@tellescope/sdk 1.256.16 → 2.0.0-beta.1

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

@@ -0,0 +1,345 @@
+require('source-map-support').install();
+
+import {
+  assert_checks,
+  Check,
+  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)
+
+/**
+ * End-to-end coverage for "contains" title matching on the `Problem Created` and `Order Created`
+ * automation triggers — the optional `titlePartials` (case sensitive) and `titlePartialsIgnoreCase`
+ * lists that sit beside the existing exact `titles` list.
+ *
+ * Three backend call sites implement this and they must agree:
+ *   - handle_problems_create           (enduser_problems.ts — single AND bulk problem creates)
+ *   - handle_order_created             (automation_triggers.ts — orders created ONE at a time)
+ *   - handle_orders_create bulk branch (enduser_orders.ts — orders created via createSome, >1)
+ *
+ * The order paths diverge structurally (`created.length === 1` takes an entirely different branch),
+ * so every order assertion here is made twice: once through `createOne` and once through a
+ * `createSome` of more than one record. That divergence is the main risk in this change.
+ *
+ * Own tenant: automation triggers are business-wide, so a shared tenant would let these triggers tag
+ * other concurrently running suites' endusers and vice versa. Never calls sdk.reset_db().
+ *
+ * Trigger actions are fire-and-forget, so positives poll. Negatives wait for a catch-all sentinel
+ * trigger (one with no title filter at all, which must fire for every record) to land first, then
+ * settle before reading — otherwise "the tag is absent" would just mean "the tag has not arrived
+ * yet".
+ */
+
+const poll_for = async <T,>(get: () => Promise<T>, done: (v: T) => boolean, attempts=24): Promise<T> => {
+  let value = await get()
+  for (let i = 0; i < attempts && !done(value); i++) {
+    await new Promise(resolve => setTimeout(resolve, 250))
+    value = await get()
+  }
+  return value
+}
+
+const wait = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
+
+export const trigger_contains_matching_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: `ContainsTriggers ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    /* ============================ triggers ============================ */
+
+    const trigger = (
+      title: string,
+      event: any,
+      tag: string,
+    ) => sdk.api.automation_triggers.createOne({
+      title,
+      status: 'Active',
+      event,
+      action: { type: 'Add Tags', info: { tags: [tag] } },
+    })
+
+    await Promise.all([
+      // ---- Order Created ----
+      // fires for every order — the sentinel that tells a negative check "the handler has run"
+      trigger('Order any', { type: 'Order Created', info: {} }, 'order-any'),
+      trigger('Order contains CS', { type: 'Order Created', info: { titlePartials: ['Semaglutide'] } }, 'order-cs'),
+      trigger('Order contains CI', { type: 'Order Created', info: { titlePartialsIgnoreCase: ['semaglutide'] } }, 'order-ci'),
+      // exact titles AND a contains fragment — both must pass
+      trigger(
+        'Order exact AND contains',
+        { type: 'Order Created', info: { titles: ['Semaglutide 0.25mg'], titlePartials: ['Sema'] } },
+        'order-and',
+      ),
+      // exact-only, unchanged prior behaviour
+      trigger('Order exact only', { type: 'Order Created', info: { titles: ['Semaglutide 0.25mg'] } }, 'order-exact'),
+
+      // ---- Problem Created ----
+      trigger('Problem any', { type: 'Problem Created', info: {} }, 'problem-any'),
+      trigger('Problem contains CS', { type: 'Problem Created', info: { titlePartials: ['Endometriosis'] } }, 'problem-cs'),
+      trigger('Problem contains CI', { type: 'Problem Created', info: { titlePartialsIgnoreCase: ['endometriosis'] } }, 'problem-ci'),
+      trigger(
+        'Problem exact AND contains',
+        { type: 'Problem Created', info: { titles: ['Endometriosis, unspecified'], titlePartials: ['Endo'] } },
+        'problem-and',
+      ),
+      trigger('Problem exact only', { type: 'Problem Created', info: { titles: ['Diabetes'] } }, 'problem-exact'),
+      // entries are trimmed before matching
+      trigger('Problem contains padded', { type: 'Problem Created', info: { titlePartials: ['  Endo  '] } }, 'problem-padded'),
+      // a blank sibling entry is dropped, not treated as "matches everything"
+      trigger(
+        'Problem contains with blank entry',
+        { type: 'Problem Created', info: { titlePartials: ['Endometriosis', '   '] } },
+        'problem-blankentry',
+      ),
+    ])
+
+    /* ============================ helpers ============================ */
+
+    const new_enduser = (fname: string) => sdk.api.endusers.createOne({ fname, lname: 'Contains' })
+
+    /** enduser_orders requires externalId/source/status; none of them affect title matching. */
+    const order_fields = (enduserId: string, title: string) => ({
+      enduserId,
+      title,
+      externalId: `contains-${RAND()}`,
+      source: 'ContainsQA',
+      status: 'created',
+    })
+
+    /** Polls until the sentinel tag has landed, then settles so absent tags mean absent. */
+    const tags_after_settling = async (enduserId: string, sentinel: string) => {
+      await poll_for(
+        () => sdk.api.endusers.getOne(enduserId),
+        e => !!e.tags?.includes(sentinel),
+      )
+      await wait(1500)
+      const e = await sdk.api.endusers.getOne(enduserId)
+      return e.tags ?? []
+    }
+
+    const expect_tags = async (
+      label: string,
+      enduserId: string,
+      sentinel: string,
+      expected: string[],
+      unexpected: string[],
+    ) => {
+      // give the positives a chance to arrive before the sentinel settle window closes
+      await poll_for(
+        () => sdk.api.endusers.getOne(enduserId),
+        e => expected.every(t => e.tags?.includes(t)),
+      )
+      const tags = await tags_after_settling(enduserId, sentinel)
+      const missing = expected.filter(t => !tags.includes(t))
+      const present = unexpected.filter(t => tags.includes(t))
+      record(
+        label,
+        missing.length === 0 && present.length === 0,
+        `tags=${JSON.stringify(tags)}`
+        + (missing.length ? ` MISSING=${JSON.stringify(missing)}` : '')
+        + (present.length ? ` UNEXPECTED=${JSON.stringify(present)}` : ''),
+      )
+    }
+
+    /* ============================ orders: single-create path ============================ */
+
+    const orderSingleMatch = await new_enduser('OrderSingleMatch')
+    await sdk.api.enduser_orders.createOne(order_fields(orderSingleMatch.id, 'Semaglutide 0.25mg'))
+    await expect_tags(
+      'A1: single-created order matching both contains lists and the exact title fires all four triggers',
+      orderSingleMatch.id, 'order-any',
+      ['order-any', 'order-cs', 'order-ci', 'order-and', 'order-exact'],
+      [],
+    )
+
+    const orderSingleCase = await new_enduser('OrderSingleCase')
+    await sdk.api.enduser_orders.createOne(order_fields(orderSingleCase.id, 'SEMAGLUTIDE injection'))
+    await expect_tags(
+      'A2: single-created order in a different case fires only the case-insensitive contains trigger',
+      orderSingleCase.id, 'order-any',
+      ['order-any', 'order-ci'],
+      ['order-cs', 'order-and', 'order-exact'],
+    )
+
+    const orderSingleMiss = await new_enduser('OrderSingleMiss')
+    await sdk.api.enduser_orders.createOne(order_fields(orderSingleMiss.id, 'Tirzepatide 5mg'))
+    await expect_tags(
+      'A3: single-created order matching no contains entry fires only the unfiltered trigger',
+      orderSingleMiss.id, 'order-any',
+      ['order-any'],
+      ['order-cs', 'order-ci', 'order-and', 'order-exact'],
+    )
+
+    const orderSingleAndMiss = await new_enduser('OrderSingleAndMiss')
+    // contains 'Sema' but is not exactly 'Semaglutide 0.25mg' — the lists AND, they do not OR
+    await sdk.api.enduser_orders.createOne(order_fields(orderSingleAndMiss.id, 'Semaglutide 1mg'))
+    await expect_tags(
+      'A4: exact+contains trigger does NOT fire when only the contains half matches (single create)',
+      orderSingleAndMiss.id, 'order-any',
+      ['order-any', 'order-cs', 'order-ci'],
+      ['order-and', 'order-exact'],
+    )
+
+    /* ============================ orders: bulk-create path ============================ */
+    /* createSome with more than one record takes handle_orders_create's bulk branch, which is a
+     * separate implementation of the same filtering. Same four assertions, same expectations. */
+
+    const [bulkMatch, bulkCase, bulkMiss, bulkAndMiss] = await Promise.all([
+      new_enduser('OrderBulkMatch'),
+      new_enduser('OrderBulkCase'),
+      new_enduser('OrderBulkMiss'),
+      new_enduser('OrderBulkAndMiss'),
+    ])
+
+    await sdk.api.enduser_orders.createSome([
+      order_fields(bulkMatch.id, 'Semaglutide 0.25mg'),
+      order_fields(bulkCase.id, 'SEMAGLUTIDE injection'),
+      order_fields(bulkMiss.id, 'Tirzepatide 5mg'),
+      order_fields(bulkAndMiss.id, 'Semaglutide 1mg'),
+    ])
+
+    await expect_tags(
+      'B1: bulk-created order matching both contains lists and the exact title fires all four triggers',
+      bulkMatch.id, 'order-any',
+      ['order-any', 'order-cs', 'order-ci', 'order-and', 'order-exact'],
+      [],
+    )
+    await expect_tags(
+      'B2: bulk-created order in a different case fires only the case-insensitive contains trigger',
+      bulkCase.id, 'order-any',
+      ['order-any', 'order-ci'],
+      ['order-cs', 'order-and', 'order-exact'],
+    )
+    await expect_tags(
+      'B3: bulk-created order matching no contains entry fires only the unfiltered trigger',
+      bulkMiss.id, 'order-any',
+      ['order-any'],
+      ['order-cs', 'order-ci', 'order-and', 'order-exact'],
+    )
+    await expect_tags(
+      'B4: exact+contains trigger does NOT fire when only the contains half matches (bulk create)',
+      bulkAndMiss.id, 'order-any',
+      ['order-any', 'order-cs', 'order-ci'],
+      ['order-and', 'order-exact'],
+    )
+
+    /* ============================ problems ============================ */
+
+    const problemMatch = await new_enduser('ProblemMatch')
+    await sdk.api.enduser_problems.createOne({ enduserId: problemMatch.id, title: 'Endometriosis, unspecified' })
+    await expect_tags(
+      'C1: problem whose title contains the case-sensitive fragment fires the contains triggers',
+      problemMatch.id, 'problem-any',
+      ['problem-any', 'problem-cs', 'problem-ci', 'problem-and', 'problem-padded', 'problem-blankentry'],
+      ['problem-exact'],
+    )
+
+    const problemCase = await new_enduser('ProblemCase')
+    await sdk.api.enduser_problems.createOne({ enduserId: problemCase.id, title: 'Chronic endometriosis pain' })
+    await expect_tags(
+      'C2: a lowercase title fires the case-insensitive trigger but not the case-sensitive one',
+      problemCase.id, 'problem-any',
+      ['problem-any', 'problem-ci'],
+      ['problem-cs', 'problem-and', 'problem-blankentry', 'problem-exact'],
+    )
+
+    const problemAndMiss = await new_enduser('ProblemAndMiss')
+    // contains 'Endo' (so the padded trigger fires) but is not the exact title the AND trigger needs
+    await sdk.api.enduser_problems.createOne({ enduserId: problemAndMiss.id, title: 'Endometrial hyperplasia' })
+    await expect_tags(
+      'C3: exact+contains problem trigger does NOT fire on a title that only satisfies the contains half',
+      problemAndMiss.id, 'problem-any',
+      ['problem-any', 'problem-padded'],
+      ['problem-and', 'problem-cs', 'problem-ci', 'problem-blankentry', 'problem-exact'],
+    )
+
+    const problemBlank = await new_enduser('ProblemBlank')
+    await sdk.api.enduser_problems.createOne({ enduserId: problemBlank.id, title: 'Common cold' })
+    await expect_tags(
+      'C4: a blank entry beside a real one does not make the trigger fire on an unrelated title',
+      problemBlank.id, 'problem-any',
+      ['problem-any'],
+      ['problem-blankentry', 'problem-cs', 'problem-ci', 'problem-and', 'problem-padded', 'problem-exact'],
+    )
+
+    /* ---- problems created in bulk (the EHR-sync shape) take the same handler with created.length > 1 ---- */
+
+    const [problemBulkMatch, problemBulkMiss] = await Promise.all([
+      new_enduser('ProblemBulkMatch'),
+      new_enduser('ProblemBulkMiss'),
+    ])
+    await sdk.api.enduser_problems.createSome([
+      { enduserId: problemBulkMatch.id, title: 'Endometriosis, unspecified' },
+      { enduserId: problemBulkMiss.id, title: 'Common cold' },
+    ])
+    await expect_tags(
+      'D1: bulk-created problem matching the contains lists fires the same triggers as a single create',
+      problemBulkMatch.id, 'problem-any',
+      ['problem-any', 'problem-cs', 'problem-ci', 'problem-and', 'problem-padded', 'problem-blankentry'],
+      ['problem-exact'],
+    )
+    await expect_tags(
+      'D2: an unrelated problem in the same bulk create fires only the unfiltered trigger',
+      problemBulkMiss.id, 'problem-any',
+      ['problem-any'],
+      ['problem-cs', 'problem-ci', 'problem-and', 'problem-padded', 'problem-blankentry'],
+    )
+
+    /* ============================ regression: exact matching unchanged ============================ */
+
+    const exactHit = await new_enduser('ExactHit')
+    await sdk.api.enduser_problems.createOne({ enduserId: exactHit.id, title: 'Diabetes' })
+    await expect_tags(
+      'E1: an exact-titles-only trigger still fires on an exactly matching title',
+      exactHit.id, 'problem-any',
+      ['problem-any', 'problem-exact'],
+      ['problem-cs', 'problem-ci', 'problem-and', 'problem-padded', 'problem-blankentry'],
+    )
+
+    const exactMiss = await new_enduser('ExactMiss')
+    await sdk.api.enduser_problems.createOne({ enduserId: exactMiss.id, title: 'Diabetes mellitus type 2' })
+    await expect_tags(
+      'E2: an exact-titles-only trigger still does NOT fire on a superstring of its title',
+      exactMiss.id, 'problem-any',
+      ['problem-any'],
+      ['problem-exact', 'problem-cs', 'problem-ci', 'problem-and', 'problem-padded', 'problem-blankentry'],
+    )
+  } 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) } }
+  }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const trigger_contains_matching_tests = async () => {
+  assert_checks('Trigger contains title matching', await trigger_contains_matching_checks())
+}
+
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  trigger_contains_matching_tests()
+    .then(() => {
+      console.log("✅ Trigger contains matching test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Trigger contains matching test suite failed:", error)
+      process.exit(1)
+    })
+}