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

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

@@ -35,11 +35,10 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 require('source-map-support').install();
-import { Session } from "../../sdk";
-import { async_test, log_header, passOnAnyResult, } from "@tellescope/testing";
 import { BELUGA_TITLE } from "@tellescope/constants";
-import { setup_tests } from "../setup";
+import { assert_checks, setup_isolated_tenant, } from "../setup_isolated";
 var host = process.env.API_URL || 'http://localhost:8080';
+var RAND = function () { return Math.random().toString(36).slice(2, 10); };
 // Beluga Trigger Refill journey action tests (CU-86e2gbv7y).
 //
 // Validator-acceptance only: verifies that automation steps configured with the new
@@ -47,279 +46,366 @@ var host = process.env.API_URL || 'http://localhost:8080';
 // invalid shapes are rejected. No live Beluga call is made — external/triggerRefill requires
 // sandbox credentials, and the process endpoint's guard branches (missing integration, missing
 // preferences) mirror the already-tested belugaAutoRx/belugaUpdateVisit handlers.
-export var beluga_trigger_refill_tests = function (_a) {
-    var sdk = _a.sdk, sdkNonAdmin = _a.sdkNonAdmin;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var journeyId, formId, stepIds, enduserAId, enduserBId, otherPatientFormResponseId, automatedActionId, createdBelugaIntegrationId, journey_1, form_1, enduserA, enduserB, otherResponse, belugaIntegrationAvailable, existing, _b, created, e_1, automatedAction_1, _i, stepIds_1, id;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    log_header("Beluga Trigger Refill Journey Action Tests");
-                    stepIds = [];
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, , 24, 43]);
-                    return [4 /*yield*/, sdk.api.journeys.createOne({ title: 'Beluga Trigger Refill Test Journey' })];
-                case 2:
-                    journey_1 = _c.sent();
-                    journeyId = journey_1.id;
-                    return [4 /*yield*/, sdk.api.forms.createOne({ title: 'Beluga Trigger Refill Test Form' })];
-                case 3:
-                    form_1 = _c.sent();
-                    formId = form_1.id;
-                    // Inline med IDs variant
-                    return [4 /*yield*/, async_test("belugaTriggerRefill step accepted (inline medIds)", function () { return sdk.api.automation_steps.createOne({
-                            journeyId: journey_1.id,
-                            events: [{ type: 'onJourneyStart', info: {} }],
-                            action: {
-                                type: 'belugaTriggerRefill',
-                                info: {
-                                    formId: form_1.id,
-                                    patientPreferences: [{ medId: 'med-123' }, { medId: 'med-456' }],
-                                    customFieldName: 'Refill Medication',
-                                },
-                            },
-                        }).then(function (s) { stepIds.push(s.id); return s; }); }, passOnAnyResult)
-                        // Organization mapping variant
-                    ];
-                case 4:
-                    // Inline med IDs variant
-                    _c.sent();
-                    // Organization mapping variant
-                    return [4 /*yield*/, async_test("belugaTriggerRefill step accepted (organization mapping)", function () { return sdk.api.automation_steps.createOne({
-                            journeyId: journey_1.id,
-                            events: [{ type: 'onJourneyStart', info: {} }],
-                            action: {
-                                type: 'belugaTriggerRefill',
-                                info: {
-                                    formId: form_1.id,
-                                    useOrganizationMapping: true,
-                                },
+//
+// Runs on its own provisioned tenant, which is what makes the cross-patient guard reliable: a fresh
+// tenant never holds a Beluga integration, so the placeholder below is always created and the guard
+// is always exercised. On the shared fixture this suite probed the org's integrations first and
+// printed "Skipping" when it could not get one — a skip reports green without asserting anything.
+export var beluga_trigger_refill_checks = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var checks, record, describe, errorMessage, expect_result, expect_rejected, tenant, journeyId, formId, stepIds, enduserAId, enduserBId, otherPatientFormResponseId, automatedActionId, createdBelugaIntegrationId, sdk_1, journey_1, form_1, enduserA, enduserB, otherResponse, belugaIntegrationAvailable, existing, _a, created, e_1, automatedAction_1, sdk, _i, stepIds_1, id, e_2;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                checks = [];
+                record = function (label, pass, detail) { return checks.push({ label: label, pass: pass, detail: detail }); };
+                describe = function (value) {
+                    if (value === undefined || value === null)
+                        return String(value);
+                    var stringified = JSON.stringify(value);
+                    return stringified === undefined ? String(value) : stringified;
+                };
+                errorMessage = function (e) { return (typeof (e === null || e === void 0 ? void 0 : e.message) === 'string' && e.message !== '' ? e.message : describe(e)); };
+                expect_result = function (label, fn, onResult) { return __awaiter(void 0, void 0, void 0, function () {
+                    var resolved, e_3, value;
+                    var _a;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                _b.trys.push([0, 2, , 3]);
+                                _a = {};
+                                return [4 /*yield*/, fn()];
+                            case 1:
+                                resolved = (_a.value = _b.sent(), _a);
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_3 = _b.sent();
+                                record(label, false, "rejected instead of resolving: ".concat(errorMessage(e_3)));
+                                return [2 /*return*/];
+                            case 3:
+                                value = resolved.value;
+                                try {
+                                    record(label, onResult(value), "result=".concat(describe(value)));
+                                }
+                                catch (predicateError) {
+                                    record(label, false, "predicate threw on result=".concat(describe(value), ": ").concat(errorMessage(predicateError)));
+                                }
+                                return [2 /*return*/];
+                        }
+                    });
+                }); };
+                expect_rejected = function (label, fn) { return __awaiter(void 0, void 0, void 0, function () {
+                    var unexpected, e_4;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, fn()];
+                            case 1:
+                                unexpected = _a.sent();
+                                record(label, false, "resolved instead of rejecting; result=".concat(describe(unexpected)));
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_4 = _a.sent();
+                                record(label, true, "rejected with ".concat(errorMessage(e_4)));
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); };
+                stepIds = [];
+                _b.label = 1;
+            case 1:
+                _b.trys.push([1, , 25, 47]);
+                return [4 /*yield*/, setup_isolated_tenant({
+                        name: "Beluga trigger refill ".concat(RAND()),
+                        users: [{ isAdmin: true }],
+                        apiKeys: 0,
+                    })];
+            case 2:
+                tenant = _b.sent();
+                sdk_1 = tenant.sdk;
+                return [4 /*yield*/, sdk_1.api.journeys.createOne({ title: 'Beluga Trigger Refill Test Journey' })];
+            case 3:
+                journey_1 = _b.sent();
+                journeyId = journey_1.id;
+                return [4 /*yield*/, sdk_1.api.forms.createOne({ title: 'Beluga Trigger Refill Test Form' })];
+            case 4:
+                form_1 = _b.sent();
+                formId = form_1.id;
+                // Inline med IDs variant
+                return [4 /*yield*/, expect_result("belugaTriggerRefill step accepted (inline medIds)", function () { return sdk_1.api.automation_steps.createOne({
+                        journeyId: journey_1.id,
+                        events: [{ type: 'onJourneyStart', info: {} }],
+                        action: {
+                            type: 'belugaTriggerRefill',
+                            info: {
+                                formId: form_1.id,
+                                patientPreferences: [{ medId: 'med-123' }, { medId: 'med-456' }],
+                                customFieldName: 'Refill Medication',
                             },
-                        }).then(function (s) { stepIds.push(s.id); return s; }); }, passOnAnyResult)
-                        // Invalid formId (not a mongo id) rejected
-                    ];
-                case 5:
+                        },
+                    }).then(function (s) { stepIds.push(s.id); return s; }); }, function () { return true; })
                     // Organization mapping variant
-                    _c.sent();
-                    // Invalid formId (not a mongo id) rejected
-                    return [4 /*yield*/, async_test("belugaTriggerRefill step rejected (invalid formId)", function () { return sdk.api.automation_steps.createOne({
-                            journeyId: journey_1.id,
-                            events: [{ type: 'onJourneyStart', info: {} }],
-                            action: {
-                                type: 'belugaTriggerRefill',
-                                info: {
-                                    formId: 'not-a-mongo-id',
-                                    patientPreferences: [{ medId: 'med-123' }],
-                                },
+                ];
+            case 5:
+                // Inline med IDs variant
+                _b.sent();
+                // Organization mapping variant
+                return [4 /*yield*/, expect_result("belugaTriggerRefill step accepted (organization mapping)", function () { return sdk_1.api.automation_steps.createOne({
+                        journeyId: journey_1.id,
+                        events: [{ type: 'onJourneyStart', info: {} }],
+                        action: {
+                            type: 'belugaTriggerRefill',
+                            info: {
+                                formId: form_1.id,
+                                useOrganizationMapping: true,
                             },
-                        }); }, { shouldError: true, onError: function () { return true; } })
-                        // Missing formId rejected
-                    ];
-                case 6:
+                        },
+                    }).then(function (s) { stepIds.push(s.id); return s; }); }, function () { return true; })
                     // Invalid formId (not a mongo id) rejected
-                    _c.sent();
-                    // Missing formId rejected
-                    return [4 /*yield*/, async_test("belugaTriggerRefill step rejected (missing formId)", function () { return sdk.api.automation_steps.createOne({
-                            journeyId: journey_1.id,
-                            events: [{ type: 'onJourneyStart', info: {} }],
-                            action: {
-                                type: 'belugaTriggerRefill',
-                                info: {
-                                    patientPreferences: [{ medId: 'med-123' }],
-                                },
+                ];
+            case 6:
+                // Organization mapping variant
+                _b.sent();
+                // Invalid formId (not a mongo id) rejected
+                return [4 /*yield*/, expect_rejected("belugaTriggerRefill step rejected (invalid formId)", function () { return sdk_1.api.automation_steps.createOne({
+                        journeyId: journey_1.id,
+                        events: [{ type: 'onJourneyStart', info: {} }],
+                        action: {
+                            type: 'belugaTriggerRefill',
+                            info: {
+                                formId: 'not-a-mongo-id',
+                                patientPreferences: [{ medId: 'med-123' }],
                             },
-                        }); }, { shouldError: true, onError: function () { return true; } })
-                        // Unexpected fields in a patient preference are stripped by objectValidator, not rejected —
-                        // assert they never reach the stored config (the step itself is accepted)
-                    ];
-                case 7:
+                        },
+                    }); })
                     // Missing formId rejected
-                    _c.sent();
-                    // Unexpected fields in a patient preference are stripped by objectValidator, not rejected —
-                    // assert they never reach the stored config (the step itself is accepted)
-                    return [4 /*yield*/, async_test("belugaTriggerRefill step strips unexpected patientPreferences field", function () { return sdk.api.automation_steps.createOne({
-                            journeyId: journey_1.id,
-                            events: [{ type: 'onJourneyStart', info: {} }],
-                            action: {
-                                type: 'belugaTriggerRefill',
-                                info: {
-                                    formId: form_1.id,
-                                    patientPreferences: [{ medId: 'med-123', pharmacyId: 'not-allowed' }],
-                                },
-                            },
-                        }).then(function (s) { stepIds.push(s.id); return s; }); }, {
-                            onResult: function (s) {
-                                var _a;
-                                var preference = (_a = s.action.info.patientPreferences) === null || _a === void 0 ? void 0 : _a[0];
-                                return (preference === null || preference === void 0 ? void 0 : preference.medId) === 'med-123' && (preference === null || preference === void 0 ? void 0 : preference.pharmacyId) === undefined;
+                ];
+            case 7:
+                // Invalid formId (not a mongo id) rejected
+                _b.sent();
+                // Missing formId rejected
+                return [4 /*yield*/, expect_rejected("belugaTriggerRefill step rejected (missing formId)", function () { return sdk_1.api.automation_steps.createOne({
+                        journeyId: journey_1.id,
+                        events: [{ type: 'onJourneyStart', info: {} }],
+                        action: {
+                            type: 'belugaTriggerRefill',
+                            info: {
+                                patientPreferences: [{ medId: 'med-123' }],
                             },
-                        })
-                        // ── Cross-patient guard (pre-deploy review H3) ──────────────────────────────
-                        // The process endpoint reads journeyContext.formResponseId; without an ownership check a
-                        // switchToRelatedContact step could point it at a DIFFERENT patient's form response and issue a
-                        // refill against their visit. This exercises the guard end-to-end: it returns BEFORE any live
-                        // Beluga call (no sandbox creds needed), but integration resolution precedes it in the handler,
-                        // so a Beluga integration must exist — the test self-skips when one can't be created.
-                    ];
-                case 8:
+                        },
+                    }); })
                     // Unexpected fields in a patient preference are stripped by objectValidator, not rejected —
                     // assert they never reach the stored config (the step itself is accepted)
-                    _c.sent();
-                    return [4 /*yield*/, sdk.api.endusers.createOne({ fname: 'Beluga', lname: 'PatientA' })];
-                case 9:
-                    enduserA = _c.sent();
-                    enduserAId = enduserA.id;
-                    return [4 /*yield*/, sdk.api.endusers.createOne({ fname: 'Beluga', lname: 'PatientB' })];
-                case 10:
-                    enduserB = _c.sent();
-                    enduserBId = enduserB.id;
-                    return [4 /*yield*/, sdk.api.form_responses.createOne({
-                            formId: form_1.id,
-                            formTitle: form_1.title,
-                            enduserId: enduserA.id,
-                        })];
-                case 11:
-                    otherResponse = _c.sent();
-                    otherPatientFormResponseId = otherResponse.id;
-                    belugaIntegrationAvailable = false;
-                    _c.label = 12;
-                case 12:
-                    _c.trys.push([12, 14, , 15]);
-                    return [4 /*yield*/, sdk.api.integrations.load_redacted({})];
-                case 13:
-                    existing = _c.sent();
-                    belugaIntegrationAvailable = !!existing.integrations.find(function (i) { return i.title === BELUGA_TITLE; });
-                    return [3 /*break*/, 15];
-                case 14:
-                    _b = _c.sent();
-                    return [3 /*break*/, 15];
-                case 15:
-                    if (!!belugaIntegrationAvailable) return [3 /*break*/, 19];
-                    _c.label = 16;
-                case 16:
-                    _c.trys.push([16, 18, , 19]);
-                    return [4 /*yield*/, sdk.api.integrations.createOne({
-                            title: BELUGA_TITLE,
-                            authentication: {
-                                type: 'oauth2',
-                                info: { access_token: 'test-access-token', refresh_token: 'test-refresh-token', scope: '', token_type: 'Bearer', expiry_date: new Date().getTime() },
-                            },
-                        })];
-                case 17:
-                    created = _c.sent();
-                    createdBelugaIntegrationId = created.id;
-                    belugaIntegrationAvailable = true;
-                    return [3 /*break*/, 19];
-                case 18:
-                    e_1 = _c.sent();
-                    console.log("Could not create a Beluga integration; skipping cross-patient guard test:", e_1);
-                    return [3 /*break*/, 19];
-                case 19:
-                    if (!belugaIntegrationAvailable) return [3 /*break*/, 22];
-                    return [4 /*yield*/, sdk.api.automated_actions.createOne({
-                            journeyId: journey_1.id,
-                            automationStepId: stepIds[0],
-                            enduserId: enduserB.id,
-                            event: { type: 'onJourneyStart', info: {} },
-                            action: {
-                                type: 'belugaTriggerRefill',
-                                info: { formId: form_1.id, patientPreferences: [{ medId: 'med-123' }] },
+                ];
+            case 8:
+                // Missing formId rejected
+                _b.sent();
+                // Unexpected fields in a patient preference are stripped by objectValidator, not rejected —
+                // assert they never reach the stored config (the step itself is accepted)
+                return [4 /*yield*/, expect_result("belugaTriggerRefill step strips unexpected patientPreferences field", function () { return sdk_1.api.automation_steps.createOne({
+                        journeyId: journey_1.id,
+                        events: [{ type: 'onJourneyStart', info: {} }],
+                        action: {
+                            type: 'belugaTriggerRefill',
+                            info: {
+                                formId: form_1.id,
+                                patientPreferences: [{ medId: 'med-123', pharmacyId: 'not-allowed' }],
                             },
-                            status: 'active',
-                            processAfter: new Date().getTime() + 60 * 60 * 1000,
-                            journeyContext: { formResponseId: otherResponse.id },
-                        })];
-                case 20:
-                    automatedAction_1 = _c.sent();
-                    automatedActionId = automatedAction_1.id;
-                    return [4 /*yield*/, async_test("belugaTriggerRefill rejects a form response owned by a different patient", function () { return sdk.api.automated_actions.process({ automatedActionId: automatedAction_1.id }); }, { onResult: function (r) { return (r === null || r === void 0 ? void 0 : r.success) === false && /does not belong to this patient/i.test((r === null || r === void 0 ? void 0 : r.error) || ''); } })];
-                case 21:
-                    _c.sent();
-                    return [3 /*break*/, 23];
-                case 22:
-                    console.log("⏭️  Skipping belugaTriggerRefill cross-patient guard test (no Beluga integration available)");
-                    _c.label = 23;
-                case 23: return [3 /*break*/, 43];
-                case 24:
-                    if (!automatedActionId) return [3 /*break*/, 26];
-                    return [4 /*yield*/, sdk.api.automated_actions.deleteOne(automatedActionId).catch(console.error)];
-                case 25:
-                    _c.sent();
-                    _c.label = 26;
-                case 26:
-                    if (!otherPatientFormResponseId) return [3 /*break*/, 28];
-                    return [4 /*yield*/, sdk.api.form_responses.deleteOne(otherPatientFormResponseId).catch(console.error)];
-                case 27:
-                    _c.sent();
-                    _c.label = 28;
-                case 28:
-                    if (!enduserAId) return [3 /*break*/, 30];
-                    return [4 /*yield*/, sdk.api.endusers.deleteOne(enduserAId).catch(console.error)];
-                case 29:
-                    _c.sent();
-                    _c.label = 30;
-                case 30:
-                    if (!enduserBId) return [3 /*break*/, 32];
-                    return [4 /*yield*/, sdk.api.endusers.deleteOne(enduserBId).catch(console.error)];
-                case 31:
-                    _c.sent();
-                    _c.label = 32;
-                case 32:
-                    if (!createdBelugaIntegrationId) return [3 /*break*/, 34];
-                    return [4 /*yield*/, sdk.api.integrations.deleteOne(createdBelugaIntegrationId).catch(console.error)];
-                case 33:
-                    _c.sent();
-                    _c.label = 34;
-                case 34:
-                    _i = 0, stepIds_1 = stepIds;
-                    _c.label = 35;
-                case 35:
-                    if (!(_i < stepIds_1.length)) return [3 /*break*/, 38];
-                    id = stepIds_1[_i];
-                    return [4 /*yield*/, sdk.api.automation_steps.deleteOne(id).catch(console.error)];
-                case 36:
-                    _c.sent();
-                    _c.label = 37;
-                case 37:
-                    _i++;
-                    return [3 /*break*/, 35];
-                case 38:
-                    if (!formId) return [3 /*break*/, 40];
-                    return [4 /*yield*/, sdk.api.forms.deleteOne(formId).catch(console.error)];
-                case 39:
-                    _c.sent();
-                    _c.label = 40;
-                case 40:
-                    if (!journeyId) return [3 /*break*/, 42];
-                    return [4 /*yield*/, sdk.api.journeys.deleteOne(journeyId).catch(console.error)];
-                case 41:
-                    _c.sent();
-                    _c.label = 42;
-                case 42: return [7 /*endfinally*/];
-                case 43: return [2 /*return*/];
-            }
-        });
+                        },
+                    }).then(function (s) { stepIds.push(s.id); return s; }); }, function (s) {
+                        var _a;
+                        var preference = (_a = s.action.info.patientPreferences) === null || _a === void 0 ? void 0 : _a[0];
+                        return (preference === null || preference === void 0 ? void 0 : preference.medId) === 'med-123' && (preference === null || preference === void 0 ? void 0 : preference.pharmacyId) === undefined;
+                    })
+                    // ── Cross-patient guard (pre-deploy review H3) ──────────────────────────────
+                    // The process endpoint reads journeyContext.formResponseId; without an ownership check a
+                    // switchToRelatedContact step could point it at a DIFFERENT patient's form response and issue a
+                    // refill against their visit. This exercises the guard end-to-end: it returns BEFORE any live
+                    // Beluga call (no sandbox creds needed), but integration resolution precedes it in the handler,
+                    // so a Beluga integration must exist. This tenant is brand new and holds none, so the
+                    // placeholder below is always created and the guard is always reached.
+                ];
+            case 9:
+                // Unexpected fields in a patient preference are stripped by objectValidator, not rejected —
+                // assert they never reach the stored config (the step itself is accepted)
+                _b.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Beluga', lname: 'PatientA' })];
+            case 10:
+                enduserA = _b.sent();
+                enduserAId = enduserA.id;
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({ fname: 'Beluga', lname: 'PatientB' })];
+            case 11:
+                enduserB = _b.sent();
+                enduserBId = enduserB.id;
+                return [4 /*yield*/, sdk_1.api.form_responses.createOne({
+                        formId: form_1.id,
+                        formTitle: form_1.title,
+                        enduserId: enduserA.id,
+                    })];
+            case 12:
+                otherResponse = _b.sent();
+                otherPatientFormResponseId = otherResponse.id;
+                belugaIntegrationAvailable = false;
+                _b.label = 13;
+            case 13:
+                _b.trys.push([13, 15, , 16]);
+                return [4 /*yield*/, sdk_1.api.integrations.load_redacted({})];
+            case 14:
+                existing = _b.sent();
+                belugaIntegrationAvailable = !!existing.integrations.find(function (i) { return i.title === BELUGA_TITLE; });
+                return [3 /*break*/, 16];
+            case 15:
+                _a = _b.sent();
+                return [3 /*break*/, 16];
+            case 16:
+                if (!!belugaIntegrationAvailable) return [3 /*break*/, 20];
+                _b.label = 17;
+            case 17:
+                _b.trys.push([17, 19, , 20]);
+                return [4 /*yield*/, sdk_1.api.integrations.createOne({
+                        title: BELUGA_TITLE,
+                        authentication: {
+                            type: 'oauth2',
+                            info: { access_token: 'test-access-token', refresh_token: 'test-refresh-token', scope: '', token_type: 'Bearer', expiry_date: new Date().getTime() },
+                        },
+                    })];
+            case 18:
+                created = _b.sent();
+                createdBelugaIntegrationId = created.id;
+                belugaIntegrationAvailable = true;
+                return [3 /*break*/, 20];
+            case 19:
+                e_1 = _b.sent();
+                // A FAILED check, not a console "skip": a skip reports green without asserting anything,
+                // which is exactly what this migration exists to remove.
+                record('a placeholder Beluga integration can be created on a freshly provisioned tenant', false, "integration create failed, so the cross-patient guard below could not run: ".concat(errorMessage(e_1)));
+                return [3 /*break*/, 20];
+            case 20:
+                if (!belugaIntegrationAvailable) return [3 /*break*/, 23];
+                return [4 /*yield*/, sdk_1.api.automated_actions.createOne({
+                        journeyId: journey_1.id,
+                        automationStepId: stepIds[0],
+                        enduserId: enduserB.id,
+                        event: { type: 'onJourneyStart', info: {} },
+                        action: {
+                            type: 'belugaTriggerRefill',
+                            info: { formId: form_1.id, patientPreferences: [{ medId: 'med-123' }] },
+                        },
+                        status: 'active',
+                        processAfter: new Date().getTime() + 60 * 60 * 1000,
+                        journeyContext: { formResponseId: otherResponse.id },
+                    })];
+            case 21:
+                automatedAction_1 = _b.sent();
+                automatedActionId = automatedAction_1.id;
+                return [4 /*yield*/, expect_result("belugaTriggerRefill rejects a form response owned by a different patient", function () { return sdk_1.api.automated_actions.process({ automatedActionId: automatedAction_1.id }); }, function (r) { return (r === null || r === void 0 ? void 0 : r.success) === false && /does not belong to this patient/i.test((r === null || r === void 0 ? void 0 : r.error) || ''); })];
+            case 22:
+                _b.sent();
+                return [3 /*break*/, 24];
+            case 23:
+                // Under the guard's OWN label, so the check table carries the same row set on every run —
+                // a missing row reads as "this was never written", which is the opposite of what happened.
+                record("belugaTriggerRefill rejects a form response owned by a different patient", false, 'no Beluga integration was available on this tenant, so the cross-patient guard could not run');
+                _b.label = 24;
+            case 24: return [3 /*break*/, 47];
+            case 25:
+                if (!tenant) return [3 /*break*/, 46];
+                sdk = tenant.sdk;
+                if (!automatedActionId) return [3 /*break*/, 27];
+                return [4 /*yield*/, sdk.api.automated_actions.deleteOne(automatedActionId).catch(console.error)];
+            case 26:
+                _b.sent();
+                _b.label = 27;
+            case 27:
+                if (!otherPatientFormResponseId) return [3 /*break*/, 29];
+                return [4 /*yield*/, sdk.api.form_responses.deleteOne(otherPatientFormResponseId).catch(console.error)];
+            case 28:
+                _b.sent();
+                _b.label = 29;
+            case 29:
+                if (!enduserAId) return [3 /*break*/, 31];
+                return [4 /*yield*/, sdk.api.endusers.deleteOne(enduserAId).catch(console.error)];
+            case 30:
+                _b.sent();
+                _b.label = 31;
+            case 31:
+                if (!enduserBId) return [3 /*break*/, 33];
+                return [4 /*yield*/, sdk.api.endusers.deleteOne(enduserBId).catch(console.error)];
+            case 32:
+                _b.sent();
+                _b.label = 33;
+            case 33:
+                if (!createdBelugaIntegrationId) return [3 /*break*/, 35];
+                return [4 /*yield*/, sdk.api.integrations.deleteOne(createdBelugaIntegrationId).catch(console.error)];
+            case 34:
+                _b.sent();
+                _b.label = 35;
+            case 35:
+                _i = 0, stepIds_1 = stepIds;
+                _b.label = 36;
+            case 36:
+                if (!(_i < stepIds_1.length)) return [3 /*break*/, 39];
+                id = stepIds_1[_i];
+                return [4 /*yield*/, sdk.api.automation_steps.deleteOne(id).catch(console.error)];
+            case 37:
+                _b.sent();
+                _b.label = 38;
+            case 38:
+                _i++;
+                return [3 /*break*/, 36];
+            case 39:
+                if (!formId) return [3 /*break*/, 41];
+                return [4 /*yield*/, sdk.api.forms.deleteOne(formId).catch(console.error)];
+            case 40:
+                _b.sent();
+                _b.label = 41;
+            case 41:
+                if (!journeyId) return [3 /*break*/, 43];
+                return [4 /*yield*/, sdk.api.journeys.deleteOne(journeyId).catch(console.error)
+                    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
+                ];
+            case 42:
+                _b.sent();
+                _b.label = 43;
+            case 43:
+                _b.trys.push([43, 45, , 46]);
+                return [4 /*yield*/, tenant.teardown()];
+            case 44:
+                _b.sent();
+                return [3 /*break*/, 46];
+            case 45:
+                e_2 = _b.sent();
+                console.error('teardown failed', e_2);
+                return [3 /*break*/, 46];
+            case 46: return [7 /*endfinally*/];
+            case 47: return [2 /*return*/, checks];
+        }
+    });
+}); };
+/** Asserting wrapper, for standalone runs. */
+export var beluga_trigger_refill_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 = ['Beluga trigger refill'];
+                return [4 /*yield*/, beluga_trigger_refill_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: 'Beluga trigger refill',
+    run: beluga_trigger_refill_checks,
 };
 if (require.main === module) {
     console.log("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*/, beluga_trigger_refill_tests({ sdk: sdk_1, sdkNonAdmin: sdkNonAdmin_1 })];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    runTests()
+    beluga_trigger_refill_tests()
         .then(function () {
         console.log("✅ Beluga trigger refill test suite completed successfully");
         process.exit(0);