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

package/src/tests/unit_tests/isolated_suite_discovery.test.ts

@@ -0,0 +1,178 @@
+require('source-map-support').install();
+
+import * as fs from "fs"
+import * as path from "path"
+
+import {
+  assert,
+  log_header,
+} from "@tellescope/testing"
+
+import {
+  discover_isolated_suites,
+  isolated_suites_root,
+  parse_test_parallelism,
+  DEFAULT_TEST_PARALLELISM,
+  ISOLATED_SUITE_EXPORT,
+} from "../setup_isolated"
+
+/**
+ * Guard for the auto-discovering dispatcher (run_discovered_isolated_suites).
+ *
+ * Discovery walks the COMPILED tree (lib/cjs/tests/api_tests), so the failure mode the old
+ * hand-maintained arrays did not have is a suite that silently stops running: a `.test.ts` enrolls
+ * itself, the build no-ops, and the dispatcher never sees it. Nothing else in the suite would
+ * notice. So the first check here compares the enrolled SOURCE files against what discovery
+ * actually loaded, in both directions — a missing one means a stale build (`npm run check:build`),
+ * an extra one means a compiled orphan of a deleted test.
+ *
+ * The other two checks protect the dispatcher's own invariants: names are the only handle on a
+ * suite in the output, and a suite that is both discovered and awaited by name in tests.ts would
+ * provision its tenants and run twice.
+ */
+
+// compiled location is <sdk>/lib/cjs/tests/unit_tests, so four levels up is the package root
+const SRC_TESTS = path.resolve(__dirname, '..', '..', '..', '..', 'src', 'tests')
+
+/**
+ * Relative paths of every source file under `root` that enrolls itself, split by whether discovery
+ * could ever see it. Discovery only loads `*.test.js` under `api_tests`, so a marker anywhere else
+ * is a suite that silently never runs — hence `unreachable`, which is an error rather than a miss.
+ */
+const enrolled_source_files = (root: string) => {
+  const discoverable: string[] = []
+  const unreachable: string[] = []
+
+  const walk = (dir: string, prefix: string) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const relative = prefix ? `${prefix}/${entry.name}` : entry.name
+
+      if (entry.isDirectory()) { walk(path.join(dir, entry.name), relative); continue }
+      if (!entry.name.endsWith('.ts') || entry.name.endsWith('.d.ts')) continue
+
+      const source = fs.readFileSync(path.join(dir, entry.name), 'utf8')
+      if (!new RegExp(`^export const ${ISOLATED_SUITE_EXPORT}\\b`, 'm').test(source)) continue
+
+      const inApiTests = relative === 'api_tests' || relative.indexOf('api_tests/') === 0
+      if (inApiTests && entry.name.endsWith('.test.ts')) {
+        discoverable.push(relative.replace(/^api_tests\//, ''))
+      } else {
+        unreachable.push(relative)
+      }
+    }
+  }
+  walk(root, '')
+
+  return { discoverable: discoverable.sort(), unreachable: unreachable.sort() }
+}
+
+export const isolated_suite_discovery_unit_tests = async () => {
+  log_header("Isolated suite discovery")
+
+  const discovered = discover_isolated_suites()  // throws on a malformed descriptor or a duplicate name
+  const discoveredFiles = discovered.map(s => s.file).sort()
+
+  if (!fs.existsSync(SRC_TESTS)) {
+    // Published package, not the monorepo — there is no source tree to compare against.
+    console.log(`  SKIPPED source comparison: no source tree at ${SRC_TESTS}`)
+  } else {
+    const { discoverable, unreachable } = enrolled_source_files(SRC_TESTS)
+    const enrolled = discoverable.map(f => f.replace(/\.ts$/, '.js'))
+
+    // Scanning all of src/tests, not just api_tests: an ISOLATED_SUITE outside the discovered tree
+    // (wrong directory, or a filename that is not *.test.ts) would never run and nothing else would say so.
+    assert(
+      unreachable.length === 0,
+      `exports ${ISOLATED_SUITE_EXPORT} where discovery can never see it (must be api_tests/**/*.test.ts): ${unreachable.join(', ')}`,
+      `every ${ISOLATED_SUITE_EXPORT} in src/tests lives where discovery looks`,
+    )
+
+    const missing = enrolled.filter(f => discoveredFiles.indexOf(f) === -1)
+    const extra = discoveredFiles.filter(f => enrolled.indexOf(f) === -1)
+
+    assert(
+      missing.length === 0,
+      `enrolled in src but NOT discovered (stale lib/cjs? run npm run check:build -- --fix): ${missing.join(', ')}`,
+      `every src file exporting ${ISOLATED_SUITE_EXPORT} is discovered (${enrolled.length})`,
+    )
+    assert(
+      extra.length === 0,
+      `discovered but not enrolled in any src file (compiled orphan? delete lib/cjs and rebuild): ${extra.join(', ')}`,
+      'every discovered suite has a source file',
+    )
+  }
+
+  assert(discovered.length > 0, `no isolated suites discovered under ${isolated_suites_root()}`, 'suites were discovered')
+
+  // Names are the only handle on a suite in the run output and in a failure message.
+  const byName: Record<string, string[]> = {}
+  for (const s of discovered) {
+    byName[s.name] = (byName[s.name] || []).concat(s.file)
+  }
+  const duplicateNames = Object.keys(byName).filter(n => byName[n].length > 1)
+  assert(
+    duplicateNames.length === 0,
+    `duplicate suite names: ${duplicateNames.map(n => `${JSON.stringify(n)} in ${byName[n].join(' and ')}`).join('; ')}`,
+    `suite names are unique (${discovered.length})`,
+  )
+
+  // A discovered suite must not ALSO be awaited by name in tests.ts — that would run it twice, each
+  // run provisioning its own tenants (which can never be deleted).
+  const testsPath = path.join(SRC_TESTS, 'tests.ts')
+  if (!fs.existsSync(testsPath)) {
+    console.log(`  SKIPPED tests.ts comparison: not found at ${testsPath}`)
+  } else {
+    const testsSource = fs.readFileSync(testsPath, 'utf8')
+
+    const doubleRun: string[] = []
+    for (const suite of discovered) {
+      const loaded = require(path.join(isolated_suites_root(), suite.file))
+      for (const exported of Object.keys(loaded)) {
+        if (exported === ISOLATED_SUITE_EXPORT) continue  // every enrolled file exports this one
+        if (new RegExp(`\\bawait\\s+${exported}\\s*\\(`).test(testsSource)) {
+          doubleRun.push(`${exported} (api_tests/${suite.file}, discovered as "${suite.name}")`)
+        }
+      }
+    }
+    assert(
+      doubleRun.length === 0,
+      `awaited directly in tests.ts as well as discovered, so it would run twice: ${doubleRun.join(', ')}`,
+      'no discovered suite is also awaited directly in tests.ts',
+    )
+  }
+
+  // TEST_PARALLELISM parsing: a bad value must fall back to the default, never to "unlimited".
+  const parallelismCases: [string | undefined, number][] = [
+    [undefined, DEFAULT_TEST_PARALLELISM],
+    ['', DEFAULT_TEST_PARALLELISM],
+    ['   ', DEFAULT_TEST_PARALLELISM],
+    ['abc', DEFAULT_TEST_PARALLELISM],
+    ['0', DEFAULT_TEST_PARALLELISM],
+    ['-1', DEFAULT_TEST_PARALLELISM],
+    ['2.5', DEFAULT_TEST_PARALLELISM],
+    ['1', 1],
+    [' 3 ', 3],
+    ['16', 16],
+  ]
+  for (const [raw, expected] of parallelismCases) {
+    const actual = parse_test_parallelism(raw)
+    assert(
+      actual === expected,
+      `TEST_PARALLELISM=${JSON.stringify(raw)} parsed as ${actual}, expected ${expected}`,
+      `TEST_PARALLELISM=${JSON.stringify(raw)} → ${expected}`,
+    )
+  }
+}
+
+// Allow running this test file independently
+if (require.main === module) {
+  isolated_suite_discovery_unit_tests()
+    .then(() => {
+      console.log("Isolated suite discovery unit tests completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("Isolated suite discovery unit tests failed:", error)
+      process.exit(1)
+    })
+}

package/src/tests/unit_tests/programs_conditional_logic.test.ts

@@ -0,0 +1,189 @@
+import { evaluate_conditional_logic_for_enduser_fields, validate_custom_field_references } from "@tellescope/utilities"
+import { Enduser, EnduserProgram } from "@tellescope/types-models"
+
+/**
+ * Unit coverage for the `Programs` key in evaluate_conditional_logic_for_enduser_fields — the V1
+ * evaluator that triggers, journeys and phone-tree branches all run on.
+ *
+ * `{ Programs: { $in: 'CHF' } }` means "has a program named CHF"; adding `$status` means "...whose
+ * status is S", bound to that same program entry. Comparison is exact string throughout, matching the
+ * shipped Order Status Equals / Vital Update program filters.
+ *
+ * The round-trip between this and the saved V2 Mongo filter is covered separately, by
+ * packages/private/webapp/src/__tests__/programs_condition_filter.test.ts.
+ */
+
+let failures = 0
+let passed = 0
+
+const assert = (name: string, actual: boolean, expected: boolean) => {
+  if (actual === expected) {
+    passed++
+    console.log(`  ✓ ${name}`)
+  } else {
+    failures++
+    console.error(`  ✗ ${name} — expected ${expected}, got ${actual}`)
+  }
+}
+
+const with_programs = (programs?: EnduserProgram[]) => ({ programs } as Omit<Enduser, 'id'>)
+
+const matches = (programs: EnduserProgram[] | undefined, value: Record<string, any>) => (
+  evaluate_conditional_logic_for_enduser_fields(
+    with_programs(programs) as any,
+    { $and: [{ condition: { Programs: value } }] },
+  )
+)
+
+const CHF_ACTIVE: EnduserProgram[] = [{ name: 'CHF', status: 'active' }]
+const CHF_COMPLETED: EnduserProgram[] = [{ name: 'CHF', status: 'completed' }]
+const CHF_NO_STATUS: EnduserProgram[] = [{ name: 'CHF' }]
+const TWO: EnduserProgram[] = [{ name: 'CHF', status: 'completed' }, { name: 'Diabetes', status: 'active' }]
+
+const run_is_in_tests = () => {
+  console.log("\n[Programs / Is In]")
+
+  assert("matches a patient with that program", matches(CHF_ACTIVE, { $in: 'CHF' }), true)
+  assert("does not match a patient with a different program", matches([{ name: 'Diabetes' }], { $in: 'CHF' }), false)
+  assert("does not match a patient with no programs", matches([], { $in: 'CHF' }), false)
+  assert("does not match a patient whose programs are unset", matches(undefined, { $in: 'CHF' }), false)
+  assert("matches one program among several", matches(TWO, { $in: 'Diabetes' }), true)
+
+  // exact string comparison — deliberately NOT case-insensitive
+  assert("name comparison is case sensitive", matches(CHF_ACTIVE, { $in: 'chf' }), false)
+  assert("name comparison does not substring match", matches(CHF_ACTIVE, { $in: 'CH' }), false)
+  assert("a name with spaces and punctuation matches exactly", matches([{ name: 'Post-Op Care' }], { $in: 'Post-Op Care' }), true)
+}
+
+const run_status_tests = () => {
+  console.log("\n[Programs / $status]")
+
+  assert("name + status both match", matches(CHF_ACTIVE, { $in: 'CHF', $status: 'active' }), true)
+  assert("name matches but status does not", matches(CHF_COMPLETED, { $in: 'CHF', $status: 'active' }), false)
+  assert("status matches but name does not", matches(CHF_ACTIVE, { $in: 'Diabetes', $status: 'active' }), false)
+  assert("a program with no status is not matched by a status condition", matches(CHF_NO_STATUS, { $in: 'CHF', $status: 'active' }), false)
+  assert("a blank status means any status", matches(CHF_COMPLETED, { $in: 'CHF', $status: '' }), true)
+  assert("an omitted status means any status", matches(CHF_NO_STATUS, { $in: 'CHF' }), true)
+  assert("status comparison is case sensitive", matches(CHF_ACTIVE, { $in: 'CHF', $status: 'Active' }), false)
+
+  // name and status must come from the SAME program, which is the whole point of one paired key
+  assert(
+    "does not match when the name and the status come from different programs",
+    matches(TWO, { $in: 'CHF', $status: 'active' }),
+    false,
+  )
+
+  // $status serialised FIRST — the generic Object.keys(value)[0] operator dispatch would pick $status
+  // here and fall through to false, so the Programs branch must read $in/$nin by name
+  assert(
+    "$status before $in still evaluates as Is In",
+    matches(CHF_ACTIVE, { $status: 'active', $in: 'CHF' }),
+    true,
+  )
+  assert(
+    "$status before $nin still evaluates as Is Not In",
+    matches(CHF_ACTIVE, { $status: 'active', $nin: 'CHF' }),
+    false,
+  )
+}
+
+const run_is_not_in_tests = () => {
+  console.log("\n[Programs / Is Not In]")
+
+  assert("does not match a patient with that program", matches(CHF_ACTIVE, { $nin: 'CHF' }), false)
+  assert("matches a patient with a different program", matches([{ name: 'Diabetes' }], { $nin: 'CHF' }), true)
+  assert("matches a patient with no programs", matches([], { $nin: 'CHF' }), true)
+  assert("matches a patient whose programs are unset", matches(undefined, { $nin: 'CHF' }), true)
+
+  assert("negates the name+status pair", matches(CHF_ACTIVE, { $nin: 'CHF', $status: 'active' }), false)
+  assert("matches when the name is present but the status differs", matches(CHF_COMPLETED, { $nin: 'CHF', $status: 'active' }), true)
+}
+
+const run_unconfigured_tests = () => {
+  console.log("\n[Programs / unconfigured]")
+
+  // An unfinished condition must match nobody in BOTH directions. This deliberately DIVERGES from
+  // Journeys rather than copying it: `{ Journeys: { $nin: '' } }` matches everybody (the blank id is
+  // simply absent from enduser.journeys). Failing open on $nin would fire a trigger for every patient.
+  assert("a blank name matches nobody under Is In", matches(CHF_ACTIVE, { $in: '' }), false)
+  assert("a blank name matches nobody under Is Not In", matches(CHF_ACTIVE, { $nin: '' }), false)
+  assert("a blank name matches nobody even with no programs", matches([], { $nin: '' }), false)
+  assert("a value with no operator matches nobody", matches(CHF_ACTIVE, { $status: 'active' }), false)
+
+  // the branch is narrowed to $in/$nin, so any other object condition under a key named 'Programs'
+  // falls through to the generic custom-field handler — which is what the V2 translator does too
+  assert("a non-$in/$nin operator falls through instead of being swallowed", matches(CHF_ACTIVE, { $isSet: 'Value' }), false)
+}
+
+const run_other_conditions_unaffected = () => {
+  console.log("\n[Programs / coexistence with Care Type and Stage]")
+
+  const enduser = {
+    programs: CHF_ACTIVE,
+    fields: { 'Care Type': 'RPM', 'Care Stage': 'Onboarding' },
+  } as any
+
+  const evaluate = (conditions: Record<string, any>) => (
+    evaluate_conditional_logic_for_enduser_fields(enduser, conditions)
+  )
+
+  assert(
+    "an existing Care Type condition is unaffected",
+    evaluate({ $and: [{ condition: { 'Care Type': 'RPM' } }] }),
+    true,
+  )
+  assert(
+    "Care Stage and Programs can be combined in one filter",
+    evaluate({ $and: [{ condition: { 'Care Stage': 'Onboarding' } }, { condition: { Programs: { $in: 'CHF' } } }] }),
+    true,
+  )
+  assert(
+    "the combined filter fails when the Programs half fails",
+    evaluate({ $and: [{ condition: { 'Care Stage': 'Onboarding' } }, { condition: { Programs: { $in: 'Diabetes' } } }] }),
+    false,
+  )
+  assert(
+    "an $or over Care Type and Programs matches on either half",
+    evaluate({ $or: [{ condition: { 'Care Type': 'Nope' } }, { condition: { Programs: { $in: 'CHF' } } }] }),
+    true,
+  )
+}
+
+const run_custom_field_validation_tests = () => {
+  console.log("\n[Programs is a built-in field]")
+
+  // without 'Programs' in BUILT_IN_FIELDS, the trigger and journey validation hooks flag every program
+  // condition as a reference to a custom field that no longer exists
+  const conditions = { $and: [{ condition: { Programs: { $in: 'CHF', $status: 'active' } } }] }
+  assert(
+    "a Programs condition is not reported as a missing custom field",
+    validate_custom_field_references(conditions, new Set<string>()).length === 0,
+    true,
+  )
+  assert(
+    "a genuinely missing custom field is still reported",
+    validate_custom_field_references(
+      { $and: [{ condition: { deletedField: 'x' } }] },
+      new Set<string>(),
+    ).includes('deletedField'),
+    true,
+  )
+}
+
+const run_all = () => {
+  console.log("Running programs_conditional_logic unit tests")
+  run_is_in_tests()
+  run_status_tests()
+  run_is_not_in_tests()
+  run_unconfigured_tests()
+  run_other_conditions_unaffected()
+  run_custom_field_validation_tests()
+  console.log(`\nResults: ${passed} passed, ${failures} failed`)
+  if (failures > 0) process.exit(1)
+}
+
+if (require.main === module) {
+  run_all()
+}
+
+export { run_all as programs_conditional_logic_unit_tests }

package/src/tests/webhooks_tests.ts

@@ -756,8 +756,13 @@ const run_tests = async () => {
   log_header("Webhooks Tests")
   await sdk.authenticate(email, password)
   await sdkSub.authenticate(subUserEmail, password)
-  await reset_test_tenant(sdk) 
+  await reset_test_tenant(sdk)
   await nonAdminSdk.authenticate(nonAdminEmail, nonAdminPassword)
+  // as in setup_tests: booking cancel/reschedule below would otherwise email the host for real
+  await Promise.all([
+    sdk.api.users.updateOne(sdk.userInfo.id, { notificationEmailsDisabled: true }),
+    sdk.api.users.updateOne(nonAdminSdk.userInfo.id, { notificationEmailsDisabled: true }),
+  ]).catch(console.error)
 
   await async_test(
     'configure webhook is admin only',