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

package/lib/esm/tests/api_tests/trigger_set_fields_date_difference.test.js

@@ -46,386 +46,253 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 require('source-map-support').install();
-import { Session } from "../../sdk";
-import { async_test, log_header, } from "@tellescope/testing";
-import { setup_tests } from "../setup";
+import { poll_for_results } from "@tellescope/testing";
+import { assert_checks, setup_isolated_tenant, } from "../setup_isolated";
 var host = process.env.API_URL || 'http://localhost:8080';
-// Test function that can be called independently
-export var trigger_set_fields_date_difference_tests = function (_a) {
-    var sdk = _a.sdk;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var testEnduser, triggerId, error_1, cleanupError_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    log_header("Trigger Set Fields Date Difference Tests");
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 9, 10, 18]);
-                    // Test 1: Setup - Create enduser with date fields
-                    return [4 /*yield*/, async_test('setup - create test enduser with date fields', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var _a, _b;
-                            return __generator(this, function (_c) {
-                                switch (_c.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.endusers.createOne({
-                                            fields: {
-                                                startDate: '2024-01-15T10:00:00Z',
-                                                endDate: '01-25-2024', // MM-DD-YYYY format (10 days after startDate)
-                                            }
-                                        })];
-                                    case 1:
-                                        testEnduser = _c.sent();
-                                        return [2 /*return*/, !!testEnduser.id && !!((_a = testEnduser.fields) === null || _a === void 0 ? void 0 : _a.startDate) && !!((_b = testEnduser.fields) === null || _b === void 0 ? void 0 : _b.endDate)];
-                                }
-                            });
-                        }); }, { onResult: function (result) { return result === true; } })
-                        // Test 2: Create trigger with Date Difference - ISO to MM-DD-YYYY
-                    ];
-                case 2:
-                    // Test 1: Setup - Create enduser with date fields
-                    _b.sent();
-                    // Test 2: Create trigger with Date Difference - ISO to MM-DD-YYYY
-                    return [4 /*yield*/, async_test('create trigger - date difference between two custom fields', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var trigger;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.automation_triggers.createOne({
-                                            title: "Date Difference Test ".concat(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: '',
-                                                            dateDifferenceOptions: {
-                                                                date1: 'startDate',
-                                                                date2: 'endDate', // Reference to field containing MM-DD-YYYY
-                                                            }
-                                                        }]
-                                                }
-                                            }
-                                        })];
-                                    case 1:
-                                        trigger = _a.sent();
-                                        triggerId = trigger.id;
-                                        return [2 /*return*/, !!trigger.id];
-                                }
-                            });
-                        }); }, { onResult: function (result) { return result === true; } })
-                        // Test 3: Trigger the action and verify calculation
-                    ];
-                case 3:
-                    // Test 2: Create trigger with Date Difference - ISO to MM-DD-YYYY
-                    _b.sent();
-                    // Test 3: Trigger the action and verify calculation
-                    return [4 /*yield*/, async_test('trigger action - verify date difference is calculated correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var i, updatedEnduser, daysBetween;
-                            var _a;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.endusers.updateOne(testEnduser.id, {
-                                            fields: __assign(__assign({}, testEnduser.fields), { triggerTest: 'calculate-days' })
-                                        })
-                                        // Wait up to 10 seconds for trigger to process
-                                    ];
-                                    case 1:
-                                        _b.sent();
-                                        i = 0;
-                                        _b.label = 2;
-                                    case 2:
-                                        if (!(i < 10)) return [3 /*break*/, 6];
-                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
-                                    case 3:
-                                        _b.sent();
-                                        return [4 /*yield*/, sdk.api.endusers.getOne(testEnduser.id)];
-                                    case 4:
-                                        updatedEnduser = _b.sent();
-                                        if (((_a = updatedEnduser.fields) === null || _a === void 0 ? void 0 : _a.daysBetween) !== undefined) {
-                                            console.log("\u2713 Found daysBetween field after ".concat(i + 1, " seconds: ").concat(updatedEnduser.fields.daysBetween));
-                                            daysBetween = Number(updatedEnduser.fields.daysBetween);
-                                            if (daysBetween === 10) {
-                                                console.log("\u2713 Date difference calculated correctly: ".concat(daysBetween, " days"));
-                                                return [2 /*return*/, true];
-                                            }
-                                            else {
-                                                console.log("\u274C Unexpected date difference: ".concat(daysBetween, " (expected 10)"));
-                                                return [2 /*return*/, false];
-                                            }
+var RAND = function () { return 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 var trigger_set_fields_date_difference_checks = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var checks, record, tenant, sdk_1, await_field, testEnduser, trigger1, daysBetweenRaw, trigger2, daysSinceStartRaw, trigger3, hardcodedDaysRaw, e_1;
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                checks = [];
+                record = function (label, pass, detail) { return checks.push({ label: label, pass: pass, detail: detail }); };
+                _c.label = 1;
+            case 1:
+                _c.trys.push([1, , 16, 21]);
+                return [4 /*yield*/, setup_isolated_tenant({
+                        name: "Set Fields date difference ".concat(RAND()),
+                        users: [{ isAdmin: true }],
+                        apiKeys: 0,
+                    })];
+            case 2:
+                tenant = _c.sent();
+                sdk_1 = tenant.sdk;
+                await_field = function (enduserId, field) { return __awaiter(void 0, void 0, void 0, function () {
+                    var enduser;
+                    var _a;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0: return [4 /*yield*/, poll_for_results(function () { return sdk_1.api.endusers.getOne(enduserId); }, function (e) { var _a; return ((_a = e.fields) === null || _a === void 0 ? void 0 : _a[field]) !== undefined; }, { interval: 1000, iterations: 10 })];
+                            case 1:
+                                enduser = _b.sent();
+                                return [2 /*return*/, (_a = enduser.fields) === null || _a === void 0 ? void 0 : _a[field]];
+                        }
+                    });
+                }); };
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({
+                        fields: {
+                            startDate: '2024-01-15T10:00:00Z',
+                            endDate: '01-25-2024', // MM-DD-YYYY format (10 days after startDate)
+                        }
+                    })];
+            case 3:
+                testEnduser = _c.sent();
+                record('setup - create test enduser with date fields', !!testEnduser.id && !!((_a = testEnduser.fields) === null || _a === void 0 ? void 0 : _a.startDate) && !!((_b = testEnduser.fields) === null || _b === void 0 ? void 0 : _b.endDate), "id=".concat(testEnduser.id, " fields=").concat(JSON.stringify(testEnduser.fields)));
+                return [4 /*yield*/, sdk_1.api.automation_triggers.createOne({
+                        title: "Date Difference Test ".concat(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: '',
+                                        dateDifferenceOptions: {
+                                            date1: 'startDate',
+                                            date2: 'endDate', // Reference to field containing MM-DD-YYYY
                                         }
-                                        _b.label = 5;
-                                    case 5:
-                                        i++;
-                                        return [3 /*break*/, 2];
-                                    case 6:
-                                        console.log("\u274C daysBetween field not set after 10 seconds");
-                                        return [2 /*return*/, false];
-                                }
-                            });
-                        }); }, { onResult: function (result) { return result === true; } })
-                        // Test 4: Test with $now
-                    ];
-                case 4:
-                    // Test 3: Trigger the action and verify calculation
-                    _b.sent();
+                                    }]
+                            }
+                        }
+                    })];
+            case 4:
+                trigger1 = _c.sent();
+                record('create trigger - date difference between two custom fields', !!trigger1.id, "triggerId=".concat(trigger1.id));
+                // Test 3: Trigger the action and verify calculation
+                return [4 /*yield*/, sdk_1.api.endusers.updateOne(testEnduser.id, {
+                        fields: __assign(__assign({}, testEnduser.fields), { triggerTest: 'calculate-days' })
+                    })];
+            case 5:
+                // Test 3: Trigger the action and verify calculation
+                _c.sent();
+                return [4 /*yield*/, await_field(testEnduser.id, 'daysBetween')
+                    // Should be 10 days between 2024-01-15 and 2024-01-25
+                ];
+            case 6:
+                daysBetweenRaw = _c.sent();
+                // 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=".concat(daysBetweenRaw, " (expected 10)"));
+                return [4 /*yield*/, sdk_1.api.automation_triggers.deleteOne(trigger1.id)
                     // Test 4: Test with $now
-                    return [4 /*yield*/, async_test('create trigger - date difference with $now', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var trigger;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        if (!triggerId) return [3 /*break*/, 2];
-                                        return [4 /*yield*/, sdk.api.automation_triggers.deleteOne(triggerId)];
-                                    case 1:
-                                        _a.sent();
-                                        _a.label = 2;
-                                    case 2: return [4 /*yield*/, sdk.api.automation_triggers.createOne({
-                                            title: "Date Difference $now Test ".concat(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',
-                                                            }
-                                                        }]
-                                                }
-                                            }
-                                        })];
-                                    case 3:
-                                        trigger = _a.sent();
-                                        triggerId = trigger.id;
-                                        return [2 /*return*/, !!trigger.id];
-                                }
-                            });
-                        }); }, { onResult: function (result) { return result === true; } })
-                        // Test 5: Trigger with $now and verify
-                    ];
-                case 5:
-                    // Test 4: Test with $now
-                    _b.sent();
-                    // Test 5: Trigger with $now and verify
-                    return [4 /*yield*/, async_test('trigger action - verify $now works correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var i, updatedEnduser, daysSinceStart;
-                            var _a;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.endusers.updateOne(testEnduser.id, {
-                                            fields: __assign(__assign({}, testEnduser.fields), { triggerTest2: 'calculate-days-now' })
-                                        })
-                                        // Wait up to 10 seconds for trigger to process
-                                    ];
-                                    case 1:
-                                        _b.sent();
-                                        i = 0;
-                                        _b.label = 2;
-                                    case 2:
-                                        if (!(i < 10)) return [3 /*break*/, 6];
-                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
-                                    case 3:
-                                        _b.sent();
-                                        return [4 /*yield*/, sdk.api.endusers.getOne(testEnduser.id)];
-                                    case 4:
-                                        updatedEnduser = _b.sent();
-                                        if (((_a = updatedEnduser.fields) === null || _a === void 0 ? void 0 : _a.daysSinceStart) !== undefined) {
-                                            daysSinceStart = Number(updatedEnduser.fields.daysSinceStart);
-                                            console.log("\u2713 Found daysSinceStart field after ".concat(i + 1, " seconds: ").concat(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("\u2713 Date difference with $now calculated correctly: ".concat(daysSinceStart, " days"));
-                                                return [2 /*return*/, true];
-                                            }
-                                            else {
-                                                console.log("\u274C Unexpected date difference with $now: ".concat(daysSinceStart));
-                                                return [2 /*return*/, false];
-                                            }
+                ];
+            case 7:
+                _c.sent();
+                return [4 /*yield*/, sdk_1.api.automation_triggers.createOne({
+                        title: "Date Difference $now Test ".concat(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',
                                         }
-                                        _b.label = 5;
-                                    case 5:
-                                        i++;
-                                        return [3 /*break*/, 2];
-                                    case 6:
-                                        console.log("\u274C daysSinceStart field not set after 10 seconds");
-                                        return [2 /*return*/, false];
-                                }
-                            });
-                        }); }, { onResult: function (result) { return result === true; } })
-                        // Test 6: Test with hardcoded date strings
-                    ];
-                case 6:
-                    // Test 5: Trigger with $now and verify
-                    _b.sent();
-                    // Test 6: Test with hardcoded date strings
-                    return [4 /*yield*/, async_test('create trigger - date difference with hardcoded dates', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var trigger;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        if (!triggerId) return [3 /*break*/, 2];
-                                        return [4 /*yield*/, sdk.api.automation_triggers.deleteOne(triggerId)];
-                                    case 1:
-                                        _a.sent();
-                                        _a.label = 2;
-                                    case 2: return [4 /*yield*/, sdk.api.automation_triggers.createOne({
-                                            title: "Date Difference Hardcoded Test ".concat(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',
-                                                                date2: '01-31-2024', // MM-DD-YYYY (30 days later)
-                                                            }
-                                                        }]
-                                                }
-                                            }
-                                        })];
-                                    case 3:
-                                        trigger = _a.sent();
-                                        triggerId = trigger.id;
-                                        return [2 /*return*/, !!trigger.id];
-                                }
-                            });
-                        }); }, { onResult: function (result) { return result === true; } })
-                        // Test 7: Trigger with hardcoded dates and verify
-                    ];
-                case 7:
+                                    }]
+                            }
+                        }
+                    })];
+            case 8:
+                trigger2 = _c.sent();
+                record('create trigger - date difference with $now', !!trigger2.id, "triggerId=".concat(trigger2.id));
+                // Test 5: Trigger with $now and verify
+                return [4 /*yield*/, sdk_1.api.endusers.updateOne(testEnduser.id, {
+                        fields: __assign(__assign({}, testEnduser.fields), { triggerTest2: 'calculate-days-now' })
+                    })];
+            case 9:
+                // Test 5: Trigger with $now and verify
+                _c.sent();
+                return [4 /*yield*/, await_field(testEnduser.id, 'daysSinceStart')
+                    // 2024-01-15 is more than 600 days before any date this suite can run on
+                ];
+            case 10:
+                daysSinceStartRaw = _c.sent();
+                // 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=".concat(daysSinceStartRaw, " (expected > 600, measured from 2024-01-15)"));
+                return [4 /*yield*/, sdk_1.api.automation_triggers.deleteOne(trigger2.id)
                     // Test 6: Test with hardcoded date strings
-                    _b.sent();
-                    // Test 7: Trigger with hardcoded dates and verify
-                    return [4 /*yield*/, async_test('trigger action - verify hardcoded dates work correctly', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var i, updatedEnduser, hardcodedDays;
-                            var _a;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.endusers.updateOne(testEnduser.id, {
-                                            fields: __assign(__assign({}, testEnduser.fields), { triggerTest3: 'calculate-days-hardcoded' })
-                                        })
-                                        // Wait up to 10 seconds for trigger to process
-                                    ];
-                                    case 1:
-                                        _b.sent();
-                                        i = 0;
-                                        _b.label = 2;
-                                    case 2:
-                                        if (!(i < 10)) return [3 /*break*/, 6];
-                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
-                                    case 3:
-                                        _b.sent();
-                                        return [4 /*yield*/, sdk.api.endusers.getOne(testEnduser.id)];
-                                    case 4:
-                                        updatedEnduser = _b.sent();
-                                        if (((_a = updatedEnduser.fields) === null || _a === void 0 ? void 0 : _a.hardcodedDays) !== undefined) {
-                                            hardcodedDays = Number(updatedEnduser.fields.hardcodedDays);
-                                            console.log("\u2713 Found hardcodedDays field after ".concat(i + 1, " seconds: ").concat(hardcodedDays));
-                                            // Should be 30 days between 2024-01-01 and 2024-01-31
-                                            if (hardcodedDays === 30) {
-                                                console.log("\u2713 Date difference with hardcoded dates calculated correctly: ".concat(hardcodedDays, " days"));
-                                                return [2 /*return*/, true];
-                                            }
-                                            else {
-                                                console.log("\u274C Unexpected date difference: ".concat(hardcodedDays, " (expected 30)"));
-                                                return [2 /*return*/, false];
-                                            }
+                ];
+            case 11:
+                _c.sent();
+                return [4 /*yield*/, sdk_1.api.automation_triggers.createOne({
+                        title: "Date Difference Hardcoded Test ".concat(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',
+                                            date2: '01-31-2024', // MM-DD-YYYY (30 days later)
                                         }
-                                        _b.label = 5;
-                                    case 5:
-                                        i++;
-                                        return [3 /*break*/, 2];
-                                    case 6:
-                                        console.log("\u274C hardcodedDays field not set after 10 seconds");
-                                        return [2 /*return*/, false];
-                                }
-                            });
-                        }); }, { onResult: function (result) { return result === true; } })];
-                case 8:
-                    // Test 7: Trigger with hardcoded dates and verify
-                    _b.sent();
-                    console.log("✅ All trigger set fields date difference tests passed!");
-                    return [3 /*break*/, 18];
-                case 9:
-                    error_1 = _b.sent();
-                    console.error('Test execution error:', error_1);
-                    throw error_1;
-                case 10:
-                    // Cleanup
-                    console.log("🧹 Cleaning up test resources...");
-                    _b.label = 11;
-                case 11:
-                    _b.trys.push([11, 16, , 17]);
-                    if (!triggerId) return [3 /*break*/, 13];
-                    return [4 /*yield*/, sdk.api.automation_triggers.deleteOne(triggerId)];
-                case 12:
-                    _b.sent();
-                    _b.label = 13;
-                case 13:
-                    if (!(testEnduser === null || testEnduser === void 0 ? void 0 : testEnduser.id)) return [3 /*break*/, 15];
-                    return [4 /*yield*/, sdk.api.endusers.deleteOne(testEnduser.id)];
-                case 14:
-                    _b.sent();
-                    _b.label = 15;
-                case 15: return [3 /*break*/, 17];
-                case 16:
-                    cleanupError_1 = _b.sent();
-                    console.error('Cleanup error (non-fatal):', cleanupError_1);
-                    return [3 /*break*/, 17];
-                case 17: return [7 /*endfinally*/];
-                case 18: return [2 /*return*/];
-            }
-        });
+                                    }]
+                            }
+                        }
+                    })];
+            case 12:
+                trigger3 = _c.sent();
+                record('create trigger - date difference with hardcoded dates', !!trigger3.id, "triggerId=".concat(trigger3.id));
+                // Test 7: Trigger with hardcoded dates and verify
+                return [4 /*yield*/, sdk_1.api.endusers.updateOne(testEnduser.id, {
+                        fields: __assign(__assign({}, testEnduser.fields), { triggerTest3: 'calculate-days-hardcoded' })
+                    })];
+            case 13:
+                // Test 7: Trigger with hardcoded dates and verify
+                _c.sent();
+                return [4 /*yield*/, await_field(testEnduser.id, 'hardcodedDays')
+                    // Should be 30 days between 2024-01-01 and 2024-01-31
+                ];
+            case 14:
+                hardcodedDaysRaw = _c.sent();
+                // 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=".concat(hardcodedDaysRaw, " (expected 30)"));
+                return [4 /*yield*/, sdk_1.api.automation_triggers.deleteOne(trigger3.id)];
+            case 15:
+                _c.sent();
+                return [3 /*break*/, 21];
+            case 16:
+                if (!tenant) return [3 /*break*/, 20];
+                _c.label = 17;
+            case 17:
+                _c.trys.push([17, 19, , 20]);
+                return [4 /*yield*/, tenant.teardown()];
+            case 18:
+                _c.sent();
+                return [3 /*break*/, 20];
+            case 19:
+                e_1 = _c.sent();
+                console.error('teardown failed', e_1);
+                return [3 /*break*/, 20];
+            case 20: return [7 /*endfinally*/];
+            case 21: return [2 /*return*/, checks];
+        }
     });
+}); };
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export var trigger_set_fields_date_difference_tests = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = assert_checks;
+                _b = ['Set Fields date difference'];
+                return [4 /*yield*/, trigger_set_fields_date_difference_checks()];
+            case 1:
+                _a.apply(void 0, _b.concat([_c.sent()]));
+                return [2 /*return*/];
+        }
+    });
+}); };
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export var ISOLATED_SUITE = {
+    name: 'Set Fields date difference',
+    run: trigger_set_fields_date_difference_checks,
 };
 // Allow running this test file independently
 if (require.main === module) {
     console.log("\uD83C\uDF10 Using API URL: ".concat(host));
-    var sdk_1 = new Session({ host: host });
-    var sdkNonAdmin_1 = new Session({ host: host });
-    var runTests = function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, setup_tests(sdk_1, sdkNonAdmin_1)];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, trigger_set_fields_date_difference_tests({ sdk: sdk_1 })];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    runTests()
+    trigger_set_fields_date_difference_tests()
         .then(function () {
         console.log("✅ Trigger set fields date difference test suite completed successfully");
         process.exit(0);