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

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

@@ -35,246 +35,358 @@ 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 { assert_checks, setup_isolated_tenant, } from "../setup_isolated";
 var host = process.env.API_URL || 'http://localhost:8080';
-export var organization_settings_duplicates_tests = function (_a) {
-    var sdk = _a.sdk, sdkNonAdmin = _a.sdkNonAdmin;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var orgId, orgBefore;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    log_header("Organization Settings Duplicate Validation Tests");
-                    orgId = sdk.userInfo.businessId;
-                    // === A. replaceObjectFields: false (merge/push behavior) ===
-                    // A1. Duplicate tags via merge
-                    return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { tags: ['tag1', 'tag2'] } }
-                        }, { replaceObjectFields: true })];
-                case 1:
-                    // === A. replaceObjectFields: false (merge/push behavior) ===
-                    // A1. Duplicate tags via merge
-                    _b.sent();
-                    return [4 /*yield*/, async_test("Merge tags rejects duplicates (tag2 appears in both old and new)", function () { return sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { tags: ['tag2', 'tag3'] } }
-                        }); }, { shouldError: true, onError: function (e) { return e.message.includes('Duplicate value in settings.endusers.tags'); } })
-                        // A2. Duplicate customFields via merge
-                    ];
-                case 2:
-                    _b.sent();
-                    // A2. Duplicate customFields via merge
-                    return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { customFields: [{ type: 'Text', field: 'myField', info: {} }] } }
-                        }, { replaceObjectFields: true })];
-                case 3:
+var RAND = function () { return Math.random().toString(36).slice(2, 10); };
+/**
+ * Duplicate-rejection coverage for organization settings: settings.endusers.tags / customFields /
+ * builtinFields / dontRecordCallsToPhone and settings.calendar.cancelReasons, under both the merge
+ * (replaceObjectFields omitted) and the replace (replaceObjectFields: true) write paths.
+ *
+ * Runs on its own provisioned tenant. It used to run on the shared fixture org, where it overwrote
+ * settings.endusers.tags / .customFields / .builtinFields nine times with replaceObjectFields and had
+ * no finally and no restore — so whatever it wrote last simply stayed on the fixture org. Custom-field
+ * and tag definitions are org-wide, so that mutated state other suites read, permanently.
+ *
+ * The tenant is thrown away at teardown, so no restore is needed: the explicit "clean up settings to
+ * avoid affecting other tests" write the shared-org version ended with is gone with it.
+ */
+export var organization_settings_duplicates_checks = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var checks, record, describe, errorMessage, settingsOf, expect_result, expect_rejected, tenant, sdk_1, orgId_1, orgBefore_1, e_1, e_2;
+    return __generator(this, function (_a) {
+        switch (_a.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)); };
+                settingsOf = function (org) { return describe(org === null || org === void 0 ? void 0 : org.settings); };
+                expect_result = function (label, fn, onResult, 
+                /** Narrows the evidence line to the part under test. Without it the whole response document
+                 *  lands in the summary, which makes a failing pooled run unreadable. Caught like the predicate,
+                 *  so a formatter that throws cannot escape `run`. */
+                detailOf) {
+                    if (detailOf === void 0) { detailOf = describe; }
+                    return __awaiter(void 0, void 0, void 0, function () {
+                        var resolved, e_3, value, detail;
+                        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;
+                                    detail = (function () {
+                                        try {
+                                            return detailOf(value);
+                                        }
+                                        catch (_a) {
+                                            return describe(value);
+                                        }
+                                    })();
+                                    try {
+                                        record(label, onResult(value), "result=".concat(detail));
+                                    }
+                                    catch (predicateError) {
+                                        record(label, false, "predicate threw on result=".concat(detail, ": ").concat(errorMessage(predicateError)));
+                                    }
+                                    return [2 /*return*/];
+                            }
+                        });
+                    });
+                };
+                expect_rejected = function (label, fn, onError) { return __awaiter(void 0, void 0, void 0, function () {
+                    var rejection, unexpected, e_4, e;
+                    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 [2 /*return*/];
+                            case 2:
+                                e_4 = _a.sent();
+                                rejection = { e: e_4 };
+                                return [3 /*break*/, 3];
+                            case 3:
+                                e = rejection.e;
+                                try {
+                                    record(label, onError(e), "rejected with ".concat(errorMessage(e)));
+                                }
+                                catch (predicateError) {
+                                    record(label, false, "predicate threw on rejection \"".concat(errorMessage(e), "\": ").concat(errorMessage(predicateError)));
+                                }
+                                return [2 /*return*/];
+                        }
+                    });
+                }); };
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, , 29, 34]);
+                return [4 /*yield*/, setup_isolated_tenant({
+                        name: "Org settings duplicates ".concat(RAND()),
+                        users: [{ isAdmin: true }],
+                        apiKeys: 0,
+                    })];
+            case 2:
+                tenant = _a.sent();
+                sdk_1 = tenant.sdk;
+                orgId_1 = tenant.businessId;
+                _a.label = 3;
+            case 3:
+                _a.trys.push([3, 27, , 28]);
+                // === A. replaceObjectFields: false (merge/push behavior) ===
+                // A1. Duplicate tags via merge
+                return [4 /*yield*/, sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { tags: ['tag1', 'tag2'] } }
+                    }, { replaceObjectFields: true })];
+            case 4:
+                // === A. replaceObjectFields: false (merge/push behavior) ===
+                // A1. Duplicate tags via merge
+                _a.sent();
+                return [4 /*yield*/, expect_rejected("Merge tags rejects duplicates (tag2 appears in both old and new)", function () { return sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { tags: ['tag2', 'tag3'] } }
+                    }); }, function (e) { return e.message.includes('Duplicate value in settings.endusers.tags'); })
                     // A2. Duplicate customFields via merge
-                    _b.sent();
-                    return [4 /*yield*/, async_test("Merge customFields rejects duplicate field name", function () { return sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { customFields: [{ type: 'Text', field: 'myField', info: {} }] } }
-                        }); }, { shouldError: true, onError: function (e) { return e.message.includes('Duplicate field in settings.endusers.customFields'); } })
-                        // A3. Duplicate builtinFields via merge
-                    ];
-                case 4:
-                    _b.sent();
-                    // A3. Duplicate builtinFields via merge
-                    return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { builtinFields: [{ field: 'fname', label: 'First Name' }] } }
-                        }, { replaceObjectFields: true })];
-                case 5:
+                ];
+            case 5:
+                _a.sent();
+                // A2. Duplicate customFields via merge
+                return [4 /*yield*/, sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { customFields: [{ type: 'Text', field: 'myField', info: {} }] } }
+                    }, { replaceObjectFields: true })];
+            case 6:
+                // A2. Duplicate customFields via merge
+                _a.sent();
+                return [4 /*yield*/, expect_rejected("Merge customFields rejects duplicate field name", function () { return sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { customFields: [{ type: 'Text', field: 'myField', info: {} }] } }
+                    }); }, function (e) { return e.message.includes('Duplicate field in settings.endusers.customFields'); })
                     // A3. Duplicate builtinFields via merge
-                    _b.sent();
-                    return [4 /*yield*/, async_test("Merge builtinFields rejects duplicate field name", function () { return sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { builtinFields: [{ field: 'fname', label: 'First Name Copy' }] } }
-                        }); }, { shouldError: true, onError: function (e) { return e.message.includes('Duplicate field in settings.endusers.builtinFields'); } })
-                        // A4. Duplicate dontRecordCallsToPhone via merge
-                    ];
-                case 6:
-                    _b.sent();
+                ];
+            case 7:
+                _a.sent();
+                // A3. Duplicate builtinFields via merge
+                return [4 /*yield*/, sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { builtinFields: [{ field: 'fname', label: 'First Name' }] } }
+                    }, { replaceObjectFields: true })];
+            case 8:
+                // A3. Duplicate builtinFields via merge
+                _a.sent();
+                return [4 /*yield*/, expect_rejected("Merge builtinFields rejects duplicate field name", function () { return sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { builtinFields: [{ field: 'fname', label: 'First Name Copy' }] } }
+                    }); }, function (e) { return e.message.includes('Duplicate field in settings.endusers.builtinFields'); })
                     // A4. Duplicate dontRecordCallsToPhone via merge
-                    return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { dontRecordCallsToPhone: ['+15551234567'] } }
-                        }, { replaceObjectFields: true })];
-                case 7:
-                    // A4. Duplicate dontRecordCallsToPhone via merge
-                    _b.sent();
-                    return [4 /*yield*/, async_test("Merge dontRecordCallsToPhone rejects duplicates", function () { return sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { dontRecordCallsToPhone: ['+15551234567'] } }
-                        }); }, { shouldError: true, onError: function (e) { return e.message.includes('Duplicate value in settings.endusers.dontRecordCallsToPhone'); } })
-                        // A5. Duplicate cancelReasons via merge
-                    ];
-                case 8:
-                    _b.sent();
-                    // A5. Duplicate cancelReasons via merge
-                    return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                            settings: { calendar: { cancelReasons: ['No show'] } }
-                        }, { replaceObjectFields: true })];
-                case 9:
+                ];
+            case 9:
+                _a.sent();
+                // A4. Duplicate dontRecordCallsToPhone via merge
+                return [4 /*yield*/, sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { dontRecordCallsToPhone: ['+15551234567'] } }
+                    }, { replaceObjectFields: true })];
+            case 10:
+                // A4. Duplicate dontRecordCallsToPhone via merge
+                _a.sent();
+                return [4 /*yield*/, expect_rejected("Merge dontRecordCallsToPhone rejects duplicates", function () { return sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { dontRecordCallsToPhone: ['+15551234567'] } }
+                    }); }, function (e) { return e.message.includes('Duplicate value in settings.endusers.dontRecordCallsToPhone'); })
                     // A5. Duplicate cancelReasons via merge
-                    _b.sent();
-                    return [4 /*yield*/, async_test("Merge cancelReasons rejects duplicates", function () { return sdk.api.organizations.updateOne(orgId, {
-                            settings: { calendar: { cancelReasons: ['No show'] } }
-                        }); }, { shouldError: true, onError: function (e) { return e.message.includes('Duplicate value in settings.calendar.cancelReasons'); } })
-                        // === B. replaceObjectFields: true (full replacement) ===
-                        // B1. Replace that grows the array with dupes should be rejected
-                    ];
-                case 10:
-                    _b.sent();
+                ];
+            case 11:
+                _a.sent();
+                // A5. Duplicate cancelReasons via merge
+                return [4 /*yield*/, sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { calendar: { cancelReasons: ['No show'] } }
+                    }, { replaceObjectFields: true })];
+            case 12:
+                // A5. Duplicate cancelReasons via merge
+                _a.sent();
+                return [4 /*yield*/, expect_rejected("Merge cancelReasons rejects duplicates", function () { return sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { calendar: { cancelReasons: ['No show'] } }
+                    }); }, function (e) { return e.message.includes('Duplicate value in settings.calendar.cancelReasons'); })
                     // === B. replaceObjectFields: true (full replacement) ===
                     // B1. Replace that grows the array with dupes should be rejected
-                    return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { tags: ['tag1'] } }
-                        }, { replaceObjectFields: true })];
-                case 11:
-                    // === B. replaceObjectFields: true (full replacement) ===
-                    // B1. Replace that grows the array with dupes should be rejected
-                    _b.sent();
-                    return [4 /*yield*/, async_test("Replace tags rejects duplicates when array grows", function () { return sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { tags: ['tag1', 'tag1', 'tag2'] } }
-                        }, { replaceObjectFields: true }); }, { shouldError: true, onError: function (e) { return e.message.includes('Duplicate value in settings.endusers.tags'); } })
-                        // B2. Replace with dupes that shrinks the array should be allowed
-                    ];
-                case 12:
-                    _b.sent();
-                    // B2. Replace with dupes that shrinks the array should be allowed
-                    return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { tags: ['a', 'b', 'c'] } }
-                        }, { replaceObjectFields: true })];
-                case 13:
+                ];
+            case 13:
+                _a.sent();
+                // === B. replaceObjectFields: true (full replacement) ===
+                // B1. Replace that grows the array with dupes should be rejected
+                return [4 /*yield*/, sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { tags: ['tag1'] } }
+                    }, { replaceObjectFields: true })];
+            case 14:
+                // === B. replaceObjectFields: true (full replacement) ===
+                // B1. Replace that grows the array with dupes should be rejected
+                _a.sent();
+                return [4 /*yield*/, expect_rejected("Replace tags rejects duplicates when array grows", function () { return sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { tags: ['tag1', 'tag1', 'tag2'] } }
+                    }, { replaceObjectFields: true }); }, function (e) { return e.message.includes('Duplicate value in settings.endusers.tags'); })
                     // B2. Replace with dupes that shrinks the array should be allowed
-                    _b.sent();
-                    return [4 /*yield*/, async_test("Replace with dupes that shrinks array succeeds", function () { return sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { tags: ['a', 'a'] } }
-                        }, { replaceObjectFields: true }); }, { shouldError: false, onResult: function () { return true; } })
-                        // B3. Replace with unique values always succeeds
-                    ];
-                case 14:
-                    _b.sent();
+                ];
+            case 15:
+                _a.sent();
+                // B2. Replace with dupes that shrinks the array should be allowed
+                return [4 /*yield*/, sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { tags: ['a', 'b', 'c'] } }
+                    }, { replaceObjectFields: true })];
+            case 16:
+                // B2. Replace with dupes that shrinks the array should be allowed
+                _a.sent();
+                return [4 /*yield*/, expect_result("Replace with dupes that shrinks array succeeds", function () { return sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { tags: ['a', 'a'] } }
+                    }, { replaceObjectFields: true }); }, function () { return true; }, settingsOf)
                     // B3. Replace with unique values always succeeds
-                    return [4 /*yield*/, async_test("Replace tags succeeds with unique values", function () { return sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { tags: ['tag1', 'tag2'] } }
-                        }, { replaceObjectFields: true }); }, { shouldError: false, onResult: function () { return true; } })
-                        // === C. Non-duplicate updates still succeed ===
-                        // C1. Set initial tags then add different tags via merge
-                    ];
-                case 15:
-                    // B3. Replace with unique values always succeeds
-                    _b.sent();
-                    // === C. Non-duplicate updates still succeed ===
-                    // C1. Set initial tags then add different tags via merge
-                    return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { tags: ['tagA', 'tagB'] } }
-                        }, { replaceObjectFields: true })];
-                case 16:
+                ];
+            case 17:
+                _a.sent();
+                // B3. Replace with unique values always succeeds
+                return [4 /*yield*/, expect_result("Replace tags succeeds with unique values", function () { return sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { tags: ['tag1', 'tag2'] } }
+                    }, { replaceObjectFields: true }); }, function () { return true; }, settingsOf)
                     // === C. Non-duplicate updates still succeed ===
                     // C1. Set initial tags then add different tags via merge
-                    _b.sent();
-                    return [4 /*yield*/, async_test("Merge with unique new tags succeeds", function () { return sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { tags: ['tagC', 'tagD'] } }
-                        }); }, { shouldError: false, onResult: function () { return true; } })
-                        // C2. Replace with unique values
-                    ];
-                case 17:
-                    _b.sent();
+                ];
+            case 18:
+                // B3. Replace with unique values always succeeds
+                _a.sent();
+                // === C. Non-duplicate updates still succeed ===
+                // C1. Set initial tags then add different tags via merge
+                return [4 /*yield*/, sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { tags: ['tagA', 'tagB'] } }
+                    }, { replaceObjectFields: true })];
+            case 19:
+                // === C. Non-duplicate updates still succeed ===
+                // C1. Set initial tags then add different tags via merge
+                _a.sent();
+                return [4 /*yield*/, expect_result("Merge with unique new tags succeeds", function () { return sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { tags: ['tagC', 'tagD'] } }
+                    }); }, function () { return true; }, settingsOf)
                     // C2. Replace with unique values
-                    return [4 /*yield*/, async_test("Replace customFields with unique values succeeds", function () { return sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { customFields: [
-                                        { type: 'Text', field: 'field1', info: {} },
-                                        { type: 'Text', field: 'field2', info: {} },
-                                    ] } }
-                        }, { replaceObjectFields: true }); }, { shouldError: false, onResult: function () { return true; } })
-                        // C3. Updating another settings field preserves pre-existing duplicates
-                        // First set tags to a longer array, then shrink to a dupe array (shrinking is allowed)
-                    ];
-                case 18:
-                    // C2. Replace with unique values
-                    _b.sent();
-                    // C3. Updating another settings field preserves pre-existing duplicates
-                    // First set tags to a longer array, then shrink to a dupe array (shrinking is allowed)
-                    return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { tags: ['dupeTag', 'otherTag', 'anotherTag'] } }
-                        }, { replaceObjectFields: true })];
-                case 19:
+                ];
+            case 20:
+                _a.sent();
+                // C2. Replace with unique values
+                return [4 /*yield*/, expect_result("Replace customFields with unique values succeeds", function () { return sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { customFields: [
+                                    { type: 'Text', field: 'field1', info: {} },
+                                    { type: 'Text', field: 'field2', info: {} },
+                                ] } }
+                    }, { replaceObjectFields: true }); }, function () { return true; }, settingsOf)
                     // C3. Updating another settings field preserves pre-existing duplicates
                     // First set tags to a longer array, then shrink to a dupe array (shrinking is allowed)
-                    _b.sent();
-                    return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                            settings: { endusers: { tags: ['dupeTag', 'dupeTag'] } }
-                        }, { replaceObjectFields: true })];
-                case 20:
-                    _b.sent();
-                    return [4 /*yield*/, async_test("Updating cancelReasons succeeds even when tags has pre-existing duplicates", function () { return sdk.api.organizations.updateOne(orgId, {
-                            settings: { calendar: { cancelReasons: ['new reason'] } }
-                        }, { replaceObjectFields: true }); }, { shouldError: false, onResult: function () { return true; } })
-                        // Clean up settings to avoid affecting other tests
-                    ];
-                case 21:
-                    _b.sent();
-                    // Clean up settings to avoid affecting other tests
-                    return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                            settings: {
-                                endusers: {
-                                    tags: [],
-                                    customFields: [],
-                                    builtinFields: [],
-                                    dontRecordCallsToPhone: [],
-                                },
-                                calendar: {
-                                    cancelReasons: [],
-                                },
+                ];
+            case 21:
+                // C2. Replace with unique values
+                _a.sent();
+                // C3. Updating another settings field preserves pre-existing duplicates
+                // First set tags to a longer array, then shrink to a dupe array (shrinking is allowed)
+                return [4 /*yield*/, sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { tags: ['dupeTag', 'otherTag', 'anotherTag'] } }
+                    }, { replaceObjectFields: true })];
+            case 22:
+                // C3. Updating another settings field preserves pre-existing duplicates
+                // First set tags to a longer array, then shrink to a dupe array (shrinking is allowed)
+                _a.sent();
+                return [4 /*yield*/, sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { endusers: { tags: ['dupeTag', 'dupeTag'] } }
+                    }, { replaceObjectFields: true })];
+            case 23:
+                _a.sent();
+                return [4 /*yield*/, expect_result("Updating cancelReasons succeeds even when tags has pre-existing duplicates", function () { return sdk_1.api.organizations.updateOne(orgId_1, {
+                        settings: { calendar: { cancelReasons: ['new reason'] } }
+                    }, { replaceObjectFields: true }); }, function () { return true; }, settingsOf)
+                    // The shared-org version reset settings.endusers / settings.calendar here "to avoid affecting
+                    // other tests". Nothing reads this org after teardown, so the reset is gone rather than kept.
+                    // === D. subdomain is readonly ===
+                ];
+            case 24:
+                _a.sent();
+                return [4 /*yield*/, sdk_1.api.organizations.getOne(orgId_1)];
+            case 25:
+                orgBefore_1 = _a.sent();
+                return [4 /*yield*/, expect_result("subdomain field is readonly — update does not change persisted value", function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var orgAfter;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.organizations.updateOne(orgId_1, {
+                                        subdomain: "readonly-attempt-".concat(Date.now()),
+                                    }).catch(function () { return undefined; })]; // tolerate either silent-drop or unknown-field rejection
+                                case 1:
+                                    _a.sent(); // tolerate either silent-drop or unknown-field rejection
+                                    return [4 /*yield*/, sdk_1.api.organizations.getOne(orgId_1)];
+                                case 2:
+                                    orgAfter = _a.sent();
+                                    return [2 /*return*/, orgAfter.subdomain === orgBefore_1.subdomain];
                             }
-                        }, { replaceObjectFields: true })
-                        // === D. subdomain is readonly ===
-                    ];
-                case 22:
-                    // Clean up settings to avoid affecting other tests
-                    _b.sent();
-                    return [4 /*yield*/, sdk.api.organizations.getOne(orgId)];
-                case 23:
-                    orgBefore = _b.sent();
-                    return [4 /*yield*/, async_test("subdomain field is readonly — update does not change persisted value", function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var orgAfter;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.organizations.updateOne(orgId, {
-                                            subdomain: "readonly-attempt-".concat(Date.now()),
-                                        }).catch(function () { return undefined; })]; // tolerate either silent-drop or unknown-field rejection
-                                    case 1:
-                                        _a.sent(); // tolerate either silent-drop or unknown-field rejection
-                                        return [4 /*yield*/, sdk.api.organizations.getOne(orgId)];
-                                    case 2:
-                                        orgAfter = _a.sent();
-                                        return [2 /*return*/, orgAfter.subdomain === orgBefore.subdomain];
-                                }
-                            });
-                        }); }, { onResult: function (unchanged) { return unchanged === true; } })];
-                case 24:
-                    _b.sent();
-                    return [2 /*return*/];
-            }
-        });
+                        });
+                    }); }, function (unchanged) { return unchanged === true; })];
+            case 26:
+                _a.sent();
+                return [3 /*break*/, 28];
+            case 27:
+                e_1 = _a.sent();
+                // A bare setup write (the ones outside a check) threw. Record it rather than letting it escape
+                // `run`, which would fail every other suite in the batch instead of just this one.
+                record('Organization settings duplicate suite ran to completion', false, "threw: ".concat(errorMessage(e_1)));
+                return [3 /*break*/, 28];
+            case 28: return [3 /*break*/, 34];
+            case 29:
+                if (!tenant) return [3 /*break*/, 33];
+                _a.label = 30;
+            case 30:
+                _a.trys.push([30, 32, , 33]);
+                return [4 /*yield*/, tenant.teardown()];
+            case 31:
+                _a.sent();
+                return [3 /*break*/, 33];
+            case 32:
+                e_2 = _a.sent();
+                console.error('teardown failed', e_2);
+                return [3 /*break*/, 33];
+            case 33: return [7 /*endfinally*/];
+            case 34: return [2 /*return*/, checks];
+        }
     });
+}); };
+/** Asserting wrapper, for standalone runs. */
+export var organization_settings_duplicates_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 = ['Organization settings duplicates'];
+                return [4 /*yield*/, organization_settings_duplicates_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: 'Organization settings duplicates',
+    run: organization_settings_duplicates_checks,
 };
 // Allow running this test file independently
 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*/, organization_settings_duplicates_tests({ sdk: sdk_1, sdkNonAdmin: sdkNonAdmin_1 })];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    runTests()
+    organization_settings_duplicates_tests()
         .then(function () {
         console.log("✅ Organization settings duplicate validation tests completed successfully");
         process.exit(0);