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

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

@@ -35,253 +35,315 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 require('source-map-support').install();
-import { Session } from "../../sdk";
-import { assert, async_test, log_header, } from "@tellescope/testing";
-import { setup_tests } from "../setup";
 import { METRIPORT_TITLE } from "@tellescope/constants";
+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); };
 // metriportPushFormResponse journey action (CU-86e2cucba).
 //
 // Fast / no-upload: this exercises validation and the guard branches that reject before any
 // Metriport HTTP call. A real upload needs a Metriport sandbox API key plus a patient already
 // synced to a facility, so the happy path is verified manually (see the task plan).
-export var metriport_push_form_response_tests = function (_a) {
-    var sdk = _a.sdk, sdkNonAdmin = _a.sdkNonAdmin;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var enduserId, otherEnduserId, formId, journeyId, createdIntegrationId, journey_1, form_1, field, enduser_1, step_1, contextOnlyStep, _b, accessCode, response, formResponseId_1, processStep, metriportIntegrationExists, existing, _c, noIntegrationResult, created, unsyncedResult, otherEnduser, crossPatientAction, crossPatientResult, untouched, stamped, idempotentResult;
-        var _d, _e;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
-                case 0:
-                    log_header("Metriport Push Form Response Tests");
-                    _f.label = 1;
-                case 1:
-                    _f.trys.push([1, , 28, 39]);
-                    return [4 /*yield*/, sdk.api.journeys.createOne({ title: 'Metriport Push Form Response Journey' })];
-                case 2:
-                    journey_1 = _f.sent();
-                    journeyId = journey_1.id;
-                    return [4 /*yield*/, sdk.api.forms.createOne({ title: 'Metriport Push Form Response Form' })];
-                case 3:
-                    form_1 = _f.sent();
-                    formId = form_1.id;
-                    return [4 /*yield*/, sdk.api.form_fields.createOne({
-                            formId: form_1.id, type: 'string', title: 'Chief Complaint', previousFields: [{ type: 'root', info: {} }],
-                        })];
-                case 4:
-                    field = _f.sent();
-                    return [4 /*yield*/, sdk.api.endusers.createOne({
-                            fname: 'metriport-push',
-                            lname: 'test',
-                            email: "metriport_push_".concat(Date.now(), "@test.tellescope.com"),
-                        })];
-                case 5:
-                    enduser_1 = _f.sent();
-                    enduserId = enduser_1.id;
-                    return [4 /*yield*/, sdk.api.automation_steps.createOne({
-                            journeyId: journey_1.id,
-                            events: [{ type: 'onJourneyStart', info: {} }],
-                            action: { type: 'metriportPushFormResponse', info: { formId: form_1.id, integrationTitle: '' } },
-                        })];
-                case 6:
-                    step_1 = _f.sent();
-                    assert(step_1.action.type === 'metriportPushFormResponse' && step_1.action.info.formId === form_1.id, 'metriportPushFormResponse step round-trip failed', 'metriportPushFormResponse step round-trips');
-                    return [4 /*yield*/, sdk.api.automation_steps.createOne({
-                            journeyId: journey_1.id,
-                            events: [{ type: 'onJourneyStart', info: {} }],
-                            action: { type: 'metriportPushFormResponse', info: {} },
-                        })];
-                case 7:
-                    contextOnlyStep = _f.sent();
-                    assert(contextOnlyStep.action.type === 'metriportPushFormResponse', 'metriportPushFormResponse step without info was rejected', 'metriportPushFormResponse info is optional');
-                    return [4 /*yield*/, async_test('metriportPushFormResponse with a malformed formId is rejected', function () { return sdk.api.automation_steps.createOne({
-                            journeyId: journey_1.id,
-                            events: [{ type: 'onJourneyStart', info: {} }],
-                            action: { type: 'metriportPushFormResponse', info: { formId: 'not-a-mongo-id' } },
-                        }); }, { shouldError: true, onError: function () { return true; } })
-                        /*************** runtime ***************/
-                    ];
-                case 8:
-                    _f.sent();
-                    return [4 /*yield*/, sdk.api.form_responses.prepare_form_response({
-                            enduserId: enduser_1.id, formId: form_1.id,
-                        })];
-                case 9:
-                    _b = _f.sent(), accessCode = _b.accessCode, response = _b.response;
-                    return [4 /*yield*/, sdk.api.form_responses.submit_form_response({
-                            accessCode: accessCode,
-                            responses: [{ fieldId: field.id, fieldTitle: 'Chief Complaint', answer: { type: 'string', value: 'Headache' } }],
-                        })];
-                case 10:
-                    _f.sent();
-                    formResponseId_1 = response.id;
-                    processStep = function () { return __awaiter(void 0, void 0, void 0, function () {
-                        var automatedAction;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, sdk.api.automated_actions.createOne({
-                                        enduserId: enduser_1.id,
-                                        journeyId: journey_1.id,
-                                        automationStepId: step_1.id,
-                                        event: { type: 'onJourneyStart', info: {} },
-                                        action: { type: 'metriportPushFormResponse', info: { formId: form_1.id } },
-                                        journeyContext: { formResponseId: formResponseId_1 },
-                                        status: 'active',
-                                        processAfter: Date.now(),
-                                    })];
-                                case 1:
-                                    automatedAction = _a.sent();
-                                    return [2 /*return*/, sdk.api.automated_actions.process({ automatedActionId: automatedAction.id })];
-                            }
-                        });
-                    }); };
-                    metriportIntegrationExists = false;
-                    _f.label = 11;
-                case 11:
-                    _f.trys.push([11, 13, , 14]);
-                    return [4 /*yield*/, sdk.api.integrations.load_redacted({})];
-                case 12:
-                    existing = _f.sent();
-                    metriportIntegrationExists = !!existing.integrations.find(function (i) { return i.title === METRIPORT_TITLE; });
-                    return [3 /*break*/, 14];
-                case 13:
-                    _c = _f.sent();
-                    return [3 /*break*/, 14];
-                case 14:
-                    if (!!metriportIntegrationExists) return [3 /*break*/, 17];
-                    return [4 /*yield*/, processStep()];
-                case 15:
-                    noIntegrationResult = _f.sent();
-                    assert(!noIntegrationResult.success
-                        && !noIntegrationResult.unimplemented
-                        && noIntegrationResult.error === 'Metriport integration not found', "expected 'Metriport integration not found', got: ".concat(JSON.stringify(noIntegrationResult)), 'metriportPushFormResponse is wired into automated_actions.process (no integration)');
-                    return [4 /*yield*/, sdk.api.integrations.createOne({
-                            title: METRIPORT_TITLE,
-                            authentication: {
-                                type: 'apiKey',
-                                info: { access_token: 'test-metriport-api-key', refresh_token: 'unused', scope: '', token_type: 'Bearer', expiry_date: new Date().getTime() },
-                            },
-                        })];
-                case 16:
-                    created = _f.sent();
-                    createdIntegrationId = created.id;
-                    _f.label = 17;
-                case 17: return [4 /*yield*/, processStep()];
-                case 18:
-                    unsyncedResult = _f.sent();
-                    assert(!unsyncedResult.success
-                        && !unsyncedResult.unimplemented
-                        && /not synced to Metriport/i.test(unsyncedResult.error || ''), "expected a 'Patient is not synced to Metriport' error, got: ".concat(JSON.stringify(unsyncedResult)), 'metriportPushFormResponse rejects a patient not synced to Metriport');
-                    return [4 /*yield*/, sdk.api.endusers.createOne({
-                            fname: 'metriport-push-other',
-                            lname: 'test',
-                            email: "metriport_push_other_".concat(Date.now(), "@test.tellescope.com"),
-                        })];
-                case 19:
-                    otherEnduser = _f.sent();
-                    otherEnduserId = otherEnduser.id;
-                    return [4 /*yield*/, sdk.api.automated_actions.createOne({
-                            enduserId: otherEnduser.id,
-                            journeyId: journey_1.id,
-                            automationStepId: step_1.id,
-                            event: { type: 'onJourneyStart', info: {} },
-                            action: { type: 'metriportPushFormResponse', info: { formId: form_1.id } },
-                            journeyContext: { formResponseId: formResponseId_1 },
-                            status: 'active',
-                            processAfter: Date.now(),
-                        })];
-                case 20:
-                    crossPatientAction = _f.sent();
-                    return [4 /*yield*/, sdk.api.automated_actions.process({ automatedActionId: crossPatientAction.id })];
-                case 21:
-                    crossPatientResult = _f.sent();
-                    assert(!crossPatientResult.success
-                        && !crossPatientResult.unimplemented
-                        && crossPatientResult.error === 'Form response does not belong to this patient', "expected a cross-patient ownership rejection, got: ".concat(JSON.stringify(crossPatientResult)), 'metriportPushFormResponse rejects a form response owned by a different patient');
-                    return [4 /*yield*/, sdk.api.form_responses.getOne(formResponseId_1)];
-                case 22:
-                    untouched = _f.sent();
-                    assert(!((_d = untouched.references) === null || _d === void 0 ? void 0 : _d.find(function (r) { return r.type === METRIPORT_TITLE; })), "patient A's form response was stamped despite a cross-patient rejection: ".concat(JSON.stringify(untouched.references)), 'metriportPushFormResponse does not stamp a form response on cross-patient rejection');
-                    /*************** idempotency ***************/
-                    // form_responses.references is a readonly field, so it can only be stamped server-side (which
-                    // is what a successful upload does). Attempt the stamp; if the API drops it, skip the check
-                    // rather than assert on a state we couldn't set up.
-                    return [4 /*yield*/, sdk.api.form_responses.updateOne(formResponseId_1, {
-                            references: [{ type: METRIPORT_TITLE, id: 'test-document-reference-id' }],
-                        }).catch(function () { })];
-                case 23:
-                    /*************** idempotency ***************/
-                    // form_responses.references is a readonly field, so it can only be stamped server-side (which
-                    // is what a successful upload does). Attempt the stamp; if the API drops it, skip the check
-                    // rather than assert on a state we couldn't set up.
-                    _f.sent();
-                    return [4 /*yield*/, sdk.api.form_responses.getOne(formResponseId_1)];
-                case 24:
-                    stamped = _f.sent();
-                    if (!((_e = stamped.references) === null || _e === void 0 ? void 0 : _e.find(function (r) { return r.type === METRIPORT_TITLE; }))) return [3 /*break*/, 26];
-                    return [4 /*yield*/, processStep()];
-                case 25:
-                    idempotentResult = _f.sent();
-                    assert(idempotentResult.success === true, "expected a no-op success for an already-shared form response, got: ".concat(JSON.stringify(idempotentResult)), 'metriportPushFormResponse no-ops for an already-shared form response');
-                    return [3 /*break*/, 27];
-                case 26:
-                    console.log("⏭️  Skipping idempotency check (form_responses.references is readonly over the API)");
-                    _f.label = 27;
-                case 27: return [3 /*break*/, 39];
-                case 28:
-                    if (!createdIntegrationId) return [3 /*break*/, 30];
-                    return [4 /*yield*/, sdk.api.integrations.deleteOne(createdIntegrationId).catch(console.error)];
-                case 29:
-                    _f.sent();
-                    _f.label = 30;
-                case 30:
-                    if (!journeyId) return [3 /*break*/, 32];
-                    return [4 /*yield*/, sdk.api.journeys.deleteOne(journeyId).catch(console.error)];
-                case 31:
-                    _f.sent();
-                    _f.label = 32;
-                case 32:
-                    if (!formId) return [3 /*break*/, 34];
-                    return [4 /*yield*/, sdk.api.forms.deleteOne(formId).catch(console.error)];
-                case 33:
-                    _f.sent();
-                    _f.label = 34;
-                case 34:
-                    if (!enduserId) return [3 /*break*/, 36];
-                    return [4 /*yield*/, sdk.api.endusers.deleteOne(enduserId).catch(console.error)];
-                case 35:
-                    _f.sent();
-                    _f.label = 36;
-                case 36:
-                    if (!otherEnduserId) return [3 /*break*/, 38];
-                    return [4 /*yield*/, sdk.api.endusers.deleteOne(otherEnduserId).catch(console.error)];
-                case 37:
-                    _f.sent();
-                    _f.label = 38;
-                case 38: return [7 /*endfinally*/];
-                case 39: return [2 /*return*/];
-            }
-        });
+//
+// Runs on its own provisioned tenant, which is what makes the no-integration guard reliable: a
+// fresh tenant never holds a Metriport integration, so that assertion always runs. On the shared
+// fixture it was wrapped in `if (!metriportIntegrationExists)` and was silently skipped whenever
+// another suite had left an integration behind — a skip reports green without asserting anything.
+export var metriport_push_form_response_checks = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var checks, record, describe, errorMessage, expect_rejected, tenant, enduserId, otherEnduserId, formId, journeyId, createdIntegrationId, sdk_1, journey_1, form_1, field, enduser_1, step_1, contextOnlyStep, _a, accessCode, response, formResponseId_1, processStep, metriportIntegrationExists, existing, _b, noIntegrationResult, created, unsyncedResult, otherEnduser, crossPatientAction, crossPatientResult, untouched, stamped, idempotentResult, sdk, e_1;
+    var _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.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_rejected = function (label, fn) { return __awaiter(void 0, void 0, void 0, function () {
+                    var unexpected, e_2;
+                    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_2 = _a.sent();
+                                record(label, true, "rejected with ".concat(errorMessage(e_2)));
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); };
+                _e.label = 1;
+            case 1:
+                _e.trys.push([1, , 30, 44]);
+                return [4 /*yield*/, setup_isolated_tenant({
+                        name: "Metriport push form response ".concat(RAND()),
+                        users: [{ isAdmin: true }],
+                        apiKeys: 0,
+                    })];
+            case 2:
+                tenant = _e.sent();
+                sdk_1 = tenant.sdk;
+                return [4 /*yield*/, sdk_1.api.journeys.createOne({ title: 'Metriport Push Form Response Journey' })];
+            case 3:
+                journey_1 = _e.sent();
+                journeyId = journey_1.id;
+                return [4 /*yield*/, sdk_1.api.forms.createOne({ title: 'Metriport Push Form Response Form' })];
+            case 4:
+                form_1 = _e.sent();
+                formId = form_1.id;
+                return [4 /*yield*/, sdk_1.api.form_fields.createOne({
+                        formId: form_1.id, type: 'string', title: 'Chief Complaint', previousFields: [{ type: 'root', info: {} }],
+                    })];
+            case 5:
+                field = _e.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({
+                        fname: 'metriport-push',
+                        lname: 'test',
+                        email: "metriport_push_".concat(Date.now(), "@test.tellescope.com"),
+                    })];
+            case 6:
+                enduser_1 = _e.sent();
+                enduserId = enduser_1.id;
+                return [4 /*yield*/, sdk_1.api.automation_steps.createOne({
+                        journeyId: journey_1.id,
+                        events: [{ type: 'onJourneyStart', info: {} }],
+                        action: { type: 'metriportPushFormResponse', info: { formId: form_1.id, integrationTitle: '' } },
+                    })];
+            case 7:
+                step_1 = _e.sent();
+                record('metriportPushFormResponse step round-trips', step_1.action.type === 'metriportPushFormResponse' && step_1.action.info.formId === form_1.id, "action=".concat(describe(step_1.action)));
+                return [4 /*yield*/, sdk_1.api.automation_steps.createOne({
+                        journeyId: journey_1.id,
+                        events: [{ type: 'onJourneyStart', info: {} }],
+                        action: { type: 'metriportPushFormResponse', info: {} },
+                    })];
+            case 8:
+                contextOnlyStep = _e.sent();
+                record('metriportPushFormResponse info is optional', contextOnlyStep.action.type === 'metriportPushFormResponse', "action=".concat(describe(contextOnlyStep.action)));
+                return [4 /*yield*/, expect_rejected('metriportPushFormResponse with a malformed formId is rejected', function () { return sdk_1.api.automation_steps.createOne({
+                        journeyId: journey_1.id,
+                        events: [{ type: 'onJourneyStart', info: {} }],
+                        action: { type: 'metriportPushFormResponse', info: { formId: 'not-a-mongo-id' } },
+                    }); })
+                    /*************** runtime ***************/
+                ];
+            case 9:
+                _e.sent();
+                return [4 /*yield*/, sdk_1.api.form_responses.prepare_form_response({
+                        enduserId: enduser_1.id, formId: form_1.id,
+                    })];
+            case 10:
+                _a = _e.sent(), accessCode = _a.accessCode, response = _a.response;
+                return [4 /*yield*/, sdk_1.api.form_responses.submit_form_response({
+                        accessCode: accessCode,
+                        responses: [{ fieldId: field.id, fieldTitle: 'Chief Complaint', answer: { type: 'string', value: 'Headache' } }],
+                    })];
+            case 11:
+                _e.sent();
+                formResponseId_1 = response.id;
+                processStep = function () { return __awaiter(void 0, void 0, void 0, function () {
+                    var automatedAction;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, sdk_1.api.automated_actions.createOne({
+                                    enduserId: enduser_1.id,
+                                    journeyId: journey_1.id,
+                                    automationStepId: step_1.id,
+                                    event: { type: 'onJourneyStart', info: {} },
+                                    action: { type: 'metriportPushFormResponse', info: { formId: form_1.id } },
+                                    journeyContext: { formResponseId: formResponseId_1 },
+                                    status: 'active',
+                                    processAfter: Date.now(),
+                                })];
+                            case 1:
+                                automatedAction = _a.sent();
+                                return [2 /*return*/, sdk_1.api.automated_actions.process({ automatedActionId: automatedAction.id })];
+                        }
+                    });
+                }); };
+                metriportIntegrationExists = false;
+                _e.label = 12;
+            case 12:
+                _e.trys.push([12, 14, , 15]);
+                return [4 /*yield*/, sdk_1.api.integrations.load_redacted({})];
+            case 13:
+                existing = _e.sent();
+                metriportIntegrationExists = !!existing.integrations.find(function (i) { return i.title === METRIPORT_TITLE; });
+                return [3 /*break*/, 15];
+            case 14:
+                _b = _e.sent();
+                return [3 /*break*/, 15];
+            case 15:
+                if (!!metriportIntegrationExists) return [3 /*break*/, 18];
+                return [4 /*yield*/, processStep()];
+            case 16:
+                noIntegrationResult = _e.sent();
+                record('metriportPushFormResponse is wired into automated_actions.process (no integration)', !noIntegrationResult.success
+                    && !noIntegrationResult.unimplemented
+                    && noIntegrationResult.error === 'Metriport integration not found', "expected 'Metriport integration not found', got: ".concat(describe(noIntegrationResult)));
+                return [4 /*yield*/, sdk_1.api.integrations.createOne({
+                        title: METRIPORT_TITLE,
+                        authentication: {
+                            type: 'apiKey',
+                            info: { access_token: 'test-metriport-api-key', refresh_token: 'unused', scope: '', token_type: 'Bearer', expiry_date: new Date().getTime() },
+                        },
+                    })];
+            case 17:
+                created = _e.sent();
+                createdIntegrationId = created.id;
+                return [3 /*break*/, 19];
+            case 18:
+                record('a freshly provisioned tenant holds no Metriport integration', false, 'the tenant already had a Metriport integration, so the no-integration assertion could not run'
+                    + ' (no placeholder is created on this branch, so the not-synced check below fails too, with'
+                    + " a misleading 'Metriport integration not found')");
+                _e.label = 19;
+            case 19: return [4 /*yield*/, processStep()];
+            case 20:
+                unsyncedResult = _e.sent();
+                record('metriportPushFormResponse rejects a patient not synced to Metriport', !unsyncedResult.success
+                    && !unsyncedResult.unimplemented
+                    && /not synced to Metriport/i.test(unsyncedResult.error || ''), "expected a 'Patient is not synced to Metriport' error, got: ".concat(describe(unsyncedResult)));
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({
+                        fname: 'metriport-push-other',
+                        lname: 'test',
+                        email: "metriport_push_other_".concat(Date.now(), "@test.tellescope.com"),
+                    })];
+            case 21:
+                otherEnduser = _e.sent();
+                otherEnduserId = otherEnduser.id;
+                return [4 /*yield*/, sdk_1.api.automated_actions.createOne({
+                        enduserId: otherEnduser.id,
+                        journeyId: journey_1.id,
+                        automationStepId: step_1.id,
+                        event: { type: 'onJourneyStart', info: {} },
+                        action: { type: 'metriportPushFormResponse', info: { formId: form_1.id } },
+                        journeyContext: { formResponseId: formResponseId_1 },
+                        status: 'active',
+                        processAfter: Date.now(),
+                    })];
+            case 22:
+                crossPatientAction = _e.sent();
+                return [4 /*yield*/, sdk_1.api.automated_actions.process({ automatedActionId: crossPatientAction.id })];
+            case 23:
+                crossPatientResult = _e.sent();
+                record('metriportPushFormResponse rejects a form response owned by a different patient', !crossPatientResult.success
+                    && !crossPatientResult.unimplemented
+                    && crossPatientResult.error === 'Form response does not belong to this patient', "expected a cross-patient ownership rejection, got: ".concat(describe(crossPatientResult)));
+                return [4 /*yield*/, sdk_1.api.form_responses.getOne(formResponseId_1)];
+            case 24:
+                untouched = _e.sent();
+                record('metriportPushFormResponse does not stamp a form response on cross-patient rejection', !((_c = untouched.references) === null || _c === void 0 ? void 0 : _c.find(function (r) { return r.type === METRIPORT_TITLE; })), "references=".concat(describe(untouched.references)));
+                /*************** idempotency ***************/
+                // form_responses.references is a readonly field, so it can only be stamped server-side (which
+                // is what a successful upload does). Attempt the stamp; if the API drops it, skip the check
+                // rather than assert on a state we couldn't set up. (This skip is about a readonly schema field,
+                // not about shared-tenant contention, so isolation does not make it unreachable.)
+                return [4 /*yield*/, sdk_1.api.form_responses.updateOne(formResponseId_1, {
+                        references: [{ type: METRIPORT_TITLE, id: 'test-document-reference-id' }],
+                    }).catch(function () { })];
+            case 25:
+                /*************** idempotency ***************/
+                // form_responses.references is a readonly field, so it can only be stamped server-side (which
+                // is what a successful upload does). Attempt the stamp; if the API drops it, skip the check
+                // rather than assert on a state we couldn't set up. (This skip is about a readonly schema field,
+                // not about shared-tenant contention, so isolation does not make it unreachable.)
+                _e.sent();
+                return [4 /*yield*/, sdk_1.api.form_responses.getOne(formResponseId_1)];
+            case 26:
+                stamped = _e.sent();
+                if (!((_d = stamped.references) === null || _d === void 0 ? void 0 : _d.find(function (r) { return r.type === METRIPORT_TITLE; }))) return [3 /*break*/, 28];
+                return [4 /*yield*/, processStep()];
+            case 27:
+                idempotentResult = _e.sent();
+                record('metriportPushFormResponse no-ops for an already-shared form response', idempotentResult.success === true, "expected a no-op success for an already-shared form response, got: ".concat(describe(idempotentResult)));
+                return [3 /*break*/, 29];
+            case 28:
+                console.log("⏭️  Skipping idempotency check (form_responses.references is readonly over the API)");
+                _e.label = 29;
+            case 29: return [3 /*break*/, 44];
+            case 30:
+                if (!tenant) return [3 /*break*/, 43];
+                sdk = tenant.sdk;
+                if (!createdIntegrationId) return [3 /*break*/, 32];
+                return [4 /*yield*/, sdk.api.integrations.deleteOne(createdIntegrationId).catch(console.error)];
+            case 31:
+                _e.sent();
+                _e.label = 32;
+            case 32:
+                if (!journeyId) return [3 /*break*/, 34];
+                return [4 /*yield*/, sdk.api.journeys.deleteOne(journeyId).catch(console.error)];
+            case 33:
+                _e.sent();
+                _e.label = 34;
+            case 34:
+                if (!formId) return [3 /*break*/, 36];
+                return [4 /*yield*/, sdk.api.forms.deleteOne(formId).catch(console.error)];
+            case 35:
+                _e.sent();
+                _e.label = 36;
+            case 36:
+                if (!enduserId) return [3 /*break*/, 38];
+                return [4 /*yield*/, sdk.api.endusers.deleteOne(enduserId).catch(console.error)];
+            case 37:
+                _e.sent();
+                _e.label = 38;
+            case 38:
+                if (!otherEnduserId) return [3 /*break*/, 40];
+                return [4 /*yield*/, sdk.api.endusers.deleteOne(otherEnduserId).catch(console.error)
+                    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
+                ];
+            case 39:
+                _e.sent();
+                _e.label = 40;
+            case 40:
+                _e.trys.push([40, 42, , 43]);
+                return [4 /*yield*/, tenant.teardown()];
+            case 41:
+                _e.sent();
+                return [3 /*break*/, 43];
+            case 42:
+                e_1 = _e.sent();
+                console.error('teardown failed', e_1);
+                return [3 /*break*/, 43];
+            case 43: return [7 /*endfinally*/];
+            case 44: return [2 /*return*/, checks];
+        }
     });
+}); };
+/** Asserting wrapper, for standalone runs. */
+export var metriport_push_form_response_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 = ['Metriport push form response'];
+                return [4 /*yield*/, metriport_push_form_response_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: 'Metriport push form response',
+    run: metriport_push_form_response_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*/, metriport_push_form_response_tests({ sdk: sdk_1, sdkNonAdmin: sdkNonAdmin_1 })];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    runTests()
+    metriport_push_form_response_tests()
         .then(function () {
         console.log("✅ Metriport push form response test suite completed successfully");
         process.exit(0);