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

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

@@ -1,305 +1,247 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
+import { poll_for_results } from "@tellescope/testing"
 import {
-  async_test,
-  log_header,
-} from "@tellescope/testing"
-import { setup_tests } from "../setup"
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
-// Test function that can be called independently
-export const trigger_set_fields_date_difference_tests = async ({ sdk } : { sdk: Session }) => {
-  log_header("Trigger Set Fields Date Difference Tests")
-
-  // Test resource tracking
-  let testEnduser: any
-  let triggerId: string | undefined
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * "Set Fields" / "Date Difference" action coverage, fired from a Field Equals trigger: two custom
+ * fields (ISO and MM-DD-YYYY), a field against `$now`, and two hardcoded date strings.
+ *
+ * Runs on its own provisioned tenant: the Field Equals triggers it installs are org-wide, so on the
+ * shared organization they evaluated every enduser-field update any concurrently running suite made
+ * (and wrote `daysBetween` / `daysSinceStart` / `hardcodedDays` onto their patients). It never calls
+ * `sdk.reset_db()`, which clears throttle namespaces shared with other suites.
+ *
+ * The three triggers each fire against the SAME enduser, which is safe because the one-fire-per-
+ * minute throttle is per trigger per enduser, and only one of them is active at a time.
+ *
+ * Records are not deleted individually: the tenant teardown in the `finally` removes everything it
+ * owns.
+ */
+export const trigger_set_fields_date_difference_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: `Set Fields date difference ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    /** Polls up to ~10s for the trigger to write `field`, and returns its value (undefined on timeout). */
+    const await_field = async (enduserId: string, field: string) => {
+      const enduser = await poll_for_results(
+        () => sdk.api.endusers.getOne(enduserId),
+        e => e.fields?.[field] !== undefined,
+        { interval: 1000, iterations: 10 },
+      )
+      return enduser.fields?.[field]
+    }
+
     // Test 1: Setup - Create enduser with date fields
-    await async_test(
+    const testEnduser = await sdk.api.endusers.createOne({
+      fields: {
+        startDate: '2024-01-15T10:00:00Z', // ISO format
+        endDate: '01-25-2024', // MM-DD-YYYY format (10 days after startDate)
+      }
+    })
+    record(
       'setup - create test enduser with date fields',
-      async () => {
-        testEnduser = await sdk.api.endusers.createOne({
-          fields: {
-            startDate: '2024-01-15T10:00:00Z', // ISO format
-            endDate: '01-25-2024', // MM-DD-YYYY format (10 days after startDate)
-          }
-        })
-
-        return !!testEnduser.id && !!testEnduser.fields?.startDate && !!testEnduser.fields?.endDate
-      },
-      { onResult: (result) => result === true }
+      !!testEnduser.id && !!testEnduser.fields?.startDate && !!testEnduser.fields?.endDate,
+      `id=${testEnduser.id} fields=${JSON.stringify(testEnduser.fields)}`,
     )
 
     // Test 2: Create trigger with Date Difference - ISO to MM-DD-YYYY
-    await async_test(
-      'create trigger - date difference between two custom fields',
-      async () => {
-        const trigger = await sdk.api.automation_triggers.createOne({
-          title: `Date Difference Test ${Date.now()}`,
-          status: 'Active',
-          event: {
-            type: 'Field Equals',
-            info: {
-              field: 'triggerTest',
-              value: 'calculate-days'
-            }
-          },
-          action: {
-            type: 'Set Fields',
-            info: {
-              fields: [{
-                name: 'daysBetween',
-                type: 'Date Difference',
-                value: '', // Not used for Date Difference type
-                dateDifferenceOptions: {
-                  date1: 'startDate', // Reference to field containing ISO string
-                  date2: 'endDate', // Reference to field containing MM-DD-YYYY
-                }
-              }]
-            }
-          }
-        })
-        triggerId = trigger.id
-        return !!trigger.id
+    const trigger1 = await sdk.api.automation_triggers.createOne({
+      title: `Date Difference Test ${Date.now()}`,
+      status: 'Active',
+      event: {
+        type: 'Field Equals',
+        info: {
+          field: 'triggerTest',
+          value: 'calculate-days'
+        }
       },
-      { onResult: (result) => result === true }
+      action: {
+        type: 'Set Fields',
+        info: {
+          fields: [{
+            name: 'daysBetween',
+            type: 'Date Difference',
+            value: '', // Not used for Date Difference type
+            dateDifferenceOptions: {
+              date1: 'startDate', // Reference to field containing ISO string
+              date2: 'endDate', // Reference to field containing MM-DD-YYYY
+            }
+          }]
+        }
+      }
+    })
+    record(
+      'create trigger - date difference between two custom fields',
+      !!trigger1.id,
+      `triggerId=${trigger1.id}`,
     )
 
     // Test 3: Trigger the action and verify calculation
-    await async_test(
-      'trigger action - verify date difference is calculated correctly',
-      async () => {
-        await sdk.api.endusers.updateOne(testEnduser.id, {
-          fields: {
-            ...testEnduser.fields,
-            triggerTest: 'calculate-days'
-          }
-        })
-
-        // Wait up to 10 seconds for trigger to process
-        for (let i = 0; i < 10; i++) {
-          await new Promise(resolve => setTimeout(resolve, 1000))
-
-          const updatedEnduser = await sdk.api.endusers.getOne(testEnduser.id)
-
-          if (updatedEnduser.fields?.daysBetween !== undefined) {
-            console.log(`✓ Found daysBetween field after ${i + 1} seconds: ${updatedEnduser.fields.daysBetween}`)
-
-            // Should be 10 days between 2024-01-15 and 2024-01-25
-            const daysBetween = Number(updatedEnduser.fields.daysBetween)
-            if (daysBetween === 10) {
-              console.log(`✓ Date difference calculated correctly: ${daysBetween} days`)
-              return true
-            } else {
-              console.log(`❌ Unexpected date difference: ${daysBetween} (expected 10)`)
-              return false
-            }
-          }
-        }
+    await sdk.api.endusers.updateOne(testEnduser.id, {
+      fields: {
+        ...testEnduser.fields,
+        triggerTest: 'calculate-days'
+      }
+    })
 
-        console.log(`❌ daysBetween field not set after 10 seconds`)
-        return false
-      },
-      { onResult: (result) => result === true }
+    const daysBetweenRaw = await await_field(testEnduser.id, 'daysBetween')
+    // Should be 10 days between 2024-01-15 and 2024-01-25
+    record(
+      'trigger action - verify date difference is calculated correctly',
+      Number(daysBetweenRaw) === 10,
+      daysBetweenRaw === undefined
+        ? 'daysBetween was not set within 10 seconds'
+        : `daysBetween=${daysBetweenRaw} (expected 10)`,
     )
 
+    await sdk.api.automation_triggers.deleteOne(trigger1.id)
+
     // Test 4: Test with $now
-    await async_test(
-      'create trigger - date difference with $now',
-      async () => {
-        // Delete previous trigger
-        if (triggerId) {
-          await sdk.api.automation_triggers.deleteOne(triggerId)
+    const trigger2 = await sdk.api.automation_triggers.createOne({
+      title: `Date Difference $now Test ${Date.now()}`,
+      status: 'Active',
+      event: {
+        type: 'Field Equals',
+        info: {
+          field: 'triggerTest2',
+          value: 'calculate-days-now'
         }
-
-        const trigger = await sdk.api.automation_triggers.createOne({
-          title: `Date Difference $now Test ${Date.now()}`,
-          status: 'Active',
-          event: {
-            type: 'Field Equals',
-            info: {
-              field: 'triggerTest2',
-              value: 'calculate-days-now'
-            }
-          },
-          action: {
-            type: 'Set Fields',
-            info: {
-              fields: [{
-                name: 'daysSinceStart',
-                type: 'Date Difference',
-                value: '',
-                dateDifferenceOptions: {
-                  date1: 'startDate',
-                  date2: '$now',
-                }
-              }]
-            }
-          }
-        })
-        triggerId = trigger.id
-        return !!trigger.id
       },
-      { onResult: (result) => result === true }
+      action: {
+        type: 'Set Fields',
+        info: {
+          fields: [{
+            name: 'daysSinceStart',
+            type: 'Date Difference',
+            value: '',
+            dateDifferenceOptions: {
+              date1: 'startDate',
+              date2: '$now',
+            }
+          }]
+        }
+      }
+    })
+    record(
+      'create trigger - date difference with $now',
+      !!trigger2.id,
+      `triggerId=${trigger2.id}`,
     )
 
     // Test 5: Trigger with $now and verify
-    await async_test(
-      'trigger action - verify $now works correctly',
-      async () => {
-        await sdk.api.endusers.updateOne(testEnduser.id, {
-          fields: {
-            ...testEnduser.fields,
-            triggerTest2: 'calculate-days-now'
-          }
-        })
-
-        // Wait up to 10 seconds for trigger to process
-        for (let i = 0; i < 10; i++) {
-          await new Promise(resolve => setTimeout(resolve, 1000))
-
-          const updatedEnduser = await sdk.api.endusers.getOne(testEnduser.id)
-
-          if (updatedEnduser.fields?.daysSinceStart !== undefined) {
-            const daysSinceStart = Number(updatedEnduser.fields.daysSinceStart)
-            console.log(`✓ Found daysSinceStart field after ${i + 1} seconds: ${daysSinceStart}`)
-
-            // Should be approximately 680+ days from 2024-01-15 to 2025-09-30 (current test date)
-            // We'll accept any reasonable value > 600 days
-            if (daysSinceStart > 600) {
-              console.log(`✓ Date difference with $now calculated correctly: ${daysSinceStart} days`)
-              return true
-            } else {
-              console.log(`❌ Unexpected date difference with $now: ${daysSinceStart}`)
-              return false
-            }
-          }
-        }
+    await sdk.api.endusers.updateOne(testEnduser.id, {
+      fields: {
+        ...testEnduser.fields,
+        triggerTest2: 'calculate-days-now'
+      }
+    })
 
-        console.log(`❌ daysSinceStart field not set after 10 seconds`)
-        return false
-      },
-      { onResult: (result) => result === true }
+    const daysSinceStartRaw = await await_field(testEnduser.id, 'daysSinceStart')
+    // 2024-01-15 is more than 600 days before any date this suite can run on
+    record(
+      'trigger action - verify $now works correctly',
+      Number(daysSinceStartRaw) > 600,
+      daysSinceStartRaw === undefined
+        ? 'daysSinceStart was not set within 10 seconds'
+        : `daysSinceStart=${daysSinceStartRaw} (expected > 600, measured from 2024-01-15)`,
     )
 
+    await sdk.api.automation_triggers.deleteOne(trigger2.id)
+
     // Test 6: Test with hardcoded date strings
-    await async_test(
-      'create trigger - date difference with hardcoded dates',
-      async () => {
-        // Delete previous trigger
-        if (triggerId) {
-          await sdk.api.automation_triggers.deleteOne(triggerId)
+    const trigger3 = await sdk.api.automation_triggers.createOne({
+      title: `Date Difference Hardcoded Test ${Date.now()}`,
+      status: 'Active',
+      event: {
+        type: 'Field Equals',
+        info: {
+          field: 'triggerTest3',
+          value: 'calculate-days-hardcoded'
         }
-
-        const trigger = await sdk.api.automation_triggers.createOne({
-          title: `Date Difference Hardcoded Test ${Date.now()}`,
-          status: 'Active',
-          event: {
-            type: 'Field Equals',
-            info: {
-              field: 'triggerTest3',
-              value: 'calculate-days-hardcoded'
-            }
-          },
-          action: {
-            type: 'Set Fields',
-            info: {
-              fields: [{
-                name: 'hardcodedDays',
-                type: 'Date Difference',
-                value: '',
-                dateDifferenceOptions: {
-                  date1: '2024-01-01T00:00:00Z', // ISO string
-                  date2: '01-31-2024', // MM-DD-YYYY (30 days later)
-                }
-              }]
-            }
-          }
-        })
-        triggerId = trigger.id
-        return !!trigger.id
       },
-      { onResult: (result) => result === true }
+      action: {
+        type: 'Set Fields',
+        info: {
+          fields: [{
+            name: 'hardcodedDays',
+            type: 'Date Difference',
+            value: '',
+            dateDifferenceOptions: {
+              date1: '2024-01-01T00:00:00Z', // ISO string
+              date2: '01-31-2024', // MM-DD-YYYY (30 days later)
+            }
+          }]
+        }
+      }
+    })
+    record(
+      'create trigger - date difference with hardcoded dates',
+      !!trigger3.id,
+      `triggerId=${trigger3.id}`,
     )
 
     // Test 7: Trigger with hardcoded dates and verify
-    await async_test(
-      'trigger action - verify hardcoded dates work correctly',
-      async () => {
-        await sdk.api.endusers.updateOne(testEnduser.id, {
-          fields: {
-            ...testEnduser.fields,
-            triggerTest3: 'calculate-days-hardcoded'
-          }
-        })
-
-        // Wait up to 10 seconds for trigger to process
-        for (let i = 0; i < 10; i++) {
-          await new Promise(resolve => setTimeout(resolve, 1000))
-
-          const updatedEnduser = await sdk.api.endusers.getOne(testEnduser.id)
-
-          if (updatedEnduser.fields?.hardcodedDays !== undefined) {
-            const hardcodedDays = Number(updatedEnduser.fields.hardcodedDays)
-            console.log(`✓ Found hardcodedDays field after ${i + 1} seconds: ${hardcodedDays}`)
-
-            // Should be 30 days between 2024-01-01 and 2024-01-31
-            if (hardcodedDays === 30) {
-              console.log(`✓ Date difference with hardcoded dates calculated correctly: ${hardcodedDays} days`)
-              return true
-            } else {
-              console.log(`❌ Unexpected date difference: ${hardcodedDays} (expected 30)`)
-              return false
-            }
-          }
-        }
+    await sdk.api.endusers.updateOne(testEnduser.id, {
+      fields: {
+        ...testEnduser.fields,
+        triggerTest3: 'calculate-days-hardcoded'
+      }
+    })
 
-        console.log(`❌ hardcodedDays field not set after 10 seconds`)
-        return false
-      },
-      { onResult: (result) => result === true }
+    const hardcodedDaysRaw = await await_field(testEnduser.id, 'hardcodedDays')
+    // Should be 30 days between 2024-01-01 and 2024-01-31
+    record(
+      'trigger action - verify hardcoded dates work correctly',
+      Number(hardcodedDaysRaw) === 30,
+      hardcodedDaysRaw === undefined
+        ? 'hardcodedDays was not set within 10 seconds'
+        : `hardcodedDays=${hardcodedDaysRaw} (expected 30)`,
     )
 
-    console.log("✅ All trigger set fields date difference tests passed!")
-
-  } catch (error) {
-    console.error('Test execution error:', error)
-    throw error
+    await sdk.api.automation_triggers.deleteOne(trigger3.id)
   } finally {
-    // Cleanup
-    console.log("🧹 Cleaning up test resources...")
+    // 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) } }
+  }
 
-    try {
-      if (triggerId) {
-        await sdk.api.automation_triggers.deleteOne(triggerId)
-      }
+  return checks
+}
 
-      if (testEnduser?.id) {
-        await sdk.api.endusers.deleteOne(testEnduser.id)
-      }
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const trigger_set_fields_date_difference_tests = async () => {
+  assert_checks('Set Fields date difference', await trigger_set_fields_date_difference_checks())
+}
 
-    } catch (cleanupError) {
-      console.error('Cleanup error (non-fatal):', cleanupError)
-    }
-  }
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Set Fields date difference',
+  run: trigger_set_fields_date_difference_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 trigger_set_fields_date_difference_tests({ sdk })
-  }
-
-  runTests()
+  trigger_set_fields_date_difference_tests()
     .then(() => {
       console.log("✅ Trigger set fields date difference test suite completed successfully")
       process.exit(0)
@@ -308,4 +250,4 @@ if (require.main === module) {
       console.error("❌ Trigger set fields date difference test suite failed:", error)
       process.exit(1)
     })
-}
+}