@tellescope/sdk 1.250.1 → 1.251.0

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

@@ -0,0 +1,258 @@
+require('source-map-support').install();
+
+import { Session } from "../../sdk"
+import {
+  assert,
+  async_test,
+  log_header,
+  wait,
+} from "@tellescope/testing"
+import { setup_tests } from "../setup"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+const TRIGGER_TITLE_BLOCK_A = "Order Templates: Block A"
+const TRIGGER_TITLE_BLOCK_B = "Order Templates: Block B"
+
+const buildSetFieldsAction = (prefix: string) => ({
+  type: 'Set Fields' as const,
+  info: {
+    fields: [
+      { name: `${prefix}_status`,     value: '{{order.status}}',     type: 'Custom Value' as const },
+      { name: `${prefix}_tracking`,   value: '{{order.tracking}}',   type: 'Custom Value' as const },
+      { name: `${prefix}_carrier`,    value: '{{order.carrier}}',    type: 'Custom Value' as const },
+      { name: `${prefix}_sku`,        value: '{{order.sku}}',        type: 'Custom Value' as const },
+      { name: `${prefix}_externalId`, value: '{{order.externalId}}', type: 'Custom Value' as const },
+      { name: `${prefix}_id`,         value: '{{order.id}}',         type: 'Custom Value' as const },
+      { name: `${prefix}_protocol`,   value: '{{order.protocol}}',   type: 'Custom Value' as const },
+    ],
+  },
+})
+
+// Block A: Direct EnduserOrder creation path
+const direct_order_creation_block = async ({ sdk }: { sdk: Session }) => {
+  log_header("Block A: Direct EnduserOrder creation -> {{order.*}} in Set Fields")
+
+  const enduser = await sdk.api.endusers.createOne({})
+  const trigger = await sdk.api.automation_triggers.createOne({
+    title: TRIGGER_TITLE_BLOCK_A,
+    status: 'Active',
+    event: { type: 'Order Status Equals', info: { source: 'Beluga', status: 'Shipped' } },
+    action: buildSetFieldsAction('pharmacy'),
+  })
+
+  let createdOrderId: string | undefined
+  let nonMatchingOrderId: string | undefined
+
+  try {
+    const order = await sdk.api.enduser_orders.createOne({
+      enduserId: enduser.id,
+      source: 'Beluga',
+      status: 'Shipped',
+      title: 'Beluga Pharmacy Order',
+      externalId: 'EXT-A-123',
+      tracking: '1Z-AAA',
+      carrier: 'UPS',
+      sku: 'SKU-A',
+      protocol: 'wl1',
+    })
+    createdOrderId = order.id
+
+    await wait(undefined, 250) // allow trigger + Set Fields to run
+
+    await async_test(
+      "Block A: {{order.*}} templates resolve to literal values",
+      () => sdk.api.endusers.getOne(enduser.id),
+      { onResult: e => !!(
+           e.fields?.pharmacy_status === 'Shipped'
+        && e.fields?.pharmacy_tracking === '1Z-AAA'
+        && e.fields?.pharmacy_carrier === 'UPS'
+        && e.fields?.pharmacy_sku === 'SKU-A'
+        && e.fields?.pharmacy_externalId === 'EXT-A-123'
+        && e.fields?.pharmacy_protocol === 'wl1'
+        && typeof e.fields?.pharmacy_id === 'string'
+        && (e.fields?.pharmacy_id as string).length > 0
+        && (e.fields?.pharmacy_id as string) === order.id
+      )}
+    )
+
+    // Negative case: status that doesn't match the trigger should NOT alter fields
+    const beforeNonMatch = await sdk.api.endusers.getOne(enduser.id)
+    const snapshot = {
+      pharmacy_status: beforeNonMatch.fields?.pharmacy_status,
+      pharmacy_tracking: beforeNonMatch.fields?.pharmacy_tracking,
+      pharmacy_carrier: beforeNonMatch.fields?.pharmacy_carrier,
+      pharmacy_sku: beforeNonMatch.fields?.pharmacy_sku,
+      pharmacy_externalId: beforeNonMatch.fields?.pharmacy_externalId,
+      pharmacy_id: beforeNonMatch.fields?.pharmacy_id,
+      pharmacy_protocol: beforeNonMatch.fields?.pharmacy_protocol,
+    }
+
+    const nonMatching = await sdk.api.enduser_orders.createOne({
+      enduserId: enduser.id,
+      source: 'Beluga',
+      status: 'In Fulfillment', // does NOT match the trigger
+      title: 'Beluga Pharmacy Order (other status)',
+      externalId: 'EXT-A-NOMATCH',
+      tracking: 'NOPE',
+      carrier: 'NoCarrier',
+      sku: 'SKU-NOPE',
+      protocol: 'nope',
+    })
+    nonMatchingOrderId = nonMatching.id
+
+    await wait(undefined, 250)
+
+    await async_test(
+      "Block A: non-matching status leaves fields unchanged",
+      () => sdk.api.endusers.getOne(enduser.id),
+      { onResult: e => !!(
+           e.fields?.pharmacy_status === snapshot.pharmacy_status
+        && e.fields?.pharmacy_tracking === snapshot.pharmacy_tracking
+        && e.fields?.pharmacy_carrier === snapshot.pharmacy_carrier
+        && e.fields?.pharmacy_sku === snapshot.pharmacy_sku
+        && e.fields?.pharmacy_externalId === snapshot.pharmacy_externalId
+        && e.fields?.pharmacy_id === snapshot.pharmacy_id
+        && e.fields?.pharmacy_protocol === snapshot.pharmacy_protocol
+      )}
+    )
+  } finally {
+    if (createdOrderId) await sdk.api.enduser_orders.deleteOne(createdOrderId).catch(console.error)
+    if (nonMatchingOrderId) await sdk.api.enduser_orders.deleteOne(nonMatchingOrderId).catch(console.error)
+    await sdk.api.automation_triggers.deleteOne(trigger.id).catch(console.error)
+    await sdk.api.endusers.deleteOne(enduser.id).catch(console.error)
+  }
+}
+
+// Block B: Beluga webhook integration path
+const beluga_webhook_block = async ({ sdk }: { sdk: Session }) => {
+  log_header("Block B: Beluga webhook -> {{order.*}} in Set Fields")
+
+  const webhookUrl = `${host}/v1/webhooks/beluga`
+  const externalOrderId = `EXT-B-${Date.now()}`
+
+  const enduser = await sdk.api.endusers.createOne({})
+  const form = await sdk.api.forms.createOne({ title: 'Order Templates Beluga Form' })
+  const formResponse = await sdk.api.form_responses.createOne({
+    formId: form.id,
+    enduserId: enduser.id,
+    formTitle: form.title,
+  })
+
+  const trigger = await sdk.api.automation_triggers.createOne({
+    title: TRIGGER_TITLE_BLOCK_B,
+    status: 'Active',
+    event: { type: 'Order Status Equals', info: { source: 'Beluga', status: 'Shipped' } },
+    action: buildSetFieldsAction('pharmacy'),
+  })
+
+  const deliveredTrigger = await sdk.api.automation_triggers.createOne({
+    title: `${TRIGGER_TITLE_BLOCK_B} (Delivered)`,
+    status: 'Active',
+    event: { type: 'Order Status Equals', info: { source: 'Beluga', status: 'Delivered' } },
+    action: buildSetFieldsAction('pharmacy'),
+  })
+
+  try {
+    // Step 1: PHARMACY_ORDER_SHIPPED
+    const shippedRes = await fetch(webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        masterId: `tellescope_${formResponse.id}`,
+        event: 'PHARMACY_ORDER_SHIPPED',
+        orderId: externalOrderId,
+        info: { carrier: 'FedEx', tracking: '7777-BBB' },
+      }),
+    })
+    assert(shippedRes.status === 200, `Beluga webhook (shipped) expected 200, got ${shippedRes.status}`)
+
+    await wait(undefined, 250) // webhook upsert + trigger + Set Fields
+
+    await async_test(
+      "Block B: Beluga PHARMACY_ORDER_SHIPPED resolves {{order.*}} into enduser fields",
+      () => sdk.api.endusers.getOne(enduser.id),
+      { onResult: e => !!(
+           e.fields?.pharmacy_status === 'Shipped'
+        && e.fields?.pharmacy_tracking === '7777-BBB'
+        && e.fields?.pharmacy_carrier === 'FedEx'
+        && e.fields?.pharmacy_externalId === externalOrderId
+        && typeof e.fields?.pharmacy_id === 'string'
+        && (e.fields?.pharmacy_id as string).length > 0
+        // Webhook does not set sku/protocol -> default branch in helper -> ''
+        && e.fields?.pharmacy_sku === ''
+        && e.fields?.pharmacy_protocol === ''
+      )}
+    )
+
+    // Step 2: PHARMACY_ORDER_DELIVERED for the same order
+    const deliveredRes = await fetch(webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        masterId: `tellescope_${formResponse.id}`,
+        event: 'PHARMACY_ORDER_DELIVERED',
+        orderId: externalOrderId,
+      }),
+    })
+    assert(deliveredRes.status === 200, `Beluga webhook (delivered) expected 200, got ${deliveredRes.status}`)
+
+    await wait(undefined, 250)
+
+    await async_test(
+      "Block B: PHARMACY_ORDER_DELIVERED flips pharmacy_status to 'Delivered'",
+      () => sdk.api.endusers.getOne(enduser.id),
+      { onResult: e => !!(
+           e.fields?.pharmacy_status === 'Delivered'
+        && e.fields?.pharmacy_externalId === externalOrderId
+      )}
+    )
+  } finally {
+    // Clean up the order created by the webhook
+    try {
+      const orders = await sdk.api.enduser_orders.getSome({
+        filter: { source: 'Beluga', externalId: externalOrderId } as any,
+      })
+      for (const o of orders) {
+        await sdk.api.enduser_orders.deleteOne(o.id).catch(console.error)
+      }
+    } catch (err) {
+      console.error(err)
+    }
+
+    await sdk.api.automation_triggers.deleteOne(trigger.id).catch(console.error)
+    await sdk.api.automation_triggers.deleteOne(deliveredTrigger.id).catch(console.error)
+    await sdk.api.form_responses.deleteOne(formResponse.id).catch(console.error)
+    await sdk.api.forms.deleteOne(form.id).catch(console.error)
+    await sdk.api.endusers.deleteOne(enduser.id).catch(console.error)
+  }
+}
+
+export const set_fields_order_templates_tests = async (
+  { sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }
+) => {
+  log_header("Set Fields: {{order.*}} template resolution")
+  await direct_order_creation_block({ sdk })
+  await beluga_webhook_block({ sdk })
+}
+
+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 set_fields_order_templates_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("set_fields_order_templates test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("set_fields_order_templates test suite failed:", error)
+      process.exit(1)
+    })
+}

package/src/tests/setup.ts

@@ -37,9 +37,16 @@ export const setup_tests = async (sdk: Session, sdkNonAdmin: Session) => {
   // Authenticate the SDKs first
   await sdk.authenticate(email, password)
   await sdkNonAdmin.authenticate(nonAdminEmail, nonAdminPassword)
-  
+
   await async_test('test_authenticated', sdk.test_authenticated, { expectedResult: 'Authenticated!' })
 
+  // Defensive: clear residual OTP gating from a previously-aborted run of
+  // enduser_session_invalidation_tests, which would otherwise cause enduser
+  // tokens minted in subsequent tests to be rejected as Unauthenticated.
+  await sdk.api.organizations.updateOne(sdk.userInfo.businessId, {
+    portalSettings: { authentication: { requireOTP: false, requireOTPAfterPassword: false } },
+  }, { replaceObjectFields: true })
+
   await async_test(
     'test_authenticated (with API Key)', 
     (new Session({ host, apiKey: '3n5q0SCBT_iUvZz-b9BJtX7o7HQUVJ9v132PgHJNJsg.' /* local test key */  })).test_authenticated, 

package/src/tests/tests.ts

@@ -49,6 +49,7 @@ import { purchase_made_trigger_tests } from "./api_tests/purchase_made_trigger.t
 import { appointment_rescheduled_trigger_tests } from "./api_tests/appointment_rescheduled_trigger.test"
 import { journey_error_branching_tests } from "./api_tests/journey_error_branching.test"
 import { afteraction_day_of_month_delay_tests } from "./api_tests/afteraction_day_of_month_delay.test"
+import { push_forms_to_portal_group_completion_tests } from "./api_tests/push_forms_to_portal_group_completion.test"
 import { setup_tests } from "./setup"
 import { evaluate_conditional_logic_for_enduser_fields, FORM_LOGIC_CALCULATED_FIELDS, get_care_team_primary, get_flattened_fields, get_next_reminder_timestamp, object_is_empty, replace_enduser_template_values, replace_form_field_template_values, responses_satisfy_conditions, truncate_string, weighted_round_robin, YYYY_MM_DD_to_MM_DD_YYYY } from "@tellescope/utilities"
 import { DEFAULT_OPERATIONS, PLACEHOLDER_ID, ZENDESK_INTEGRATIONS_TITLE, ZOOM_TITLE } from "@tellescope/constants"
@@ -74,10 +75,12 @@ import {
 
 import fs from "fs"
 import { load_inbox_data_tests } from "./api_tests/load_inbox_data.test";
+import { enduser_login_tests } from "./api_tests/enduser_login.test";
 import { eom_procedure_codes_tests } from "./api_tests/eom_procedure_codes.test";
 import { cross_org_api_key_tests } from "./api_tests/cross_org_api_key.test";
 import { custom_dashboards_tests } from "./api_tests/custom_dashboards.test";
 import { message_assignment_trigger_tests } from "./api_tests/message_assignment_trigger.test";
+import { outbound_chat_sent_trigger_tests } from "./api_tests/outbound_chat_sent_trigger.test";
 import { time_tracks_tests, time_tracks_historical_tests, time_tracks_correction_tests, time_tracks_review_tests, time_tracks_lock_tests, time_tracks_edge_case_tests } from "./api_tests/time_tracks.test";
 import { monthly_availability_restrictions_tests } from "./api_tests/monthly_availability_restrictions.test";
 import { calendar_event_limits_tests } from "./api_tests/calendar_event_limits.test";
@@ -95,11 +98,14 @@ import { load_team_chat_tests } from "./api_tests/load_team_chat.test";
 import { form_started_trigger_tests } from "./api_tests/form_started_trigger.test";
 import { form_submitted_trigger_tests } from "./api_tests/form_submitted_trigger.test";
 import { medication_added_trigger_tests } from "./api_tests/medication_added_trigger.test";
+import { conditional_logic_medication_unit_tests } from "./unit_tests/conditional_logic_medication.test";
 import { elation_user_id_tests } from "./api_tests/elation_user_id.test";
 import { organization_settings_duplicates_tests } from "./api_tests/organization_settings_duplicates.test";
 import { calendar_events_bulk_update_tests } from "./api_tests/calendar_events_bulk_update.test";
 import { openloop_webhooks_tests } from "./api_tests/openloop_webhooks.test";
 import { beluga_pharmacy_mappings_tests } from "./api_tests/beluga_pharmacy_mappings.test";
+import { account_switcher_tests } from "./api_tests/account_switcher.test";
+import { set_fields_order_templates_tests } from "./api_tests/set_fields_order_templates.test";
 import { date_string_validation_tests } from "./api_tests/date_string_validation.test";
 import { enduser_session_invalidation_tests } from "./api_tests/enduser_session_invalidation.test";
 import { enduser_cross_access_isolation_tests } from "./api_tests/enduser_cross_access_isolation.test";
@@ -5087,6 +5093,7 @@ const automation_trigger_tests = async () => {
   log_header("Automation Trigger Tests")
 
   await order_status_equals_tests()
+  await set_fields_order_templates_tests({ sdk, sdkNonAdmin })
   await medication_added_trigger_tests({ sdk, sdkNonAdmin })
   await appointment_cancelled_tests()
   await set_fields_tests()
@@ -5095,6 +5102,7 @@ const automation_trigger_tests = async () => {
   await form_response_set_fields_trigger_tests()
   await form_response_set_fields_journey_tests()
   await appointment_completed_trigger_tests({ sdk, sdkNonAdmin })
+  await push_forms_to_portal_group_completion_tests({ sdk, sdkNonAdmin })
   await trigger_events_api_tests()
   await fields_changed_tests()
   await field_equals_trigger_tests()
@@ -7119,16 +7127,18 @@ const merge_enduser_tests = async () => {
   const stripeCustomerId = 'example_cu_id';
   const stripeKey = 'example_stripe_key';
   const [source, destination, otherEnduser] = (await sdk.api.endusers.createSome([
-    { 
-      email: 'source@tellescope.com', fname: 'source', lname: 'enduser', 
-      references: [{ type: '2', id: '2.2' }, { type: '3', id: '3.2' }, { type: '4', id: '4.2'}], 
+    {
+      email: 'source@tellescope.com', fname: 'source', lname: 'enduser',
+      references: [{ type: '2', id: '2.2' }, { type: '3', id: '3.2' }, { type: '4', id: '4.2'}],
       // @ts-ignore
       stripeCustomerId,
       stripeKey,
       athenaPracticeId: '12345',
       athenaDepartmentId: '54321',
+      insurance: { memberId: 'src-member', payerName: 'Source Payer' },
+      insuranceSecondary: { memberId: 'src-secondary' },
     },
-    { email: 'destination@tellescope.com', source: '4', externalId: "4", references: [{ type: '1', id: '1' }, { type: '2', id: '2' }] },
+    { email: 'destination@tellescope.com', source: '4', externalId: "4", references: [{ type: '1', id: '1' }, { type: '2', id: '2' }], insurance: { memberId: 'dest-member', payerName: 'Dest Payer' } },
     { email: 'other@tellescope.com'},
   ])).created
 
@@ -7177,7 +7187,10 @@ const merge_enduser_tests = async () => {
       && e.references?.find(r => r.type === '1')?.id === '1'
       && e.references?.find(r => r.type === '2')?.id === '2'
       && e.references?.find(r => r.type === '3')?.id === '3.2'
-      && !e.references?.find(r => r.type === '4')?.id 
+      && !e.references?.find(r => r.type === '4')?.id
+      && e.insurance?.memberId === 'dest-member'
+      && e.insurance?.payerName === 'Dest Payer'
+      && e.insuranceSecondary?.memberId === 'src-secondary'
     )}
   )
     
@@ -14303,10 +14316,15 @@ const ip_address_form_tests = async () => {
 
 
     await enduser_conditional_logic_tests()
+    await conditional_logic_medication_unit_tests()
     await replace_enduser_template_values_tests()
     await replace_form_field_template_values_tests()
     await mfa_tests()
     await setup_tests(sdk, sdkNonAdmin)
+    await account_switcher_tests({ sdk, sdkNonAdmin })
+    await enduser_login_tests({ sdk, sdkNonAdmin })
+    await outbound_chat_sent_trigger_tests({ sdk })
+    await automation_trigger_tests()
     await enduser_cross_access_isolation_tests({ sdk, sdkNonAdmin })
     await eom_procedure_codes_tests({ sdk, sdkNonAdmin })
     await cross_org_api_key_tests({ sdk, sdkNonAdmin })
@@ -14317,7 +14335,6 @@ const ip_address_form_tests = async () => {
     await form_submitted_trigger_tests({ sdk, sdkNonAdmin })
     await date_string_validation_tests({ sdk, sdkNonAdmin })
     await openloop_webhooks_tests({ sdk, sdkNonAdmin })
-    await automation_trigger_tests()
     await integrations_redacted_tests({ sdk, sdkNonAdmin })
     await mdb_sort_tests({ sdk, sdkNonAdmin })
     await search_tests()

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

@@ -0,0 +1,133 @@
+import {
+  evaluate_conditional_logic_for_medication_title,
+  evaluate_string_field_comparison,
+} from "@tellescope/utilities"
+import { CompoundFilter } from "@tellescope/types-models"
+
+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 run_string_comparison_tests = () => {
+  console.log("\n[evaluate_string_field_comparison]")
+
+  // Plain-string equals (implicit operator)
+  assert("equals plain string match", evaluate_string_field_comparison('Aspirin', 'Aspirin'), true)
+  assert("equals plain string mismatch", evaluate_string_field_comparison('Aspirin', 'Lisinopril'), false)
+  assert("equals empty string against empty title", evaluate_string_field_comparison('', ''), true)
+  assert("equals empty string against undefined title", evaluate_string_field_comparison(undefined, ''), true)
+
+  // $ne
+  assert("$ne matches when different", evaluate_string_field_comparison('Aspirin', { $ne: 'Lisinopril' }), true)
+  assert("$ne fails when equal", evaluate_string_field_comparison('Aspirin', { $ne: 'Aspirin' }), false)
+
+  // $contains (case sensitive — consistent with enduser/form-response evaluators)
+  assert("$contains substring match", evaluate_string_field_comparison('Semaglutide GLP-1', { $contains: 'GLP' }), true)
+  assert("$contains case sensitive miss", evaluate_string_field_comparison('Lisinopril 10MG', { $contains: 'mg' }), false)
+  assert("$contains case sensitive match", evaluate_string_field_comparison('Lisinopril 10mg', { $contains: 'mg' }), true)
+  assert("$contains no match", evaluate_string_field_comparison('Aspirin', { $contains: 'GLP' }), false)
+  assert("$contains empty string is always true", evaluate_string_field_comparison('Aspirin', { $contains: '' }), true)
+
+  // $doesNotContain
+  assert("$doesNotContain mismatch true", evaluate_string_field_comparison('Aspirin', { $doesNotContain: 'GLP' }), true)
+  assert("$doesNotContain match false", evaluate_string_field_comparison('Semaglutide', { $doesNotContain: 'Sema' }), false)
+  assert("$doesNotContain case sensitive (different case = no match)", evaluate_string_field_comparison('Placebo', { $doesNotContain: 'PLACEBO' }), true)
+
+  // $exists
+  assert("$exists:true on present", evaluate_string_field_comparison('Aspirin', { $exists: true }), true)
+  assert("$exists:true on empty", evaluate_string_field_comparison('', { $exists: true }), false)
+  assert("$exists:true on undefined", evaluate_string_field_comparison(undefined, { $exists: true }), false)
+  assert("$exists:false on present", evaluate_string_field_comparison('Aspirin', { $exists: false }), false)
+  assert("$exists:false on undefined", evaluate_string_field_comparison(undefined, { $exists: false }), true)
+
+  // null operator → treated as "no value set"
+  assert("null operator on undefined title", evaluate_string_field_comparison(undefined, null), true)
+  assert("null operator on present title", evaluate_string_field_comparison('Aspirin', null), false)
+
+  // Unknown operator → returns true (don't suppress triggers on bad data)
+  assert("unknown operator returns true", evaluate_string_field_comparison('Aspirin', { $weirdOp: 'x' } as any), true)
+}
+
+const run_conditional_logic_tests = () => {
+  console.log("\n[evaluate_conditional_logic_for_medication_title]")
+
+  // Single condition (case-sensitive)
+  const c1: CompoundFilter<'title'> = { condition: { title: { $contains: 'GLP' } } }
+  assert("single $contains true", evaluate_conditional_logic_for_medication_title('Semaglutide GLP-1', c1), true)
+  assert("single $contains false", evaluate_conditional_logic_for_medication_title('Aspirin', c1), false)
+  assert("single $contains case-sensitive miss", evaluate_conditional_logic_for_medication_title('Semaglutide glp-1', c1), false)
+
+  // Plain string default-equals
+  const c2: CompoundFilter<'title'> = { condition: { title: 'Aspirin' } }
+  assert("plain equals true", evaluate_conditional_logic_for_medication_title('Aspirin', c2), true)
+  assert("plain equals false", evaluate_conditional_logic_for_medication_title('Lisinopril', c2), false)
+
+  // $and (both true)
+  const cAnd: CompoundFilter<'title'> = {
+    $and: [
+      { condition: { title: { $contains: 'mg' } } },
+      { condition: { title: { $doesNotContain: 'Placebo' } } },
+    ],
+  }
+  assert("$and both pass", evaluate_conditional_logic_for_medication_title('Lisinopril 10mg', cAnd), true)
+  assert("$and first fails", evaluate_conditional_logic_for_medication_title('Lisinopril', cAnd), false)
+  assert("$and second fails", evaluate_conditional_logic_for_medication_title('Placebo 5mg', cAnd), false)
+
+  // $or
+  const cOr: CompoundFilter<'title'> = {
+    $or: [
+      { condition: { title: 'Aspirin' } },
+      { condition: { title: { $contains: 'pril' } } },
+    ],
+  }
+  assert("$or first matches", evaluate_conditional_logic_for_medication_title('Aspirin', cOr), true)
+  assert("$or second matches", evaluate_conditional_logic_for_medication_title('Lisinopril', cOr), true)
+  assert("$or neither matches", evaluate_conditional_logic_for_medication_title('Metformin', cOr), false)
+
+  // Mixed compound: $and containing $or — the canonical "compound" case
+  const cMixed: CompoundFilter<'title'> = {
+    $and: [
+      { condition: { title: { $contains: 'mg' } } },
+      {
+        $or: [
+          { condition: { title: { $contains: 'Lisin' } } },
+          { condition: { title: { $contains: 'Metform' } } },
+        ],
+      },
+    ],
+  }
+  assert("$and+$or first or-branch matches", evaluate_conditional_logic_for_medication_title('Lisinopril 10mg', cMixed), true)
+  assert("$and+$or second or-branch matches", evaluate_conditional_logic_for_medication_title('Metformin 500mg', cMixed), true)
+  assert("$and+$or and-branch fails", evaluate_conditional_logic_for_medication_title('Lisinopril', cMixed), false)
+  assert("$and+$or or-branch fails", evaluate_conditional_logic_for_medication_title('Aspirin 81mg', cMixed), false)
+
+  // Empty / no-op
+  assert("empty conditions returns true", evaluate_conditional_logic_for_medication_title('Aspirin', {}), true)
+
+  // Unknown operator inside condition → returns true (safe)
+  const cUnknown: CompoundFilter<'title'> = { condition: { title: { $regex: 'foo' } as any } }
+  assert("unknown operator is permissive", evaluate_conditional_logic_for_medication_title('Aspirin', cUnknown), true)
+}
+
+const run_all = () => {
+  console.log("Running conditional_logic_medication unit tests")
+  run_string_comparison_tests()
+  run_conditional_logic_tests()
+  console.log(`\nResults: ${passed} passed, ${failures} failed`)
+  if (failures > 0) process.exit(1)
+}
+
+if (require.main === module) {
+  run_all()
+}
+
+export { run_all as conditional_logic_medication_unit_tests }