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

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

@@ -0,0 +1,541 @@
+require('source-map-support').install();
+
+import { EnduserSession, Session } from "../../sdk"
+import {
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * Coverage for the Phone Embed backend, `sms_messages.leave_message` (api/v1/api.ts) — the endpoint
+ * behind the "Leave a note, and we will text you back soon" widget.
+ *
+ * Two changes are under test:
+ *
+ *   1. Matching. Historically phone-only: a submission from a number that already existed was filed
+ *      onto that contact no matter whose name was typed. Now, for orgs that have opted into
+ *      `settings.endusers.matchEmailAndNames`, phone AND fname AND lname must all match, compared
+ *      through `nameMatchValue` so `settings.endusers.caseInsensitiveMatching` applies exactly as it
+ *      does to public form intake. Both settings OFF must behave exactly as before.
+ *
+ *   2. The "Incoming Message" automation trigger. Submissions used to fire only "Contact Created" and
+ *      "Field Equals"; they now go through `handleIncomingCommunication` with channel 'SMS' and NO
+ *      destination, so unfiltered and SMS-filtered triggers fire while destination-filtered and
+ *      Email-filtered ones stay silent.
+ *
+ * Fixture warning, inherited from public_form_case_insensitive_match: `nameValidator` applies
+ * `first_letter_capitalized`, so a submitted "carol" is already stored as "Carol" and a
+ * "carol"/"Carol" fixture would pass with the setting OFF, proving nothing. The case-insensitive
+ * cases here differ AFTER the first letter ("MCDONALD" vs "mcdonald" -> "Mcdonald").
+ *
+ * `setup_isolated` rather than `setup_tests` because this flips ORGANIZATION settings, which on the
+ * shared fixture org would change behavior under every concurrently running suite, and because it
+ * asserts on "how many contacts carry this phone number", which needs a tenant nobody else writes to.
+ *
+ * RATE LIMIT: `leave_message` is throttled per IP at 10/min and 50/hour (`enduser-leave_message-ip`).
+ * Every submission in this suite comes from one IP, so the post count is kept to 8 deliberately — see
+ * POST_BUDGET below. Adding a submission risks 429ing the run rather than failing a check.
+ *
+ * Runs standalone or as part of the main suite:
+ *   npm run test:modular -- api_tests/phone_embed_leave_message
+ */
+
+/** Hard ceiling this suite stays under; `leave_message` allows 10 posts per minute per IP. */
+const POST_BUDGET = 8
+
+/** Polls until `check` returns truthy or the budget runs out. The endpoint responds 204 before its
+ *  trigger work finishes (handleIncomingCommunication is deliberately not awaited), so every
+ *  assertion about a trigger's effect has to wait for it. Returns the last value either way, so a
+ *  timeout produces a failed check with real evidence rather than a thrown error. */
+const pollFor = async <T>(
+  describe: string,
+  read: () => Promise<T>,
+  check: (value: T) => boolean,
+  { timeoutMs = 15_000, intervalMs = 500 } = {},
+): Promise<T> => {
+  const deadline = Date.now() + timeoutMs
+  let last = await read()
+  while (!check(last) && Date.now() < deadline) {
+    await new Promise(resolve => setTimeout(resolve, intervalMs))
+    last = await read()
+  }
+  if (!check(last)) console.log(`    (timed out waiting for ${describe} after ${timeoutMs}ms)`)
+  return last
+}
+
+export const phone_embed_leave_message_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: `PhoneEmbedLeaveMessage ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk, businessId } = tenant
+
+    /* ---------------------------------------------------------------- helpers */
+
+    let posts = 0
+    /** One Phone Embed submission, exactly as the widget makes it (unauthenticated EnduserSession). */
+    const submit = async (fname: string, lname: string, phone: string, message: string) => {
+      posts += 1
+      if (posts > POST_BUDGET) {
+        throw new Error(`Suite exceeded its ${POST_BUDGET}-post budget; the per-IP throttle will 429`)
+      }
+      const enduserSDK = new EnduserSession({ host, businessId })
+      await enduserSDK.api.sms_messages.leave_message({ businessId, fname, lname, phone, message })
+    }
+
+    /** Every contact in the tenant carrying this phone number. The matcher's observable output: one
+     *  contact means the submission matched, two means it inserted a second record. */
+    const contactsWithPhone = async (phone: string) => (
+      await sdk.api.endusers.getSome({ filter: { phone } })
+    )
+
+    /** Inbound notes filed onto one contact, newest last. */
+    const messagesFor = async (enduserId: string) => (
+      await sdk.api.sms_messages.getSome({ filter: { enduserId } })
+    )
+
+    /** Writes BOTH flags every time. Writing only one would be ambiguous about whether the update
+     *  merges into `settings.endusers` or replaces it, and this suite needs them on simultaneously. */
+    const setSettings = async (matchEmailAndNames: boolean, caseInsensitiveMatching: boolean) => {
+      await sdk.api.organizations.updateOne(businessId, {
+        settings: { endusers: { matchEmailAndNames, caseInsensitiveMatching } },
+      })
+      const after = await sdk.api.organizations.getOne(businessId)
+      record(
+        `fixture: settings applied (matchEmailAndNames=${matchEmailAndNames}, caseInsensitive=${caseInsensitiveMatching})`,
+        after.settings?.endusers?.matchEmailAndNames === matchEmailAndNames
+          && after.settings?.endusers?.caseInsensitiveMatching === caseInsensitiveMatching,
+        `org now reports matchEmailAndNames=${after.settings?.endusers?.matchEmailAndNames}, `
+        + `caseInsensitiveMatching=${after.settings?.endusers?.caseInsensitiveMatching} `
+        + `(if these disagree every check in the section below is vacuous)`,
+      )
+    }
+
+    /* ------------------------------------------- triggers, created before any submission */
+
+    const TAG_ANY = `embed-any-${RAND()}`
+    const TAG_SMS = `embed-sms-${RAND()}`
+    const TAG_EMAIL = `embed-email-${RAND()}`
+    const TAG_DESTINATION = `embed-destination-${RAND()}`
+    const TAG_CREATED = `embed-created-${RAND()}`
+
+    const addTagsTrigger = async (title: string, event: any, tag: string) => (
+      await sdk.api.automation_triggers.createOne({
+        title: `${title} ${RAND()}`,
+        status: 'Active',
+        event,
+        action: { type: 'Add Tags', info: { tags: [tag] } },
+      })
+    )
+
+    await addTagsTrigger('Embed incoming, unfiltered', { type: 'Incoming Message', info: {} }, TAG_ANY)
+    await addTagsTrigger('Embed incoming, SMS only', { type: 'Incoming Message', info: { channels: ['SMS'] } }, TAG_SMS)
+    await addTagsTrigger('Embed incoming, Email only', { type: 'Incoming Message', info: { channels: ['Email'] } }, TAG_EMAIL)
+    await addTagsTrigger(
+      'Embed incoming, destination filtered',
+      { type: 'Incoming Message', info: { destinations: ['+15005550123'] } },
+      TAG_DESTINATION,
+    )
+    await addTagsTrigger('Embed contact created', { type: 'Contact Created', info: {} }, TAG_CREATED)
+
+    // Executable guard for the journey-removal race. `handleIncomingCommunication` runs
+    // `handleRemoveFromJourneysForIncomingCommunication`, which strips a contact out of every journey
+    // marked `onIncomingEnduserCommunication: 'Remove'`. The handler passes it the enduser object it
+    // already has, and for a BRAND-NEW contact that object carries no journeys, so the removal no-ops
+    // and the contact stays in the journey "Contact Created" is concurrently adding them to.
+    //
+    // This is the only check that would fail if a future edit replaced `enduser: result` with a
+    // re-read of the contact — a comment alone cannot catch that. Both halves are asserted below,
+    // against the two submissions section 1 already makes, so this costs no extra posts:
+    //   new contact  -> removal no-ops, contact STAYS in the journey
+    //   matched one  -> removal really runs, contact is REMOVED (Twilio inbound-webhook parity)
+    const removeOnIncomingJourney = await sdk.api.journeys.createOne({
+      title: `Embed Remove On Incoming ${RAND()}`,
+      onIncomingEnduserCommunication: 'Remove',
+    })
+    await sdk.api.automation_triggers.createOne({
+      title: `Embed add to remove-on-incoming journey ${RAND()}`,
+      status: 'Active',
+      event: { type: 'Contact Created', info: {} },
+      action: { type: 'Add To Journey', info: { journeyId: removeOnIncomingJourney.id } },
+    })
+
+    const inRemoveJourney = async (enduserId: string) => (
+      Object.keys((await sdk.api.endusers.getOne(enduserId)).journeys ?? {})
+        .includes(removeOnIncomingJourney.id)
+    )
+
+    /* ======== 1. both settings OFF: unchanged legacy behavior, plus the new trigger ======== */
+
+    await setSettings(false, false)
+
+    const PHONE_LEGACY = '+15005550101'
+    {
+      /** Captured after the first submission so the second (a MATCH) can be shown to advance it. */
+      let stampBeforeMatch: Date | string | undefined
+
+      await submit('Alice', 'Smith', PHONE_LEGACY, 'off note one')
+
+      const afterFirst = await pollFor(
+        'the first submission to create a contact',
+        () => contactsWithPhone(PHONE_LEGACY),
+        found => found.length >= 1,
+      )
+      record(
+        'settings OFF: a submission from an unknown number creates a contact',
+        afterFirst.length === 1 && afterFirst[0].fname === 'Alice' && afterFirst[0].lname === 'Smith',
+        `contacts on ${PHONE_LEGACY}: ${afterFirst.length} `
+        + `(${afterFirst.map(e => `${e.fname} ${e.lname}`).join(', ') || 'none'}); expected exactly one Alice Smith`,
+      )
+
+      const alice = afterFirst[0]
+
+      if (alice) {
+        const notes = await messagesFor(alice.id)
+        record(
+          'the note is filed as an inbound, log-only SMS (so the patient is never texted it back)',
+          notes.length === 1 && notes[0].inbound === true && notes[0].logOnly === true
+            && notes[0].message === 'off note one',
+          `messages=${notes.length}: ${JSON.stringify(notes.map(n => ({ m: n.message, inbound: n.inbound, logOnly: n.logOnly })))}`,
+        )
+
+        // The trigger work runs after the 204, so poll for the unfiltered tag before reading the rest.
+        const tagged = await pollFor(
+          'the Incoming Message trigger to fire',
+          async () => (await sdk.api.endusers.getOne(alice.id)).tags ?? [],
+          tags => tags.includes(TAG_ANY),
+        )
+
+        record(
+          'an unfiltered Incoming Message trigger FIRES for an embed submission (the headline ask)',
+          tagged.includes(TAG_ANY),
+          `tags on the contact: ${JSON.stringify(tagged)}; expected to contain ${TAG_ANY}`,
+        )
+        record(
+          'an Incoming Message trigger filtered to channel SMS fires',
+          tagged.includes(TAG_SMS),
+          `tags on the contact: ${JSON.stringify(tagged)}; expected to contain ${TAG_SMS}`,
+        )
+        record(
+          'an Incoming Message trigger filtered to channel Email does NOT fire',
+          !tagged.includes(TAG_EMAIL),
+          `tags on the contact: ${JSON.stringify(tagged)}; must NOT contain ${TAG_EMAIL}`,
+        )
+        record(
+          'an Incoming Message trigger filtered to a DESTINATION stays silent (no Twilio number is involved)',
+          !tagged.includes(TAG_DESTINATION),
+          `tags on the contact: ${JSON.stringify(tagged)}; must NOT contain ${TAG_DESTINATION}`,
+        )
+        record(
+          'the Contact Created trigger still fires for a contact the submission created (regression)',
+          tagged.includes(TAG_CREATED),
+          `tags on the contact: ${JSON.stringify(tagged)}; expected to contain ${TAG_CREATED}`,
+        )
+
+        const stamped = await sdk.api.endusers.getOne(alice.id)
+        record(
+          'recentInboundSMSAt is stamped, so the contact sorts as recently active in the inbox',
+          !!stamped.recentInboundSMSAt,
+          `recentInboundSMSAt=${JSON.stringify(stamped.recentInboundSMSAt)}`,
+        )
+        stampBeforeMatch = stamped.recentInboundSMSAt
+
+        // half one of the race guard: the contact "Contact Created" just added must still be there
+        await pollFor(
+          'the Contact Created trigger to add the new contact to the remove-on-incoming journey',
+          () => inRemoveJourney(alice.id),
+          present => present,
+        )
+        // settle, so a removal that fired slightly late would still be caught rather than missed
+        await new Promise(resolve => setTimeout(resolve, 2_000))
+        record(
+          'a brand-new contact is NOT stripped from the journey Contact Created just added them to',
+          await inRemoveJourney(alice.id),
+          `contact ${alice.id} must still be in journey ${removeOnIncomingJourney.id}; `
+          + `journeys=${JSON.stringify(Object.keys((await sdk.api.endusers.getOne(alice.id)).journeys ?? {}))}`,
+        )
+      }
+
+      // The legacy carve-out: with the setting OFF a DIFFERENT name on the same number must still
+      // match, exactly as it has for years. This is the regression that proves the gate works.
+      await submit('Bob', 'Jones', PHONE_LEGACY, 'off note two')
+
+      // A direct read, not a poll: the handler commits the match-or-insert decision BEFORE it answers
+      // 204, so the contact count is already final here. Only the trigger and stamp writes lag.
+      const afterSecond = await contactsWithPhone(PHONE_LEGACY)
+      record(
+        'settings OFF: a DIFFERENT name on the same number still matches (no second contact) — unchanged',
+        afterSecond.length === 1,
+        `contacts on ${PHONE_LEGACY}: ${afterSecond.length} `
+        + `(${afterSecond.map(e => `${e.fname} ${e.lname}`).join(', ')}); expected exactly one`,
+      )
+
+      if (alice) {
+        const notes = await pollFor(
+          'the second note to land',
+          () => messagesFor(alice.id),
+          found => found.length >= 2,
+        )
+        record(
+          'settings OFF: the second note is filed onto the matched contact',
+          notes.length === 2 && notes.some(n => n.message === 'off note two'),
+          `messages on the matched contact: ${JSON.stringify(notes.map(n => n.message))}`,
+        )
+
+        // Twilio-webhook parity is about EXISTING contacts too, so assert the stamp advances on a
+        // match and not only on the insert above. The write is fire-and-forget, hence the poll.
+        const restamped = await pollFor(
+          'recentInboundSMSAt to advance on the matched contact',
+          async () => (await sdk.api.endusers.getOne(alice.id)).recentInboundSMSAt,
+          value => !!value && !!stampBeforeMatch && new Date(value) > new Date(stampBeforeMatch),
+        )
+        record(
+          'recentInboundSMSAt advances on a MATCHED contact, not just a newly created one',
+          !!restamped && !!stampBeforeMatch && new Date(restamped) > new Date(stampBeforeMatch),
+          `before=${JSON.stringify(stampBeforeMatch)}, after=${JSON.stringify(restamped)}; after must be later`,
+        )
+
+        // half two of the race guard: for an EXISTING contact the removal must really run, which is
+        // the Twilio inbound-webhook semantics. If this stopped happening, the no-op above would be
+        // masking a removal that never works at all rather than one deferred for new contacts.
+        const removed = await pollFor(
+          'the matched contact to be removed from the remove-on-incoming journey',
+          () => inRemoveJourney(alice.id),
+          present => !present,
+        )
+        record(
+          'an incoming note from an EXISTING contact DOES remove them from a remove-on-incoming journey',
+          !removed,
+          `contact ${alice.id} must no longer be in journey ${removeOnIncomingJourney.id}; `
+          + `journeys=${JSON.stringify(Object.keys((await sdk.api.endusers.getOne(alice.id)).journeys ?? {}))}`,
+        )
+      }
+    }
+
+    /* ======== 2. matchEmailAndNames ON: phone + name must both match ======== */
+
+    await setSettings(true, false)
+
+    const PHONE_NAMED = '+15005550102'
+    {
+      await submit('Carol', 'Diaz', PHONE_NAMED, 'on note one')
+      const afterFirst = await pollFor(
+        'the first named submission to create a contact',
+        () => contactsWithPhone(PHONE_NAMED),
+        found => found.length >= 1,
+      )
+      record(
+        'setting ON: an unknown number still creates a contact',
+        afterFirst.length === 1,
+        `contacts on ${PHONE_NAMED}: ${afterFirst.length}; expected exactly one`,
+      )
+      const carol = afterFirst[0]
+
+      // "fires for every org, setting or not" — section 1 proved it with the setting OFF, so prove it
+      // again with name matching ON rather than assuming the trigger path is independent of the gate.
+      if (carol) {
+        const taggedOn = await pollFor(
+          'the Incoming Message trigger to fire with matchEmailAndNames ON',
+          async () => (await sdk.api.endusers.getOne(carol.id)).tags ?? [],
+          tags => tags.includes(TAG_ANY),
+        )
+        record(
+          'the Incoming Message trigger also fires with matchEmailAndNames ON (gate is matching-only)',
+          taggedOn.includes(TAG_ANY) && taggedOn.includes(TAG_SMS) && !taggedOn.includes(TAG_DESTINATION),
+          `tags: ${JSON.stringify(taggedOn)}; expected ${TAG_ANY} and ${TAG_SMS}, and NOT ${TAG_DESTINATION}`,
+        )
+      }
+
+      // same phone, SAME name -> must match the existing record
+      await submit('Carol', 'Diaz', PHONE_NAMED, 'on note two')
+      const afterSame = await contactsWithPhone(PHONE_NAMED)
+      record(
+        'setting ON: the SAME name on the same number matches (no duplicate)',
+        afterSame.length === 1,
+        `contacts on ${PHONE_NAMED}: ${afterSame.length} `
+        + `(${afterSame.map(e => `${e.fname} ${e.lname}`).join(', ')}); expected exactly one`,
+      )
+
+      if (carol) {
+        const notes = await pollFor(
+          'both notes to land on Carol',
+          () => messagesFor(carol.id),
+          found => found.length >= 2,
+        )
+        record(
+          'setting ON: both notes from the same person land on the one contact',
+          notes.length === 2,
+          `messages on ${carol.id}: ${JSON.stringify(notes.map(n => n.message))}`,
+        )
+      }
+
+      // same phone, DIFFERENT name -> a second contact, which is the behavior change
+      await submit('Dave', 'Edwards', PHONE_NAMED, 'on note three')
+      const afterDifferent = await pollFor(
+        'the differing-name submission to create a second contact',
+        () => contactsWithPhone(PHONE_NAMED),
+        found => found.length >= 2,
+      )
+      record(
+        'setting ON: a DIFFERENT name on the same number creates a SECOND contact',
+        afterDifferent.length === 2,
+        `contacts on ${PHONE_NAMED}: ${afterDifferent.length} `
+        + `(${afterDifferent.map(e => `${e.fname} ${e.lname}`).join(', ')}); expected two`,
+      )
+
+      const dave = afterDifferent.find(e => e.fname === 'Dave' && e.lname === 'Edwards')
+      record(
+        'setting ON: the differing-name note is filed onto the NEW contact, not the existing one',
+        !!dave && (await messagesFor(dave.id)).some(n => n.message === 'on note three'),
+        dave
+          ? `messages on Dave ${dave.id}: ${JSON.stringify((await messagesFor(dave.id)).map(n => n.message))}`
+          : `no Dave Edwards contact was created on ${PHONE_NAMED}`,
+      )
+
+      if (carol) {
+        const carolNotes = await messagesFor(carol.id)
+        record(
+          'setting ON: the differing-name note did NOT leak onto the other contact',
+          !carolNotes.some(n => n.message === 'on note three'),
+          `messages on Carol ${carol.id}: ${JSON.stringify(carolNotes.map(n => n.message))}`,
+        )
+      }
+    }
+
+    /* ======== 3. a blank-name contact (what the Twilio webhook creates) is not a match ======== */
+
+    const PHONE_NAMELESS = '+15005550103'
+    {
+      // exactly the record shape the Twilio inbound-SMS webhook inserts: a phone and nothing else
+      const nameless = await sdk.api.endusers.createOne({ phone: PHONE_NAMELESS })
+      record(
+        'fixture: the nameless contact really has no name',
+        !nameless.fname && !nameless.lname,
+        `fname=${JSON.stringify(nameless.fname)}, lname=${JSON.stringify(nameless.lname)} `
+        + `(if either is set, the check below is vacuous)`,
+      )
+
+      await submit('Fiona', 'Grant', PHONE_NAMELESS, 'blank name note')
+
+      const after = await pollFor(
+        'the submission to create its own contact beside the nameless one',
+        () => contactsWithPhone(PHONE_NAMELESS),
+        found => found.length >= 2,
+      )
+      record(
+        'setting ON: a blank-name contact on the same number is NOT matched; a second contact is created',
+        after.length === 2 && after.some(e => e.fname === 'Fiona' && e.lname === 'Grant'),
+        `contacts on ${PHONE_NAMELESS}: ${after.length} `
+        + `(${after.map(e => `${JSON.stringify(e.fname)} ${JSON.stringify(e.lname)}`).join(', ')}); `
+        + `expected two, one of them Fiona Grant`,
+      )
+
+      const namelessAfter = await sdk.api.endusers.getOne(nameless.id)
+      record(
+        'setting ON: the nameless contact is left untouched — no name is written onto it',
+        !namelessAfter.fname && !namelessAfter.lname,
+        `the nameless contact now reads fname=${JSON.stringify(namelessAfter.fname)}, `
+        + `lname=${JSON.stringify(namelessAfter.lname)}; both must still be empty`,
+      )
+      record(
+        'setting ON: the note did not land on the nameless contact',
+        !(await messagesFor(nameless.id)).some(n => n.message === 'blank name note'),
+        `messages on the nameless contact: `
+        + `${JSON.stringify((await messagesFor(nameless.id)).map(n => n.message))}`,
+      )
+    }
+
+    /* ======== 4/5. caseInsensitiveMatching governs the name comparison ======== */
+
+    const PHONE_CASE = '+15005550104'
+    {
+      // "MCDONALD" survives nameValidator verbatim — it only capitalizes the FIRST letter, so the
+      // difference here is after letter one and a submitted "mcdonald" becomes "Mcdonald".
+      const stored = await sdk.api.endusers.createOne({ fname: 'Ian', lname: 'MCDONALD', phone: PHONE_CASE })
+      record(
+        'fixture: a non-first-letter capitalization variant is stored verbatim',
+        stored.lname === 'MCDONALD',
+        `stored lname=${JSON.stringify(stored.lname)} (if this is not MCDONALD both checks below are vacuous)`,
+      )
+
+      await setSettings(true, true)
+      await submit('Ian', 'mcdonald', PHONE_CASE, 'case note one')
+
+      const afterInsensitive = await contactsWithPhone(PHONE_CASE)
+      record(
+        'caseInsensitiveMatching ON: "mcdonald" matches stored "MCDONALD" (no duplicate)',
+        afterInsensitive.length === 1,
+        `contacts on ${PHONE_CASE}: ${afterInsensitive.length} `
+        + `(${afterInsensitive.map(e => `${e.fname} ${e.lname}`).join(', ')}); expected exactly one`,
+      )
+      record(
+        'caseInsensitiveMatching ON: the matched contact keeps its own capitalization',
+        (await sdk.api.endusers.getOne(stored.id)).lname === 'MCDONALD',
+        `stored lname is now ${JSON.stringify((await sdk.api.endusers.getOne(stored.id)).lname)}, must still be "MCDONALD"`,
+      )
+
+      await setSettings(true, false)
+      await submit('Ian', 'mcdonald', PHONE_CASE, 'case note two')
+
+      const afterSensitive = await pollFor(
+        'the byte-exact submission to create a second contact',
+        () => contactsWithPhone(PHONE_CASE),
+        found => found.length >= 2,
+      )
+      record(
+        'caseInsensitiveMatching OFF: "Mcdonald" no longer matches "MCDONALD"; a second contact is created',
+        afterSensitive.length === 2,
+        `contacts on ${PHONE_CASE}: ${afterSensitive.length} `
+        + `(${afterSensitive.map(e => `${e.fname} ${e.lname}`).join(', ')}); expected two`,
+      )
+    }
+
+    record(
+      `the suite stayed within its per-IP post budget`,
+      posts <= POST_BUDGET,
+      `made ${posts} submissions, budget is ${POST_BUDGET} (the endpoint allows 10/min per IP)`,
+    )
+
+    return checks
+  } finally {
+    await tenant?.teardown()
+  }
+}
+
+/** Asserting wrapper, for standalone runs. */
+export const phone_embed_leave_message_tests = async () => {
+  assert_checks('Phone Embed leave_message', await phone_embed_leave_message_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Phone Embed leave_message',
+  run: phone_embed_leave_message_checks,
+}
+
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`Using API URL: ${host}`)
+  phone_embed_leave_message_tests()
+    .then(() => {
+      console.log("Phone Embed leave_message test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("Phone Embed leave_message test suite failed:", error)
+      process.exit(1)
+    })
+}