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

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

@@ -35,263 +35,355 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 require('source-map-support').install();
-import { Session } from "../../sdk";
-import { async_test, handleAnyError, 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';
-// Main test function for bulk_assignment endpoint
-export var bulk_assignment_tests = function (_a) {
-    var sdk = _a.sdk, sdkNonAdmin = _a.sdkNonAdmin;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var customTypeId, user1, user2, enduserWithCustomType, enduserWithEmptyCustomType, enduserWithoutCustomType, enduserWithDifferentField;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    log_header("Bulk Assignment Tests");
-                    customTypeId = '507f1f77bcf86cd799439011' // Valid MongoDB ObjectId
-                    ;
-                    return [4 /*yield*/, sdk.api.users.createOne({
-                            email: "test-user-1-".concat(Date.now(), "@test.com"),
-                            fname: 'Test',
-                            lname: 'User1',
-                        })];
-                case 1:
-                    user1 = _b.sent();
-                    return [4 /*yield*/, sdk.api.users.createOne({
-                            email: "test-user-2-".concat(Date.now(), "@test.com"),
-                            fname: 'Test',
-                            lname: 'User2',
-                        })
-                        // Create endusers with different customTypeId scenarios
-                    ];
-                case 2:
-                    user2 = _b.sent();
-                    return [4 /*yield*/, sdk.api.endusers.createOne({
-                            fname: 'Test',
-                            lname: 'WithType',
-                            customTypeId: customTypeId,
-                            fields: { Building: ['Building A'] },
-                        })];
-                case 3:
-                    enduserWithCustomType = _b.sent();
-                    return [4 /*yield*/, sdk.api.endusers.createOne({
-                            fname: 'Test',
-                            lname: 'EmptyType',
-                            customTypeId: '',
-                            fields: { Building: ['Building A'] },
-                        })];
-                case 4:
-                    enduserWithEmptyCustomType = _b.sent();
-                    return [4 /*yield*/, sdk.api.endusers.createOne({
-                            fname: 'Test',
-                            lname: 'NoType',
-                            // customTypeId not set (will be missing from document)
-                            fields: { Building: ['Building B'] },
-                        })];
-                case 5:
-                    enduserWithoutCustomType = _b.sent();
-                    return [4 /*yield*/, sdk.api.endusers.createOne({
-                            fname: 'Test',
-                            lname: 'DifferentField',
-                            customTypeId: '',
-                            fields: { Building: ['Building C'] },
-                        })
-                        // Test 1: Add care team members with specific customTypeId
-                    ];
-                case 6:
-                    enduserWithDifferentField = _b.sent();
-                    // Test 1: Add care team members with specific customTypeId
-                    return [4 /*yield*/, async_test("bulk_assignment: Add care team with specific customTypeId", function () { return sdk.api.endusers.bulk_assignment({
-                            customTypeId: customTypeId,
-                            addIds: [user1.id],
-                        }); }, {
-                            onResult: function (r) {
-                                var _a;
-                                return (r.updated.length === 1
-                                    && r.updated[0].id === enduserWithCustomType.id
-                                    && !!((_a = r.updated[0].assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user1.id)));
+var RAND = function () { return Math.random().toString(36).slice(2, 10); };
+/**
+ * endusers.bulk_assignment care-team coverage: adds and removes across customTypeId variants
+ * (a real id, the empty string, and the field missing entirely), the existingAssignment
+ * qualifiers, the custom-field filter, and the no-addIds-or-removeIds error case.
+ *
+ * Runs on its own provisioned tenant. bulk_assignment writes to EVERY enduser matching the filter
+ * in the business, so on the shared fixture org the "undefined customTypeId" and "empty string
+ * customTypeId" cases raced every other suite's patients: both of those checks assert an exact
+ * updated.length of 3, which only holds when no one else owns an untyped enduser in the org.
+ */
+export var bulk_assignment_checks = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var checks, record, describe, errorMessage, updatedSummary, expect_result, expect_rejected, tenant, sdk_1, customTypeId_1, user1_1, user2_1, enduserWithCustomType_1, enduserWithEmptyCustomType_1, enduserWithoutCustomType_1, enduserWithDifferentField_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)); };
+                updatedSummary = function (r) { return describe(r.updated.map(function (e) { var _a; return ({ id: e.id, assignedTo: e.assignedTo, Building: (_a = e.fields) === null || _a === void 0 ? void 0 : _a.Building }); })); };
+                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*/];
                             }
-                        })
-                        // Test 2: Add care team members with undefined customTypeId (should match empty string AND missing)
-                    ];
-                case 7:
+                        });
+                    });
+                };
+                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*/];
+                        }
+                    });
+                }); };
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, , 20, 25]);
+                return [4 /*yield*/, setup_isolated_tenant({
+                        name: "Bulk assignment ".concat(RAND()),
+                        users: [{ isAdmin: true }],
+                        apiKeys: 0,
+                    })];
+            case 2:
+                tenant = _a.sent();
+                sdk_1 = tenant.sdk;
+                _a.label = 3;
+            case 3:
+                _a.trys.push([3, 18, , 19]);
+                customTypeId_1 = '507f1f77bcf86cd799439011' // Valid MongoDB ObjectId
+                ;
+                return [4 /*yield*/, sdk_1.api.users.createOne({
+                        email: "test-user-1-".concat(RAND(), "@test.com"),
+                        fname: 'Test',
+                        lname: 'User1',
+                    })];
+            case 4:
+                user1_1 = _a.sent();
+                return [4 /*yield*/, sdk_1.api.users.createOne({
+                        email: "test-user-2-".concat(RAND(), "@test.com"),
+                        fname: 'Test',
+                        lname: 'User2',
+                    })
+                    // Create endusers with different customTypeId scenarios
+                ];
+            case 5:
+                user2_1 = _a.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({
+                        fname: 'Test',
+                        lname: 'WithType',
+                        customTypeId: customTypeId_1,
+                        fields: { Building: ['Building A'] },
+                    })];
+            case 6:
+                enduserWithCustomType_1 = _a.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({
+                        fname: 'Test',
+                        lname: 'EmptyType',
+                        customTypeId: '',
+                        fields: { Building: ['Building A'] },
+                    })];
+            case 7:
+                enduserWithEmptyCustomType_1 = _a.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({
+                        fname: 'Test',
+                        lname: 'NoType',
+                        // customTypeId not set (will be missing from document)
+                        fields: { Building: ['Building B'] },
+                    })];
+            case 8:
+                enduserWithoutCustomType_1 = _a.sent();
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({
+                        fname: 'Test',
+                        lname: 'DifferentField',
+                        customTypeId: '',
+                        fields: { Building: ['Building C'] },
+                    })
                     // Test 1: Add care team members with specific customTypeId
-                    _b.sent();
-                    // Test 2: Add care team members with undefined customTypeId (should match empty string AND missing)
-                    return [4 /*yield*/, async_test("bulk_assignment: Add care team with undefined customTypeId (matches empty and missing)", function () { return sdk.api.endusers.bulk_assignment({
-                            customTypeId: undefined,
-                            addIds: [user2.id],
-                        }); }, {
-                            onResult: function (r) {
-                                // Should update endusers with empty string customTypeId and missing customTypeId
-                                // Should NOT update enduserWithCustomType (has actual customTypeId set)
-                                var updatedIds = r.updated.map(function (e) { return e.id; }).sort();
-                                var expectedIds = [enduserWithEmptyCustomType.id, enduserWithoutCustomType.id, enduserWithDifferentField.id].sort();
-                                return (r.updated.length === 3
-                                    && JSON.stringify(updatedIds) === JSON.stringify(expectedIds)
-                                    && r.updated.every(function (e) { var _a; return !!((_a = e.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user2.id)); }));
-                            }
-                        })
-                        // Test 3: Add care team members with empty string customTypeId
-                    ];
-                case 8:
+                ];
+            case 9:
+                enduserWithDifferentField_1 = _a.sent();
+                // Test 1: Add care team members with specific customTypeId
+                return [4 /*yield*/, expect_result("bulk_assignment: Add care team with specific customTypeId", function () { return sdk_1.api.endusers.bulk_assignment({
+                        customTypeId: customTypeId_1,
+                        addIds: [user1_1.id],
+                    }); }, function (r) {
+                        var _a;
+                        return (r.updated.length === 1
+                            && r.updated[0].id === enduserWithCustomType_1.id
+                            && !!((_a = r.updated[0].assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user1_1.id)));
+                    }, updatedSummary)
                     // Test 2: Add care team members with undefined customTypeId (should match empty string AND missing)
-                    _b.sent();
+                ];
+            case 10:
+                // Test 1: Add care team members with specific customTypeId
+                _a.sent();
+                // Test 2: Add care team members with undefined customTypeId (should match empty string AND missing)
+                return [4 /*yield*/, expect_result("bulk_assignment: Add care team with undefined customTypeId (matches empty and missing)", function () { return sdk_1.api.endusers.bulk_assignment({
+                        customTypeId: undefined,
+                        addIds: [user2_1.id],
+                    }); }, function (r) {
+                        // Should update endusers with empty string customTypeId and missing customTypeId
+                        // Should NOT update enduserWithCustomType (has actual customTypeId set)
+                        var updatedIds = r.updated.map(function (e) { return e.id; }).sort();
+                        var expectedIds = [enduserWithEmptyCustomType_1.id, enduserWithoutCustomType_1.id, enduserWithDifferentField_1.id].sort();
+                        return (r.updated.length === 3
+                            && JSON.stringify(updatedIds) === JSON.stringify(expectedIds)
+                            && r.updated.every(function (e) { var _a; return !!((_a = e.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user2_1.id)); }));
+                    }, updatedSummary)
                     // Test 3: Add care team members with empty string customTypeId
-                    return [4 /*yield*/, async_test("bulk_assignment: Add care team with empty string customTypeId", function () { return sdk.api.endusers.bulk_assignment({
-                            customTypeId: '',
-                            addIds: [user1.id],
-                        }); }, {
-                            onResult: function (r) {
-                                // Should update endusers with empty string customTypeId and missing customTypeId
-                                var updatedIds = r.updated.map(function (e) { return e.id; }).sort();
-                                var expectedIds = [enduserWithEmptyCustomType.id, enduserWithoutCustomType.id, enduserWithDifferentField.id].sort();
-                                return (r.updated.length === 3
-                                    && JSON.stringify(updatedIds) === JSON.stringify(expectedIds)
-                                    && r.updated.every(function (e) { var _a; return !!((_a = e.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user1.id)); }));
-                            }
-                        })
-                        // Test 4: Remove care team members with existingAssignment filter
-                    ];
-                case 9:
-                    // Test 3: Add care team members with empty string customTypeId
-                    _b.sent();
+                ];
+            case 11:
+                // Test 2: Add care team members with undefined customTypeId (should match empty string AND missing)
+                _a.sent();
+                // Test 3: Add care team members with empty string customTypeId
+                return [4 /*yield*/, expect_result("bulk_assignment: Add care team with empty string customTypeId", function () { return sdk_1.api.endusers.bulk_assignment({
+                        customTypeId: '',
+                        addIds: [user1_1.id],
+                    }); }, function (r) {
+                        // Should update endusers with empty string customTypeId and missing customTypeId
+                        var updatedIds = r.updated.map(function (e) { return e.id; }).sort();
+                        var expectedIds = [enduserWithEmptyCustomType_1.id, enduserWithoutCustomType_1.id, enduserWithDifferentField_1.id].sort();
+                        return (r.updated.length === 3
+                            && JSON.stringify(updatedIds) === JSON.stringify(expectedIds)
+                            && r.updated.every(function (e) { var _a; return !!((_a = e.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user1_1.id)); }));
+                    }, updatedSummary)
                     // Test 4: Remove care team members with existingAssignment filter
-                    return [4 /*yield*/, async_test("bulk_assignment: Remove care team with existingAssignment filter (All Of)", function () { return sdk.api.endusers.bulk_assignment({
-                            customTypeId: undefined,
-                            existingAssignment: {
-                                qualifier: 'All Of',
-                                values: [user1.id, user2.id],
-                            },
-                            removeIds: [user2.id],
-                        }); }, {
-                            onResult: function (r) { return (r.updated.every(function (e) {
-                                var _a, _b;
-                                return !((_a = e.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user2.id)) && // user2 removed
-                                    !!((_b = e.assignedTo) === null || _b === void 0 ? void 0 : _b.includes(user1.id));
-                            } // user1 still present
-                            )); }
-                        })
-                        // Test 5: Add care team members with existingAssignment filter (One Of)
-                    ];
-                case 10:
-                    // Test 4: Remove care team members with existingAssignment filter
-                    _b.sent();
-                    // Test 5: Add care team members with existingAssignment filter (One Of)
-                    return [4 /*yield*/, async_test("bulk_assignment: Add with existingAssignment filter (One Of)", function () { return sdk.api.endusers.bulk_assignment({
-                            customTypeId: undefined,
-                            existingAssignment: {
-                                qualifier: 'One Of',
-                                values: [user1.id],
-                            },
-                            addIds: [user2.id],
-                        }); }, {
-                            onResult: function (r) { return (r.updated.every(function (e) {
-                                var _a, _b;
-                                return !!((_a = e.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user1.id)) &&
-                                    !!((_b = e.assignedTo) === null || _b === void 0 ? void 0 : _b.includes(user2.id));
-                            })); }
-                        })
-                        // Test 6: Add care team members with custom field filter (array field)
-                    ];
-                case 11:
+                ];
+            case 12:
+                // Test 3: Add care team members with empty string customTypeId
+                _a.sent();
+                // Test 4: Remove care team members with existingAssignment filter
+                return [4 /*yield*/, expect_result("bulk_assignment: Remove care team with existingAssignment filter (All Of)", function () { return sdk_1.api.endusers.bulk_assignment({
+                        customTypeId: undefined,
+                        existingAssignment: {
+                            qualifier: 'All Of',
+                            values: [user1_1.id, user2_1.id],
+                        },
+                        removeIds: [user2_1.id],
+                    }); }, function (r) { return (r.updated.every(function (e) {
+                        var _a, _b;
+                        return !((_a = e.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user2_1.id)) && // user2 removed
+                            !!((_b = e.assignedTo) === null || _b === void 0 ? void 0 : _b.includes(user1_1.id));
+                    } // user1 still present
+                    )); }, updatedSummary)
                     // Test 5: Add care team members with existingAssignment filter (One Of)
-                    _b.sent();
+                ];
+            case 13:
+                // Test 4: Remove care team members with existingAssignment filter
+                _a.sent();
+                // Test 5: Add care team members with existingAssignment filter (One Of)
+                return [4 /*yield*/, expect_result("bulk_assignment: Add with existingAssignment filter (One Of)", function () { return sdk_1.api.endusers.bulk_assignment({
+                        customTypeId: undefined,
+                        existingAssignment: {
+                            qualifier: 'One Of',
+                            values: [user1_1.id],
+                        },
+                        addIds: [user2_1.id],
+                    }); }, function (r) { return (r.updated.every(function (e) {
+                        var _a, _b;
+                        return !!((_a = e.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user1_1.id)) &&
+                            !!((_b = e.assignedTo) === null || _b === void 0 ? void 0 : _b.includes(user2_1.id));
+                    })); }, updatedSummary)
                     // Test 6: Add care team members with custom field filter (array field)
-                    return [4 /*yield*/, async_test("bulk_assignment: Add with custom field filter (array value)", function () { return sdk.api.endusers.bulk_assignment({
-                            customTypeId: undefined,
-                            field: 'Building',
-                            existingFieldValue: 'Building A',
-                            addIds: [sdk.userInfo.id], // Use admin user ID
-                        }); }, {
-                            onResult: function (r) {
-                                // Should match endusers where Building array contains 'Building A'
-                                // Note: May return fewer than 2 if some already have this user assigned
-                                var updatedIds = r.updated.map(function (e) { return e.id; });
-                                var hasCorrectEnduser = updatedIds.includes(enduserWithEmptyCustomType.id) || updatedIds.includes(enduserWithCustomType.id);
-                                return (r.updated.length >= 1
-                                    && hasCorrectEnduser
-                                    && r.updated.every(function (e) { var _a; return !!((_a = e.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(sdk.userInfo.id)); })
-                                    && r.updated.every(function (e) {
-                                        var _a;
-                                        var building = (_a = e.fields) === null || _a === void 0 ? void 0 : _a.Building;
-                                        return Array.isArray(building) ? building.includes('Building A') : building === 'Building A';
-                                    }));
-                            }
-                        })
-                        // Test 7: Remove care team members with combined filters
-                    ];
-                case 12:
-                    // Test 6: Add care team members with custom field filter (array field)
-                    _b.sent();
-                    // Test 7: Remove care team members with combined filters
-                    return [4 /*yield*/, async_test("bulk_assignment: Remove with combined filters (customTypeId + field + existingAssignment)", function () { return sdk.api.endusers.bulk_assignment({
-                            customTypeId: '',
-                            field: 'Building',
-                            existingFieldValue: 'Building A',
-                            existingAssignment: {
-                                qualifier: 'All Of',
-                                values: [user1.id],
-                            },
-                            removeIds: [user1.id],
-                        }); }, {
-                            onResult: function (r) {
+                ];
+            case 14:
+                // Test 5: Add care team members with existingAssignment filter (One Of)
+                _a.sent();
+                // Test 6: Add care team members with custom field filter (array field)
+                return [4 /*yield*/, expect_result("bulk_assignment: Add with custom field filter (array value)", function () { return sdk_1.api.endusers.bulk_assignment({
+                        customTypeId: undefined,
+                        field: 'Building',
+                        existingFieldValue: 'Building A',
+                        addIds: [sdk_1.userInfo.id], // Use admin user ID
+                    }); }, function (r) {
+                        // Should match endusers where Building array contains 'Building A'
+                        // Note: May return fewer than 2 if some already have this user assigned
+                        var updatedIds = r.updated.map(function (e) { return e.id; });
+                        var hasCorrectEnduser = updatedIds.includes(enduserWithEmptyCustomType_1.id) || updatedIds.includes(enduserWithCustomType_1.id);
+                        return (r.updated.length >= 1
+                            && hasCorrectEnduser
+                            && r.updated.every(function (e) { var _a; return !!((_a = e.assignedTo) === null || _a === void 0 ? void 0 : _a.includes(sdk_1.userInfo.id)); })
+                            && r.updated.every(function (e) {
                                 var _a;
-                                return (r.updated.length === 1
-                                    && r.updated[0].id === enduserWithEmptyCustomType.id
-                                    && !((_a = r.updated[0].assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user1.id)));
-                            }
-                        })
-                        // Test 8: Error when neither addIds nor removeIds provided
-                    ];
-                case 13:
+                                var building = (_a = e.fields) === null || _a === void 0 ? void 0 : _a.Building;
+                                return Array.isArray(building) ? building.includes('Building A') : building === 'Building A';
+                            }));
+                    }, updatedSummary)
                     // Test 7: Remove care team members with combined filters
-                    _b.sent();
+                ];
+            case 15:
+                // Test 6: Add care team members with custom field filter (array field)
+                _a.sent();
+                // Test 7: Remove care team members with combined filters
+                return [4 /*yield*/, expect_result("bulk_assignment: Remove with combined filters (customTypeId + field + existingAssignment)", function () { return sdk_1.api.endusers.bulk_assignment({
+                        customTypeId: '',
+                        field: 'Building',
+                        existingFieldValue: 'Building A',
+                        existingAssignment: {
+                            qualifier: 'All Of',
+                            values: [user1_1.id],
+                        },
+                        removeIds: [user1_1.id],
+                    }); }, function (r) {
+                        var _a;
+                        return (r.updated.length === 1
+                            && r.updated[0].id === enduserWithEmptyCustomType_1.id
+                            && !((_a = r.updated[0].assignedTo) === null || _a === void 0 ? void 0 : _a.includes(user1_1.id)));
+                    }, updatedSummary)
                     // Test 8: Error when neither addIds nor removeIds provided
-                    return [4 /*yield*/, async_test("bulk_assignment: Error when no addIds or removeIds", function () { return sdk.api.endusers.bulk_assignment({
-                            customTypeId: customTypeId,
-                        }); }, handleAnyError)
-                        // Cleanup
-                    ];
-                case 14:
-                    // Test 8: Error when neither addIds nor removeIds provided
-                    _b.sent();
-                    // Cleanup
-                    return [4 /*yield*/, Promise.all([
-                            sdk.api.endusers.deleteOne(enduserWithCustomType.id),
-                            sdk.api.endusers.deleteOne(enduserWithEmptyCustomType.id),
-                            sdk.api.endusers.deleteOne(enduserWithoutCustomType.id),
-                            sdk.api.endusers.deleteOne(enduserWithDifferentField.id),
-                            sdk.api.users.deleteOne(user1.id),
-                            sdk.api.users.deleteOne(user2.id),
-                        ])];
-                case 15:
-                    // Cleanup
-                    _b.sent();
-                    return [2 /*return*/];
-            }
-        });
+                ];
+            case 16:
+                // Test 7: Remove care team members with combined filters
+                _a.sent();
+                // Test 8: Error when neither addIds nor removeIds provided
+                return [4 /*yield*/, expect_rejected("bulk_assignment: Error when no addIds or removeIds", function () { return sdk_1.api.endusers.bulk_assignment({
+                        customTypeId: customTypeId_1,
+                    }); })
+                    // The shared-org version deleted its endusers and users here. Teardown discards the whole
+                    // tenant, so the records go with it.
+                ];
+            case 17:
+                // Test 8: Error when neither addIds nor removeIds provided
+                _a.sent();
+                return [3 /*break*/, 19];
+            case 18:
+                e_1 = _a.sent();
+                // A bare fixture 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('Bulk assignment suite ran to completion', false, "threw: ".concat(errorMessage(e_1)));
+                return [3 /*break*/, 19];
+            case 19: return [3 /*break*/, 25];
+            case 20:
+                if (!tenant) return [3 /*break*/, 24];
+                _a.label = 21;
+            case 21:
+                _a.trys.push([21, 23, , 24]);
+                return [4 /*yield*/, tenant.teardown()];
+            case 22:
+                _a.sent();
+                return [3 /*break*/, 24];
+            case 23:
+                e_2 = _a.sent();
+                console.error('teardown failed', e_2);
+                return [3 /*break*/, 24];
+            case 24: return [7 /*endfinally*/];
+            case 25: return [2 /*return*/, checks];
+        }
     });
+}); };
+/** Asserting wrapper, for standalone runs. */
+export var bulk_assignment_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 = ['Bulk assignment'];
+                return [4 /*yield*/, bulk_assignment_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: 'Bulk assignment',
+    run: bulk_assignment_checks,
 };
 // Allow running this test file independently
 if (require.main === module) {
     console.log("\uD83C\uDF10 Using API URL: ".concat(host));
-    var sdk_1 = new Session({ host: host });
-    var sdkNonAdmin_1 = new Session({ host: host });
-    var runTests = function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, setup_tests(sdk_1, sdkNonAdmin_1)];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, bulk_assignment_tests({ sdk: sdk_1, sdkNonAdmin: sdkNonAdmin_1 })];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    runTests()
+    bulk_assignment_tests()
         .then(function () {
         console.log("✅ Bulk assignment test suite completed successfully");
         process.exit(0);