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

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

@@ -44,319 +44,362 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 require('source-map-support').install();
-import { Session } from "../../sdk";
-import { assert, 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';
-// Main test function that can be called independently
-export var get_some_projection_tests = function (_a) {
-    var sdk = _a.sdk, sdkNonAdmin = _a.sdkNonAdmin;
-    return __awaiter(void 0, void 0, void 0, function () {
-        var testEnduser, observationIds, obs1, obs2, obs3, _i, observationIds_1, obsId, error_1, deleteError_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    log_header("getSome Projection Support");
-                    return [4 /*yield*/, sdk.api.endusers.createOne({ fname: 'ProjectionTest', lname: 'User', email: 'projection-test@tellescope.com' })];
-                case 1:
-                    testEnduser = _b.sent();
-                    observationIds = [];
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, , 13, 25]);
-                    return [4 /*yield*/, sdk.api.enduser_observations.createOne({
-                            enduserId: testEnduser.id,
-                            status: 'final',
-                            category: 'vital-signs',
-                            measurement: { value: 120, unit: 'mmHg' },
-                        })];
-                case 3:
-                    obs1 = _b.sent();
-                    return [4 /*yield*/, sdk.api.enduser_observations.createOne({
-                            enduserId: testEnduser.id,
-                            status: 'final',
-                            category: 'vital-signs',
-                            measurement: { value: 80, unit: 'mmHg' },
-                        })];
-                case 4:
-                    obs2 = _b.sent();
-                    return [4 /*yield*/, sdk.api.enduser_observations.createOne({
-                            enduserId: testEnduser.id,
-                            status: 'final',
-                            category: 'vital-signs',
-                            measurement: { value: 98, unit: 'bpm' },
-                        })];
-                case 5:
-                    obs3 = _b.sent();
-                    observationIds = [obs1.id, obs2.id, obs3.id];
+var RAND = function () { return Math.random().toString(36).slice(2, 10); };
+var PROJECTION_TEST_EMAIL = 'projection-test@tellescope.com';
+/**
+ * getSome `projection` coverage: which fields come back for an inclusion projection, for no
+ * projection, for an empty projection, alongside filter/limit/sortBy, across lastId pagination, on a
+ * second model (endusers), and for a non-admin session.
+ *
+ * Runs on its own provisioned tenant. Every check counts records — three observations, one enduser
+ * at a FIXED email address — so on the shared fixture org a concurrently running suite's observation
+ * or a leftover projection-test@tellescope.com enduser changed the counts. Owning the tenant is also
+ * what lets the enduser lookup assert an exact count instead of `>= 1`.
+ *
+ * Each former async_test's nested `assert` calls became one Check each: `assert` calls process.exit,
+ * which inside a pooled `run` would skip every concurrently running suite's teardown and strand its
+ * tenant permanently.
+ */
+export var get_some_projection_checks = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var checks, record, describe, errorMessage, presentIn, step, tenant, sdk_1, sdkNonAdmin_1, testEnduser_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)); };
+                presentIn = function (results, get) { return ("present in ".concat(results.filter(function (r) { return get(r) !== undefined; }).length, " of ").concat(results.length)); };
+                step = function (name, body) { return __awaiter(void 0, void 0, void 0, function () {
+                    var e_3;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, body()];
+                            case 1:
+                                _a.sent();
+                                return [3 /*break*/, 3];
+                            case 2:
+                                e_3 = _a.sent();
+                                record("".concat(name, ": block ran to completion"), false, "threw: ".concat(errorMessage(e_3)));
+                                return [3 /*break*/, 3];
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                }); };
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, , 17, 22]);
+                return [4 /*yield*/, setup_isolated_tenant({
+                        name: "getSome projection ".concat(RAND()),
+                        users: [{ isAdmin: true }, { roles: ['Non-Admin'] }],
+                        apiKeys: 0,
+                    })];
+            case 2:
+                tenant = _a.sent();
+                sdk_1 = tenant.sdk, sdkNonAdmin_1 = tenant.sdkNonAdmin;
+                _a.label = 3;
+            case 3:
+                _a.trys.push([3, 15, , 16]);
+                return [4 /*yield*/, sdk_1.api.endusers.createOne({
+                        fname: 'ProjectionTest', lname: 'User', email: PROJECTION_TEST_EMAIL,
+                        assignedTo: [tenant.users[1].id],
+                    })
+                    // Create test observations
+                ];
+            case 4:
+                testEnduser_1 = _a.sent();
+                // Create test observations
+                return [4 /*yield*/, sdk_1.api.enduser_observations.createOne({
+                        enduserId: testEnduser_1.id,
+                        status: 'final',
+                        category: 'vital-signs',
+                        measurement: { value: 120, unit: 'mmHg' },
+                    })];
+            case 5:
+                // Create test observations
+                _a.sent();
+                return [4 /*yield*/, sdk_1.api.enduser_observations.createOne({
+                        enduserId: testEnduser_1.id,
+                        status: 'final',
+                        category: 'vital-signs',
+                        measurement: { value: 80, unit: 'mmHg' },
+                    })];
+            case 6:
+                _a.sent();
+                return [4 /*yield*/, sdk_1.api.enduser_observations.createOne({
+                        enduserId: testEnduser_1.id,
+                        status: 'final',
+                        category: 'vital-signs',
+                        measurement: { value: 98, unit: 'bpm' },
+                    })
                     // Test 1: Inclusion projection returns only specified fields
-                    return [4 /*yield*/, async_test('projection-inclusion', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results, _i, results_1, r;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.enduser_observations.getSome({
-                                            filter: { enduserId: testEnduser.id },
-                                            projection: { timestamp: 1, measurement: 1, enduserId: 1 },
-                                        })];
-                                    case 1:
-                                        results = _a.sent();
-                                        assert(results.length === 3, 'Expected 3 observations with projection', 'Got correct count with projection');
-                                        for (_i = 0, results_1 = results; _i < results_1.length; _i++) {
-                                            r = results_1[_i];
-                                            assert(r.id !== undefined, 'id should always be present');
-                                            assert(r.createdAt !== undefined, 'createdAt should always be present');
-                                            assert(r.measurement !== undefined, 'measurement should be present in projection');
-                                            assert(r.enduserId !== undefined, 'enduserId should be present in projection');
-                                            assert(r.timestamp !== undefined, 'timestamp should be present in projection');
-                                            // Fields NOT in projection should be excluded
-                                            assert(r.status === undefined, 'status should NOT be present when not in projection');
-                                            assert(r.category === undefined, 'category should NOT be present when not in projection');
-                                        }
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 2: No projection returns all fields (backward compatibility)
-                    ];
-                case 6:
-                    // Test 1: Inclusion projection returns only specified fields
-                    _b.sent();
+                ];
+            case 7:
+                _a.sent();
+                // Test 1: Inclusion projection returns only specified fields
+                return [4 /*yield*/, step('projection-inclusion', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.enduser_observations.getSome({
+                                        filter: { enduserId: testEnduser_1.id },
+                                        projection: { timestamp: 1, measurement: 1, enduserId: 1 },
+                                    })];
+                                case 1:
+                                    results = _a.sent();
+                                    record('projection-inclusion: Expected 3 observations with projection', results.length === 3, "length=".concat(results.length));
+                                    // One Check per nested assert, evaluated over every returned record rather than once per
+                                    // record, so the labels stay one-to-one with the original asserts.
+                                    record('projection-inclusion: id should always be present', results.every(function (r) { return r.id !== undefined; }), "ids=".concat(describe(results.map(function (r) { return r.id; }))));
+                                    record('projection-inclusion: createdAt should always be present', results.every(function (r) { return r.createdAt !== undefined; }), "createdAts=".concat(describe(results.map(function (r) { return r.createdAt; }))));
+                                    record('projection-inclusion: measurement should be present in projection', results.every(function (r) { return r.measurement !== undefined; }), "measurements=".concat(describe(results.map(function (r) { return r.measurement; }))));
+                                    record('projection-inclusion: enduserId should be present in projection', results.every(function (r) { return r.enduserId !== undefined; }), "enduserIds=".concat(describe(results.map(function (r) { return r.enduserId; }))));
+                                    record('projection-inclusion: timestamp should be present in projection', results.every(function (r) { return r.timestamp !== undefined; }), "timestamps=".concat(describe(results.map(function (r) { return r.timestamp; }))));
+                                    // Fields NOT in projection should be excluded
+                                    record('projection-inclusion: status should NOT be present when not in projection', results.every(function (r) { return r.status === undefined; }), "status ".concat(presentIn(results, function (r) { return r.status; })));
+                                    record('projection-inclusion: category should NOT be present when not in projection', results.every(function (r) { return r.category === undefined; }), "category ".concat(presentIn(results, function (r) { return r.category; })));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
                     // Test 2: No projection returns all fields (backward compatibility)
-                    return [4 /*yield*/, async_test('no-projection-returns-all-fields', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results, _i, results_2, r;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.enduser_observations.getSome({
-                                            filter: { enduserId: testEnduser.id },
-                                        })];
-                                    case 1:
-                                        results = _a.sent();
-                                        assert(results.length === 3, 'Expected 3 observations without projection');
-                                        for (_i = 0, results_2 = results; _i < results_2.length; _i++) {
-                                            r = results_2[_i];
-                                            assert(r.id !== undefined, 'id should be present');
-                                            assert(r.status !== undefined, 'status should be present without projection');
-                                            assert(r.category !== undefined, 'category should be present without projection');
-                                            assert(r.measurement !== undefined, 'measurement should be present without projection');
-                                            assert(r.enduserId !== undefined, 'enduserId should be present without projection');
-                                        }
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 3: Projection with other filters (filter, limit, sortBy)
-                    ];
-                case 7:
-                    // Test 2: No projection returns all fields (backward compatibility)
-                    _b.sent();
-                    // Test 3: Projection with other filters (filter, limit, sortBy)
-                    return [4 /*yield*/, async_test('projection-with-filters', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results, _i, results_3, r;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.enduser_observations.getSome({
-                                            filter: { enduserId: testEnduser.id },
-                                            projection: { measurement: 1 },
-                                            limit: 2,
-                                            sortBy: 'timestamp',
-                                        })];
-                                    case 1:
-                                        results = _a.sent();
-                                        assert(results.length === 2, 'Expected 2 observations with limit=2', "Got ".concat(results.length));
-                                        for (_i = 0, results_3 = results; _i < results_3.length; _i++) {
-                                            r = results_3[_i];
-                                            assert(r.measurement !== undefined, 'measurement should be present in projection');
-                                            assert(r.status === undefined, 'status should NOT be present when not in projection');
-                                        }
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 4: Projection works across different models (endusers)
-                    ];
-                case 8:
+                ];
+            case 8:
+                // Test 1: Inclusion projection returns only specified fields
+                _a.sent();
+                // Test 2: No projection returns all fields (backward compatibility)
+                return [4 /*yield*/, step('no-projection-returns-all-fields', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.enduser_observations.getSome({
+                                        filter: { enduserId: testEnduser_1.id },
+                                    })];
+                                case 1:
+                                    results = _a.sent();
+                                    record('no-projection-returns-all-fields: Expected 3 observations without projection', results.length === 3, "length=".concat(results.length));
+                                    record('no-projection-returns-all-fields: id should be present', results.every(function (r) { return r.id !== undefined; }), "ids=".concat(describe(results.map(function (r) { return r.id; }))));
+                                    record('no-projection-returns-all-fields: status should be present without projection', results.every(function (r) { return r.status !== undefined; }), "statuses=".concat(describe(results.map(function (r) { return r.status; }))));
+                                    record('no-projection-returns-all-fields: category should be present without projection', results.every(function (r) { return r.category !== undefined; }), "categories=".concat(describe(results.map(function (r) { return r.category; }))));
+                                    record('no-projection-returns-all-fields: measurement should be present without projection', results.every(function (r) { return r.measurement !== undefined; }), "measurements=".concat(describe(results.map(function (r) { return r.measurement; }))));
+                                    record('no-projection-returns-all-fields: enduserId should be present without projection', results.every(function (r) { return r.enduserId !== undefined; }), "enduserIds=".concat(describe(results.map(function (r) { return r.enduserId; }))));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
                     // Test 3: Projection with other filters (filter, limit, sortBy)
-                    _b.sent();
+                ];
+            case 9:
+                // Test 2: No projection returns all fields (backward compatibility)
+                _a.sent();
+                // Test 3: Projection with other filters (filter, limit, sortBy)
+                return [4 /*yield*/, step('projection-with-filters', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.enduser_observations.getSome({
+                                        filter: { enduserId: testEnduser_1.id },
+                                        projection: { measurement: 1 },
+                                        limit: 2,
+                                        sortBy: 'timestamp',
+                                    })];
+                                case 1:
+                                    results = _a.sent();
+                                    record('projection-with-filters: Expected 2 observations with limit=2', results.length === 2, "Got ".concat(results.length));
+                                    record('projection-with-filters: measurement should be present in projection', results.every(function (r) { return r.measurement !== undefined; }), "measurements=".concat(describe(results.map(function (r) { return r.measurement; }))));
+                                    record('projection-with-filters: status should NOT be present when not in projection', results.every(function (r) { return r.status === undefined; }), "status ".concat(presentIn(results, function (r) { return r.status; })));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
                     // Test 4: Projection works across different models (endusers)
-                    return [4 /*yield*/, async_test('projection-on-endusers', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results, enduser;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.endusers.getSome({
-                                            filter: { email: 'projection-test@tellescope.com' },
-                                            projection: { fname: 1, email: 1 },
-                                        })];
-                                    case 1:
-                                        results = _a.sent();
-                                        assert(results.length >= 1, 'Expected at least 1 enduser');
-                                        enduser = results[0];
-                                        assert(enduser.id !== undefined, 'id should always be present');
-                                        assert(enduser.fname !== undefined, 'fname should be present in projection');
-                                        assert(enduser.email !== undefined, 'email should be present in projection');
-                                        assert(enduser.lname === undefined, 'lname should NOT be present when not in projection');
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 5: Projection with pagination (lastId)
-                    ];
-                case 9:
-                    // Test 4: Projection works across different models (endusers)
-                    _b.sent();
+                ];
+            case 10:
+                // Test 3: Projection with other filters (filter, limit, sortBy)
+                _a.sent();
+                // Test 4: Projection works across different models (endusers)
+                return [4 /*yield*/, step('projection-on-endusers', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results, enduser;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.endusers.getSome({
+                                        filter: { email: PROJECTION_TEST_EMAIL },
+                                        projection: { fname: 1, email: 1 },
+                                    })
+                                    // Tightened from the shared-org version's `>= 1`: this tenant has exactly one enduser, so an
+                                    // exact count is unambiguous here and a stray second match is now a real failure.
+                                ];
+                                case 1:
+                                    results = _a.sent();
+                                    // Tightened from the shared-org version's `>= 1`: this tenant has exactly one enduser, so an
+                                    // exact count is unambiguous here and a stray second match is now a real failure.
+                                    record('projection-on-endusers: Expected exactly 1 enduser', results.length === 1, "length=".concat(results.length));
+                                    enduser = results[0];
+                                    record('projection-on-endusers: id should always be present', (enduser === null || enduser === void 0 ? void 0 : enduser.id) !== undefined, "id=".concat(describe(enduser === null || enduser === void 0 ? void 0 : enduser.id)));
+                                    record('projection-on-endusers: fname should be present in projection', (enduser === null || enduser === void 0 ? void 0 : enduser.fname) !== undefined, "fname=".concat(describe(enduser === null || enduser === void 0 ? void 0 : enduser.fname)));
+                                    record('projection-on-endusers: email should be present in projection', (enduser === null || enduser === void 0 ? void 0 : enduser.email) !== undefined, "email=".concat(describe(enduser === null || enduser === void 0 ? void 0 : enduser.email)));
+                                    record('projection-on-endusers: lname should NOT be present when not in projection', (enduser === null || enduser === void 0 ? void 0 : enduser.lname) === undefined, "lname=".concat(describe(enduser === null || enduser === void 0 ? void 0 : enduser.lname)));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
                     // Test 5: Projection with pagination (lastId)
-                    return [4 /*yield*/, async_test('projection-with-pagination', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var page1, lastId, page2, _i, _a, r;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.enduser_observations.getSome({
-                                            filter: { enduserId: testEnduser.id },
+                ];
+            case 11:
+                // Test 4: Projection works across different models (endusers)
+                _a.sent();
+                // Test 5: Projection with pagination (lastId)
+                return [4 /*yield*/, step('projection-with-pagination', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var page1, lastId, page2, bothPages;
+                        var _a;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.enduser_observations.getSome({
+                                        filter: { enduserId: testEnduser_1.id },
+                                        projection: { measurement: 1, enduserId: 1 },
+                                        limit: 2,
+                                        sort: 'oldFirst',
+                                    })];
+                                case 1:
+                                    page1 = _b.sent();
+                                    record('projection-with-pagination: Expected 2 observations on first page', page1.length === 2, "length=".concat(page1.length));
+                                    lastId = (_a = page1[page1.length - 1]) === null || _a === void 0 ? void 0 : _a.id;
+                                    return [4 /*yield*/, sdk_1.api.enduser_observations.getSome({
+                                            filter: { enduserId: testEnduser_1.id },
                                             projection: { measurement: 1, enduserId: 1 },
                                             limit: 2,
                                             sort: 'oldFirst',
+                                            lastId: lastId,
                                         })];
-                                    case 1:
-                                        page1 = _b.sent();
-                                        assert(page1.length === 2, 'Expected 2 observations on first page');
-                                        lastId = page1[page1.length - 1].id;
-                                        return [4 /*yield*/, sdk.api.enduser_observations.getSome({
-                                                filter: { enduserId: testEnduser.id },
-                                                projection: { measurement: 1, enduserId: 1 },
-                                                limit: 2,
-                                                sort: 'oldFirst',
-                                                lastId: lastId,
-                                            })];
-                                    case 2:
-                                        page2 = _b.sent();
-                                        assert(page2.length === 1, 'Expected 1 observation on second page');
-                                        // Verify consistent fields across pages
-                                        for (_i = 0, _a = __spreadArray(__spreadArray([], page1, true), page2, true); _i < _a.length; _i++) {
-                                            r = _a[_i];
-                                            assert(r.measurement !== undefined, 'measurement should be present across pages');
-                                            assert(r.enduserId !== undefined, 'enduserId should be present across pages');
-                                            assert(r.status === undefined, 'status should NOT be present across pages');
-                                        }
-                                        return [2 /*return*/, __spreadArray(__spreadArray([], page1, true), page2, true)];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 6: Empty projection returns all fields (no crash)
-                    ];
-                case 10:
-                    // Test 5: Projection with pagination (lastId)
-                    _b.sent();
+                                case 2:
+                                    page2 = _b.sent();
+                                    record('projection-with-pagination: Expected 1 observation on second page', page2.length === 1, "length=".concat(page2.length, " (lastId=").concat(describe(lastId), ")"));
+                                    bothPages = __spreadArray(__spreadArray([], page1, true), page2, true);
+                                    record('projection-with-pagination: measurement should be present across pages', bothPages.every(function (r) { return r.measurement !== undefined; }), "measurements=".concat(describe(bothPages.map(function (r) { return r.measurement; }))));
+                                    record('projection-with-pagination: enduserId should be present across pages', bothPages.every(function (r) { return r.enduserId !== undefined; }), "enduserIds=".concat(describe(bothPages.map(function (r) { return r.enduserId; }))));
+                                    record('projection-with-pagination: status should NOT be present across pages', bothPages.every(function (r) { return r.status === undefined; }), "status ".concat(presentIn(bothPages, function (r) { return r.status; })));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
                     // Test 6: Empty projection returns all fields (no crash)
-                    return [4 /*yield*/, async_test('empty-projection', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results, _i, results_4, r;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdk.api.enduser_observations.getSome({
-                                            filter: { enduserId: testEnduser.id },
-                                            projection: {},
-                                        })];
-                                    case 1:
-                                        results = _a.sent();
-                                        assert(results.length === 3, 'Expected 3 observations with empty projection');
-                                        for (_i = 0, results_4 = results; _i < results_4.length; _i++) {
-                                            r = results_4[_i];
-                                            assert(r.status !== undefined, 'status should be present with empty projection');
-                                            assert(r.category !== undefined, 'category should be present with empty projection');
-                                            assert(r.measurement !== undefined, 'measurement should be present with empty projection');
-                                        }
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })
-                        // Test 7: Non-admin access with projection (RBA still applies)
-                    ];
-                case 11:
-                    // Test 6: Empty projection returns all fields (no crash)
-                    _b.sent();
+                ];
+            case 12:
+                // Test 5: Projection with pagination (lastId)
+                _a.sent();
+                // Test 6: Empty projection returns all fields (no crash)
+                return [4 /*yield*/, step('empty-projection', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, sdk_1.api.enduser_observations.getSome({
+                                        filter: { enduserId: testEnduser_1.id },
+                                        projection: {},
+                                    })];
+                                case 1:
+                                    results = _a.sent();
+                                    record('empty-projection: Expected 3 observations with empty projection', results.length === 3, "length=".concat(results.length));
+                                    record('empty-projection: status should be present with empty projection', results.every(function (r) { return r.status !== undefined; }), "statuses=".concat(describe(results.map(function (r) { return r.status; }))));
+                                    record('empty-projection: category should be present with empty projection', results.every(function (r) { return r.category !== undefined; }), "categories=".concat(describe(results.map(function (r) { return r.category; }))));
+                                    record('empty-projection: measurement should be present with empty projection', results.every(function (r) { return r.measurement !== undefined; }), "measurements=".concat(describe(results.map(function (r) { return r.measurement; }))));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
                     // Test 7: Non-admin access with projection (RBA still applies)
-                    return [4 /*yield*/, async_test('non-admin-projection', function () { return __awaiter(void 0, void 0, void 0, function () {
-                            var results, _i, results_5, r;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, sdkNonAdmin.api.enduser_observations.getSome({
-                                            filter: { enduserId: testEnduser.id },
-                                            projection: { measurement: 1, enduserId: 1 },
-                                        })
-                                        // Non-admin should still get results (RBA should apply)
-                                    ];
-                                    case 1:
-                                        results = _a.sent();
-                                        // Non-admin should still get results (RBA should apply)
-                                        assert(Array.isArray(results), 'Non-admin should receive an array response');
-                                        for (_i = 0, results_5 = results; _i < results_5.length; _i++) {
-                                            r = results_5[_i];
-                                            assert(r.measurement !== undefined, 'measurement should be present for non-admin projection');
-                                            assert(r.enduserId !== undefined, 'enduserId should be present for non-admin projection');
-                                        }
-                                        return [2 /*return*/, results];
-                                }
-                            });
-                        }); }, { onResult: function () { return true; } })];
-                case 12:
-                    // Test 7: Non-admin access with projection (RBA still applies)
-                    _b.sent();
-                    return [3 /*break*/, 25];
-                case 13:
-                    _b.trys.push([13, 19, , 24]);
-                    _i = 0, observationIds_1 = observationIds;
-                    _b.label = 14;
-                case 14:
-                    if (!(_i < observationIds_1.length)) return [3 /*break*/, 17];
-                    obsId = observationIds_1[_i];
-                    return [4 /*yield*/, sdk.api.enduser_observations.deleteOne(obsId)];
-                case 15:
-                    _b.sent();
-                    _b.label = 16;
-                case 16:
-                    _i++;
-                    return [3 /*break*/, 14];
-                case 17: return [4 /*yield*/, sdk.api.endusers.deleteOne(testEnduser.id)];
-                case 18:
-                    _b.sent();
-                    return [3 /*break*/, 24];
-                case 19:
-                    error_1 = _b.sent();
-                    console.error('Cleanup error:', error_1);
-                    _b.label = 20;
-                case 20:
-                    _b.trys.push([20, 22, , 23]);
-                    return [4 /*yield*/, sdk.api.endusers.deleteOne(testEnduser.id)];
-                case 21:
-                    _b.sent();
-                    return [3 /*break*/, 23];
-                case 22:
-                    deleteError_1 = _b.sent();
-                    console.error('Failed to delete test enduser:', deleteError_1);
-                    return [3 /*break*/, 23];
-                case 23: return [3 /*break*/, 24];
-                case 24: return [7 /*endfinally*/];
-                case 25: return [2 /*return*/];
-            }
-        });
+                ];
+            case 13:
+                // Test 6: Empty projection returns all fields (no crash)
+                _a.sent();
+                // Test 7: Non-admin access with projection (RBA still applies)
+                return [4 /*yield*/, step('non-admin-projection', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        var results;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, sdkNonAdmin_1.api.enduser_observations.getSome({
+                                        filter: { enduserId: testEnduser_1.id },
+                                        projection: { measurement: 1, enduserId: 1 },
+                                    })
+                                    // Non-admin should still get results (RBA should apply)
+                                ];
+                                case 1:
+                                    results = _a.sent();
+                                    // Non-admin should still get results (RBA should apply)
+                                    record('non-admin-projection: Non-admin should receive an array response', Array.isArray(results), "results=".concat(describe(results.map(function (r) { return r.id; }))));
+                                    // `.every` over an empty array is true, so these two asserted nothing whenever RBA returned
+                                    // nothing — which, before the care-team assignment above, was always. The length guard is
+                                    // what stops them passing vacuously again if enduser access regresses.
+                                    record('non-admin-projection: measurement should be present for non-admin projection', results.length === 3 && results.every(function (r) { return r.measurement !== undefined; }), "measurements=".concat(describe(results.map(function (r) { return r.measurement; }))));
+                                    record('non-admin-projection: enduserId should be present for non-admin projection', results.length === 3 && results.every(function (r) { return r.enduserId !== undefined; }), "enduserIds=".concat(describe(results.map(function (r) { return r.enduserId; }))));
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })
+                    // The shared-org version deleted its observations and enduser here. Teardown discards the
+                    // whole tenant, so the records go with it.
+                ];
+            case 14:
+                // Test 7: Non-admin access with projection (RBA still applies)
+                _a.sent();
+                return [3 /*break*/, 16];
+            case 15:
+                e_1 = _a.sent();
+                // A fixture write outside a step threw. Record it rather than letting it escape `run`, which
+                // would fail every other suite in the batch instead of just this one.
+                record('getSome projection suite ran to completion', false, "threw: ".concat(errorMessage(e_1)));
+                return [3 /*break*/, 16];
+            case 16: return [3 /*break*/, 22];
+            case 17:
+                if (!tenant) return [3 /*break*/, 21];
+                _a.label = 18;
+            case 18:
+                _a.trys.push([18, 20, , 21]);
+                return [4 /*yield*/, tenant.teardown()];
+            case 19:
+                _a.sent();
+                return [3 /*break*/, 21];
+            case 20:
+                e_2 = _a.sent();
+                console.error('teardown failed', e_2);
+                return [3 /*break*/, 21];
+            case 21: return [7 /*endfinally*/];
+            case 22: return [2 /*return*/, checks];
+        }
+    });
+}); };
+/** Asserting wrapper, for standalone runs. */
+export var get_some_projection_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 = ['getSome projection'];
+                return [4 /*yield*/, get_some_projection_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: 'getSome projection',
+    run: get_some_projection_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*/, get_some_projection_tests({ sdk: sdk_1, sdkNonAdmin: sdkNonAdmin_1 })];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    runTests()
+    get_some_projection_tests()
         .then(function () {
         console.log("✅ getSome projection test suite completed successfully");
         process.exit(0);