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

package/src/tests/api_tests/get_some_projection.test.ts

@@ -1,137 +1,267 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
 import {
-  assert,
-  async_test,
-  log_header,
-} from "@tellescope/testing"
-import { setup_tests } from "../setup"
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
-// Main test function that can be called independently
-export const get_some_projection_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("getSome Projection Support")
+const RAND = () => Math.random().toString(36).slice(2, 10)
 
-  // Create test enduser
-  const testEnduser = await sdk.api.endusers.createOne({ fname: 'ProjectionTest', lname: 'User', email: 'projection-test@tellescope.com' })
+const PROJECTION_TEST_EMAIL = 'projection-test@tellescope.com'
 
-  let observationIds: string[] = []
+/**
+ * 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 const get_some_projection_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  // The raw value decides the fallback, not JSON.stringify of it — JSON.stringify('') is '""',
+  // which is truthy, so a `|| fallback` on the stringified form could never fire.
+  const describe = (value: any): string => {
+    if (value === undefined || value === null) return String(value)
+    const stringified = JSON.stringify(value)
+    return stringified === undefined ? String(value) : stringified
+  }
+  const errorMessage = (e: any): string => (
+    typeof e?.message === 'string' && e.message !== '' ? e.message : describe(e)
+  )
+  /** For the absence checks: JSON.stringify renders undefined inside an array as `null`, which reads
+   *  as "the field is null" rather than "the field is not there". Count instead. */
+  const presentIn = <T,>(results: T[], get: (r: T) => any) => (
+    `present in ${results.filter(r => get(r) !== undefined).length} of ${results.length}`
+  )
+
+  /**
+   * One former async_test block. Its nested asserts became `record` calls labelled
+   * `<block>: <the assert's own message>`; anything the block throws fails THIS block and nothing
+   * else, instead of escaping `run` — which, per run_isolated_in_parallel, would fail the whole
+   * batch rather than one check.
+   */
+  const step = async (name: string, body: () => Promise<void>) => {
+    try {
+      await body()
+    } catch (e: any) {
+      record(`${name}: block ran to completion`, false, `threw: ${errorMessage(e)}`)
+    }
+  }
+
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
-    // Create test observations
-    const obs1 = await sdk.api.enduser_observations.createOne({
-      enduserId: testEnduser.id,
-      status: 'final',
-      category: 'vital-signs',
-      measurement: { value: 120, unit: 'mmHg' },
-    })
-    const obs2 = await sdk.api.enduser_observations.createOne({
-      enduserId: testEnduser.id,
-      status: 'final',
-      category: 'vital-signs',
-      measurement: { value: 80, unit: 'mmHg' },
+    tenant = await setup_isolated_tenant({
+      name: `getSome projection ${RAND()}`,
+      users: [{ isAdmin: true }, { roles: ['Non-Admin'] }],
+      apiKeys: 0,
     })
-    const obs3 = await sdk.api.enduser_observations.createOne({
-      enduserId: testEnduser.id,
-      status: 'final',
-      category: 'vital-signs',
-      measurement: { value: 98, unit: 'bpm' },
-    })
-    observationIds = [obs1.id, obs2.id, obs3.id]
+    const { sdk, sdkNonAdmin } = tenant
+
+    try {
+      // Create test enduser.
+      //
+      // assignedTo is the one fixture detail that is NOT carried over verbatim, and it is what makes
+      // test 7 mean anything. A non-admin reads endusers through
+      // `{ $or: [{ assignedTo: userId }, { creator: userId }] }` (modifyFilterForAccessConstraint,
+      // api/modules/database.ts) and observations through the set of endusers that query returns —
+      // and this one is created by the ADMIN, so on the shared fixture org the non-admin's query
+      // returned [] and both field checks passed vacuously over an empty array. Putting users[1] on
+      // the care team leaves every admin-side count and projection identical (assignedTo is in none
+      // of them) while letting the RBA check assert.
+      const testEnduser = await sdk.api.endusers.createOne({
+        fname: 'ProjectionTest', lname: 'User', email: PROJECTION_TEST_EMAIL,
+        assignedTo: [tenant.users[1].id],
+      })
+
+      // Create test observations
+      await sdk.api.enduser_observations.createOne({
+        enduserId: testEnduser.id,
+        status: 'final',
+        category: 'vital-signs',
+        measurement: { value: 120, unit: 'mmHg' },
+      })
+      await sdk.api.enduser_observations.createOne({
+        enduserId: testEnduser.id,
+        status: 'final',
+        category: 'vital-signs',
+        measurement: { value: 80, unit: 'mmHg' },
+      })
+      await sdk.api.enduser_observations.createOne({
+        enduserId: testEnduser.id,
+        status: 'final',
+        category: 'vital-signs',
+        measurement: { value: 98, unit: 'bpm' },
+      })
 
-    // Test 1: Inclusion projection returns only specified fields
-    await async_test(
-      'projection-inclusion',
-      async () => {
+      // Test 1: Inclusion projection returns only specified fields
+      await step('projection-inclusion', async () => {
         const results = await sdk.api.enduser_observations.getSome({
           filter: { enduserId: testEnduser.id },
           projection: { timestamp: 1, measurement: 1, enduserId: 1 },
         })
-        assert(results.length === 3, 'Expected 3 observations with projection', 'Got correct count with projection')
-
-        for (const r of results) {
-          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 as any).status === undefined, 'status should NOT be present when not in projection')
-          assert((r as any).category === undefined, 'category should NOT be present when not in projection')
-        }
-        return results
-      },
-      { onResult: () => true },
-    )
-
-    // Test 2: No projection returns all fields (backward compatibility)
-    await async_test(
-      'no-projection-returns-all-fields',
-      async () => {
+        record(
+          'projection-inclusion: Expected 3 observations with projection',
+          results.length === 3,
+          `length=${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(r => r.id !== undefined),
+          `ids=${describe(results.map(r => r.id))}`,
+        )
+        record(
+          'projection-inclusion: createdAt should always be present',
+          results.every(r => r.createdAt !== undefined),
+          `createdAts=${describe(results.map(r => r.createdAt))}`,
+        )
+        record(
+          'projection-inclusion: measurement should be present in projection',
+          results.every(r => r.measurement !== undefined),
+          `measurements=${describe(results.map(r => r.measurement))}`,
+        )
+        record(
+          'projection-inclusion: enduserId should be present in projection',
+          results.every(r => r.enduserId !== undefined),
+          `enduserIds=${describe(results.map(r => r.enduserId))}`,
+        )
+        record(
+          'projection-inclusion: timestamp should be present in projection',
+          results.every(r => r.timestamp !== undefined),
+          `timestamps=${describe(results.map(r => r.timestamp))}`,
+        )
+        // Fields NOT in projection should be excluded
+        record(
+          'projection-inclusion: status should NOT be present when not in projection',
+          results.every(r => (r as any).status === undefined),
+          `status ${presentIn(results, r => (r as any).status)}`,
+        )
+        record(
+          'projection-inclusion: category should NOT be present when not in projection',
+          results.every(r => (r as any).category === undefined),
+          `category ${presentIn(results, r => (r as any).category)}`,
+        )
+      })
+
+      // Test 2: No projection returns all fields (backward compatibility)
+      await step('no-projection-returns-all-fields', async () => {
         const results = await sdk.api.enduser_observations.getSome({
           filter: { enduserId: testEnduser.id },
         })
-        assert(results.length === 3, 'Expected 3 observations without projection')
-
-        for (const r of results) {
-          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 results
-      },
-      { onResult: () => true },
-    )
-
-    // Test 3: Projection with other filters (filter, limit, sortBy)
-    await async_test(
-      'projection-with-filters',
-      async () => {
+        record(
+          'no-projection-returns-all-fields: Expected 3 observations without projection',
+          results.length === 3,
+          `length=${results.length}`,
+        )
+
+        record(
+          'no-projection-returns-all-fields: id should be present',
+          results.every(r => r.id !== undefined),
+          `ids=${describe(results.map(r => r.id))}`,
+        )
+        record(
+          'no-projection-returns-all-fields: status should be present without projection',
+          results.every(r => r.status !== undefined),
+          `statuses=${describe(results.map(r => r.status))}`,
+        )
+        record(
+          'no-projection-returns-all-fields: category should be present without projection',
+          results.every(r => r.category !== undefined),
+          `categories=${describe(results.map(r => r.category))}`,
+        )
+        record(
+          'no-projection-returns-all-fields: measurement should be present without projection',
+          results.every(r => r.measurement !== undefined),
+          `measurements=${describe(results.map(r => r.measurement))}`,
+        )
+        record(
+          'no-projection-returns-all-fields: enduserId should be present without projection',
+          results.every(r => r.enduserId !== undefined),
+          `enduserIds=${describe(results.map(r => r.enduserId))}`,
+        )
+      })
+
+      // Test 3: Projection with other filters (filter, limit, sortBy)
+      await step('projection-with-filters', async () => {
         const results = await sdk.api.enduser_observations.getSome({
           filter: { enduserId: testEnduser.id },
           projection: { measurement: 1 },
           limit: 2,
           sortBy: 'timestamp',
         })
-        assert(results.length === 2, 'Expected 2 observations with limit=2', `Got ${results.length}`)
-
-        for (const r of results) {
-          assert(r.measurement !== undefined, 'measurement should be present in projection')
-          assert((r as any).status === undefined, 'status should NOT be present when not in projection')
-        }
-        return results
-      },
-      { onResult: () => true },
-    )
-
-    // Test 4: Projection works across different models (endusers)
-    await async_test(
-      'projection-on-endusers',
-      async () => {
+        record(
+          'projection-with-filters: Expected 2 observations with limit=2',
+          results.length === 2,
+          `Got ${results.length}`,
+        )
+
+        record(
+          'projection-with-filters: measurement should be present in projection',
+          results.every(r => r.measurement !== undefined),
+          `measurements=${describe(results.map(r => r.measurement))}`,
+        )
+        record(
+          'projection-with-filters: status should NOT be present when not in projection',
+          results.every(r => (r as any).status === undefined),
+          `status ${presentIn(results, r => (r as any).status)}`,
+        )
+      })
+
+      // Test 4: Projection works across different models (endusers)
+      await step('projection-on-endusers', async () => {
         const results = await sdk.api.endusers.getSome({
-          filter: { email: 'projection-test@tellescope.com' },
+          filter: { email: PROJECTION_TEST_EMAIL },
           projection: { fname: 1, email: 1 },
         })
-        assert(results.length >= 1, 'Expected at least 1 enduser')
+        // 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=${results.length}`,
+        )
 
         const 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 as any).lname === undefined, 'lname should NOT be present when not in projection')
-        return results
-      },
-      { onResult: () => true },
-    )
-
-    // Test 5: Projection with pagination (lastId)
-    await async_test(
-      'projection-with-pagination',
-      async () => {
+        record(
+          'projection-on-endusers: id should always be present',
+          enduser?.id !== undefined,
+          `id=${describe(enduser?.id)}`,
+        )
+        record(
+          'projection-on-endusers: fname should be present in projection',
+          enduser?.fname !== undefined,
+          `fname=${describe(enduser?.fname)}`,
+        )
+        record(
+          'projection-on-endusers: email should be present in projection',
+          enduser?.email !== undefined,
+          `email=${describe(enduser?.email)}`,
+        )
+        record(
+          'projection-on-endusers: lname should NOT be present when not in projection',
+          (enduser as any)?.lname === undefined,
+          `lname=${describe((enduser as any)?.lname)}`,
+        )
+      })
+
+      // Test 5: Projection with pagination (lastId)
+      await step('projection-with-pagination', async () => {
         // First page
         const page1 = await sdk.api.enduser_observations.getSome({
           filter: { enduserId: testEnduser.id },
@@ -139,10 +269,14 @@ export const get_some_projection_tests = async ({ sdk, sdkNonAdmin } : { sdk: Se
           limit: 2,
           sort: 'oldFirst',
         })
-        assert(page1.length === 2, 'Expected 2 observations on first page')
+        record(
+          'projection-with-pagination: Expected 2 observations on first page',
+          page1.length === 2,
+          `length=${page1.length}`,
+        )
 
         // Second page using lastId from first page
-        const lastId = page1[page1.length - 1].id
+        const lastId = page1[page1.length - 1]?.id
         const page2 = await sdk.api.enduser_observations.getSome({
           filter: { enduserId: testEnduser.id },
           projection: { measurement: 1, enduserId: 1 },
@@ -150,90 +284,120 @@ export const get_some_projection_tests = async ({ sdk, sdkNonAdmin } : { sdk: Se
           sort: 'oldFirst',
           lastId,
         })
-        assert(page2.length === 1, 'Expected 1 observation on second page')
+        record(
+          'projection-with-pagination: Expected 1 observation on second page',
+          page2.length === 1,
+          `length=${page2.length} (lastId=${describe(lastId)})`,
+        )
 
         // Verify consistent fields across pages
-        for (const r of [...page1, ...page2]) {
-          assert(r.measurement !== undefined, 'measurement should be present across pages')
-          assert(r.enduserId !== undefined, 'enduserId should be present across pages')
-          assert((r as any).status === undefined, 'status should NOT be present across pages')
-        }
-        return [...page1, ...page2]
-      },
-      { onResult: () => true },
-    )
-
-    // Test 6: Empty projection returns all fields (no crash)
-    await async_test(
-      'empty-projection',
-      async () => {
+        const bothPages = [...page1, ...page2]
+        record(
+          'projection-with-pagination: measurement should be present across pages',
+          bothPages.every(r => r.measurement !== undefined),
+          `measurements=${describe(bothPages.map(r => r.measurement))}`,
+        )
+        record(
+          'projection-with-pagination: enduserId should be present across pages',
+          bothPages.every(r => r.enduserId !== undefined),
+          `enduserIds=${describe(bothPages.map(r => r.enduserId))}`,
+        )
+        record(
+          'projection-with-pagination: status should NOT be present across pages',
+          bothPages.every(r => (r as any).status === undefined),
+          `status ${presentIn(bothPages, r => (r as any).status)}`,
+        )
+      })
+
+      // Test 6: Empty projection returns all fields (no crash)
+      await step('empty-projection', async () => {
         const results = await sdk.api.enduser_observations.getSome({
           filter: { enduserId: testEnduser.id },
           projection: {},
         })
-        assert(results.length === 3, 'Expected 3 observations with empty projection')
-
-        for (const r of results) {
-          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 results
-      },
-      { onResult: () => true },
-    )
-
-    // Test 7: Non-admin access with projection (RBA still applies)
-    await async_test(
-      'non-admin-projection',
-      async () => {
+        record(
+          'empty-projection: Expected 3 observations with empty projection',
+          results.length === 3,
+          `length=${results.length}`,
+        )
+
+        record(
+          'empty-projection: status should be present with empty projection',
+          results.every(r => r.status !== undefined),
+          `statuses=${describe(results.map(r => r.status))}`,
+        )
+        record(
+          'empty-projection: category should be present with empty projection',
+          results.every(r => r.category !== undefined),
+          `categories=${describe(results.map(r => r.category))}`,
+        )
+        record(
+          'empty-projection: measurement should be present with empty projection',
+          results.every(r => r.measurement !== undefined),
+          `measurements=${describe(results.map(r => r.measurement))}`,
+        )
+      })
+
+      // Test 7: Non-admin access with projection (RBA still applies)
+      await step('non-admin-projection', async () => {
         const results = await sdkNonAdmin.api.enduser_observations.getSome({
           filter: { enduserId: testEnduser.id },
           projection: { measurement: 1, enduserId: 1 },
         })
         // Non-admin should still get results (RBA should apply)
-        assert(Array.isArray(results), 'Non-admin should receive an array response')
+        record(
+          'non-admin-projection: Non-admin should receive an array response',
+          Array.isArray(results),
+          `results=${describe(results.map(r => r.id))}`,
+        )
 
-        for (const r of results) {
-          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 results
-      },
-      { onResult: () => true },
-    )
+        // `.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(r => r.measurement !== undefined),
+          `measurements=${describe(results.map(r => r.measurement))}`,
+        )
+        record(
+          'non-admin-projection: enduserId should be present for non-admin projection',
+          results.length === 3 && results.every(r => r.enduserId !== undefined),
+          `enduserIds=${describe(results.map(r => r.enduserId))}`,
+        )
+      })
 
+      // The shared-org version deleted its observations and enduser here. Teardown discards the
+      // whole tenant, so the records go with it.
+    } catch (e: any) {
+      // 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: ${errorMessage(e)}`)
+    }
   } finally {
-    // Cleanup: Delete test resources
-    try {
-      for (const obsId of observationIds) {
-        await sdk.api.enduser_observations.deleteOne(obsId)
-      }
-      await sdk.api.endusers.deleteOne(testEnduser.id)
-    } catch (error) {
-      console.error('Cleanup error:', error)
-      // Try to at least delete the enduser (cascade deletes observations)
-      try {
-        await sdk.api.endusers.deleteOne(testEnduser.id)
-      } catch (deleteError) {
-        console.error('Failed to delete test enduser:', deleteError)
-      }
+    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
+    if (tenant) {
+      try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) }
     }
   }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs. */
+export const get_some_projection_tests = async () => {
+  assert_checks('getSome projection', await get_some_projection_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'getSome projection',
+  run: get_some_projection_checks,
 }
 
 // Allow running this test file independently
 if (require.main === module) {
   console.log(`🌐 Using API URL: ${host}`)
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
-
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await get_some_projection_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  get_some_projection_tests()
     .then(() => {
       console.log("✅ getSome projection test suite completed successfully")
       process.exit(0)