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

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

@@ -1,130 +1,203 @@
 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 mdb_sort_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("mdbSort Custom Sorting Support")
-
-  // Create test endusers with known field values for sorting
-  const testEndusers = await Promise.all([
-    sdk.api.endusers.createOne({ fname: 'Alice', lname: 'Smith', email: 'alice-mdbsort@tellescope.com' }),
-    sdk.api.endusers.createOne({ fname: 'Bob', lname: 'Jones', email: 'bob-mdbsort@tellescope.com' }),
-    sdk.api.endusers.createOne({ fname: 'Charlie', lname: 'Adams', email: 'charlie-mdbsort@tellescope.com' }),
-    sdk.api.endusers.createOne({ fname: 'Alice', lname: 'Zeta', email: 'alice2-mdbsort@tellescope.com' }), // Same fname for multi-field test
-  ])
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+const ALICE_EMAIL   = 'alice-mdbsort@tellescope.com'
+const ALICE2_EMAIL  = 'alice2-mdbsort@tellescope.com'
+const BOB_EMAIL     = 'bob-mdbsort@tellescope.com'
+const CHARLIE_EMAIL = 'charlie-mdbsort@tellescope.com'
+
+/**
+ * getSome `mdbSort` coverage: ascending, descending, multi-field tie-breaking, combined with
+ * mdbFilter, keyset pagination through mdbFilter $or, combined with projection, for a non-admin
+ * session, and the fallback to sortBy when mdbSort is absent.
+ *
+ * Runs on its own provisioned tenant. The mdbFilter checks (tests 4 and 5) query by email with NO id
+ * scoping — `filter` is ignored when mdbFilter is present — so on the shared fixture org any leftover
+ * *-mdbsort@tellescope.com enduser from an earlier run silently changed the counts and the ordering.
+ * On a disposable tenant those four fixed addresses are unambiguous.
+ *
+ * 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 mdb_sort_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)
+  )
+  const names = (results: { fname?: string, lname?: string }[]) => (
+    describe(results.map(e => `${e.fname} ${e.lname}`))
+  )
+
+  /**
+   * 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)}`)
+    }
+  }
 
-  const enduserIds = testEndusers.map(e => e.id)
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
-    // Test 1: Sort by fname ascending (alphabetical order)
-    await async_test(
-      'mdbSort-fname-ascending',
-      async () => {
+    tenant = await setup_isolated_tenant({
+      name: `mdbSort ${RAND()}`,
+      users: [{ isAdmin: true }, { roles: ['Non-Admin'] }],
+      apiKeys: 0,
+    })
+    const { sdk, sdkNonAdmin } = tenant
+
+    try {
+      // Create test endusers with known field values for sorting.
+      //
+      // 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 these are created by the ADMIN — so on the shared fixture org
+      // the non-admin's query returned [] and the ordering assert inside `if (results.length >= 2)`
+      // never ran. Putting users[1] on the care team keeps every admin-side ordering, count and
+      // projection identical (assignedTo is in none of them) while letting the RBA check assert.
+      const careTeam = [tenant.users[1].id]
+      const testEndusers = await Promise.all([
+        sdk.api.endusers.createOne({ fname: 'Alice', lname: 'Smith', email: ALICE_EMAIL, assignedTo: careTeam }),
+        sdk.api.endusers.createOne({ fname: 'Bob', lname: 'Jones', email: BOB_EMAIL, assignedTo: careTeam }),
+        sdk.api.endusers.createOne({ fname: 'Charlie', lname: 'Adams', email: CHARLIE_EMAIL, assignedTo: careTeam }),
+        sdk.api.endusers.createOne({ fname: 'Alice', lname: 'Zeta', email: ALICE2_EMAIL, assignedTo: careTeam }), // Same fname for multi-field test
+      ])
+
+      const enduserIds = testEndusers.map(e => e.id)
+
+      // Test 1: Sort by fname ascending (alphabetical order)
+      await step('mdbSort-fname-ascending', async () => {
         const results = await sdk.api.endusers.getSome({
           filter: { id: { _in: enduserIds } },
           mdbSort: { fname: 1 },
         })
-        assert(results.length === 4, 'Expected 4 endusers', `Got ${results.length}`)
+        record(
+          'mdbSort-fname-ascending: Expected 4 endusers',
+          results.length === 4,
+          `Got ${results.length}`,
+        )
 
         // Verify alphabetical order: Alice, Alice, Bob, Charlie
-        assert(results[0].fname === 'Alice', 'First should be Alice')
-        assert(results[1].fname === 'Alice', 'Second should be Alice')
-        assert(results[2].fname === 'Bob', 'Third should be Bob')
-        assert(results[3].fname === 'Charlie', 'Fourth should be Charlie')
-
-        return results
-      },
-      { onResult: () => true },
-    )
-
-    // Test 2: Sort by fname descending (reverse alphabetical order)
-    await async_test(
-      'mdbSort-fname-descending',
-      async () => {
+        record('mdbSort-fname-ascending: First should be Alice', results[0]?.fname === 'Alice', names(results))
+        record('mdbSort-fname-ascending: Second should be Alice', results[1]?.fname === 'Alice', names(results))
+        record('mdbSort-fname-ascending: Third should be Bob', results[2]?.fname === 'Bob', names(results))
+        record('mdbSort-fname-ascending: Fourth should be Charlie', results[3]?.fname === 'Charlie', names(results))
+      })
+
+      // Test 2: Sort by fname descending (reverse alphabetical order)
+      await step('mdbSort-fname-descending', async () => {
         const results = await sdk.api.endusers.getSome({
           filter: { id: { _in: enduserIds } },
           mdbSort: { fname: -1 },
         })
-        assert(results.length === 4, 'Expected 4 endusers')
+        record(
+          'mdbSort-fname-descending: Expected 4 endusers',
+          results.length === 4,
+          `Got ${results.length}`,
+        )
 
         // Verify reverse alphabetical order: Charlie, Bob, Alice, Alice
-        assert(results[0].fname === 'Charlie', 'First should be Charlie')
-        assert(results[1].fname === 'Bob', 'Second should be Bob')
-        assert(results[2].fname === 'Alice', 'Third should be Alice')
-        assert(results[3].fname === 'Alice', 'Fourth should be Alice')
-
-        return results
-      },
-      { onResult: () => true },
-    )
-
-    // Test 3: Multi-field sort (fname ascending, then lname ascending for ties)
-    await async_test(
-      'mdbSort-multi-field',
-      async () => {
+        record('mdbSort-fname-descending: First should be Charlie', results[0]?.fname === 'Charlie', names(results))
+        record('mdbSort-fname-descending: Second should be Bob', results[1]?.fname === 'Bob', names(results))
+        record('mdbSort-fname-descending: Third should be Alice', results[2]?.fname === 'Alice', names(results))
+        record('mdbSort-fname-descending: Fourth should be Alice', results[3]?.fname === 'Alice', names(results))
+      })
+
+      // Test 3: Multi-field sort (fname ascending, then lname ascending for ties)
+      await step('mdbSort-multi-field', async () => {
         const results = await sdk.api.endusers.getSome({
           filter: { id: { _in: enduserIds } },
           mdbSort: { fname: 1, lname: 1 },
         })
-        assert(results.length === 4, 'Expected 4 endusers')
+        record(
+          'mdbSort-multi-field: Expected 4 endusers',
+          results.length === 4,
+          `Got ${results.length}`,
+        )
 
         // Verify multi-field sort:
         // Alice Smith (fname: Alice, lname: Smith)
         // Alice Zeta  (fname: Alice, lname: Zeta)
         // Bob Jones   (fname: Bob)
         // Charlie Adams (fname: Charlie)
-        assert(results[0].fname === 'Alice' && results[0].lname === 'Smith', 'First should be Alice Smith')
-        assert(results[1].fname === 'Alice' && results[1].lname === 'Zeta', 'Second should be Alice Zeta')
-        assert(results[2].fname === 'Bob', 'Third should be Bob')
-        assert(results[3].fname === 'Charlie', 'Fourth should be Charlie')
-
-        return results
-      },
-      { onResult: () => true },
-    )
-
-    // Test 4: mdbSort combined with mdbFilter
-    await async_test(
-      'mdbSort-with-mdbFilter',
-      async () => {
+        record(
+          'mdbSort-multi-field: First should be Alice Smith',
+          results[0]?.fname === 'Alice' && results[0]?.lname === 'Smith',
+          names(results),
+        )
+        record(
+          'mdbSort-multi-field: Second should be Alice Zeta',
+          results[1]?.fname === 'Alice' && results[1]?.lname === 'Zeta',
+          names(results),
+        )
+        record('mdbSort-multi-field: Third should be Bob', results[2]?.fname === 'Bob', names(results))
+        record('mdbSort-multi-field: Fourth should be Charlie', results[3]?.fname === 'Charlie', names(results))
+      })
+
+      // Test 4: mdbSort combined with mdbFilter
+      await step('mdbSort-with-mdbFilter', async () => {
         const results = await sdk.api.endusers.getSome({
           mdbFilter: {
-            email: { $in: ['alice-mdbsort@tellescope.com', 'alice2-mdbsort@tellescope.com'] },
+            email: { $in: [ALICE_EMAIL, ALICE2_EMAIL] },
             fname: 'Alice', // Only get Alice endusers
           },
           mdbSort: { lname: 1 }, // Sort by last name
         })
-        assert(results.length === 2, 'Expected 2 Alice endusers', `Got ${results.length}`)
+        record(
+          'mdbSort-with-mdbFilter: Expected 2 Alice endusers',
+          results.length === 2,
+          `Got ${results.length}`,
+        )
 
         // Verify both are Alice and sorted by lname: Smith, then Zeta
-        assert(results[0].fname === 'Alice' && results[0].lname === 'Smith', 'First Alice should be Smith')
-        assert(results[1].fname === 'Alice' && results[1].lname === 'Zeta', 'Second Alice should be Zeta')
-
-        return results
-      },
-      { onResult: () => true },
-    )
-
-    // Test 5: mdbSort keyset pagination via mdbFilter $or
-    // Note: filter is ignored when mdbFilter is present, so both id scoping and keyset cursor
-    // must be expressed in mdbFilter.
-    await async_test(
-      'mdbSort-keyset-pagination',
-      async () => {
+        record(
+          'mdbSort-with-mdbFilter: First Alice should be Smith',
+          results[0]?.fname === 'Alice' && results[0]?.lname === 'Smith',
+          names(results),
+        )
+        record(
+          'mdbSort-with-mdbFilter: Second Alice should be Zeta',
+          results[1]?.fname === 'Alice' && results[1]?.lname === 'Zeta',
+          names(results),
+        )
+      })
+
+      // Test 5: mdbSort keyset pagination via mdbFilter $or
+      // Note: filter is ignored when mdbFilter is present, so both id scoping and keyset cursor
+      // must be expressed in mdbFilter.
+      await step('mdbSort-keyset-pagination', async () => {
         const testEmails = [
-          'alice-mdbsort@tellescope.com',
-          'alice2-mdbsort@tellescope.com',
-          'bob-mdbsort@tellescope.com',
-          'charlie-mdbsort@tellescope.com',
+          ALICE_EMAIL,
+          ALICE2_EMAIL,
+          BOB_EMAIL,
+          CHARLIE_EMAIL,
         ]
 
         // Page 1: first 2 results sorted by fname ascending → both Alices
@@ -133,12 +206,12 @@ export const mdb_sort_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkN
           mdbSort: { fname: 1 },
           limit: 2,
         })
-        assert(page1.length === 2, 'Expected 2 endusers on page 1')
-        assert(page1[0].fname === 'Alice', 'Page 1 first should be Alice')
-        assert(page1[1].fname === 'Alice', 'Page 1 second should be Alice')
+        record('mdbSort-keyset-pagination: Expected 2 endusers on page 1', page1.length === 2, `Got ${page1.length}`)
+        record('mdbSort-keyset-pagination: Page 1 first should be Alice', page1[0]?.fname === 'Alice', names(page1))
+        record('mdbSort-keyset-pagination: Page 1 second should be Alice', page1[1]?.fname === 'Alice', names(page1))
 
         // Page 2: keyset cursor — fname > last seen fname ('Alice')
-        const lastFname = page1[page1.length - 1].fname
+        const lastFname = page1[page1.length - 1]?.fname
         const page2 = await sdk.api.endusers.getSome({
           mdbFilter: {
             email: { $in: testEmails },
@@ -147,107 +220,120 @@ export const mdb_sort_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkN
           mdbSort: { fname: 1 },
           limit: 2,
         })
-        assert(page2.length === 2, 'Expected 2 endusers on page 2')
-        assert(page2[0].fname === 'Bob', 'Page 2 first should be Bob')
-        assert(page2[1].fname === 'Charlie', 'Page 2 second should be Charlie')
-
-        return [...page1, ...page2]
-      },
-      { onResult: () => true },
-    )
-
-    // Test 6: mdbSort with projection (ensure both work together)
-    await async_test(
-      'mdbSort-with-projection',
-      async () => {
+        record(
+          'mdbSort-keyset-pagination: Expected 2 endusers on page 2',
+          page2.length === 2,
+          `Got ${page2.length} (cursor fname > ${describe(lastFname)})`,
+        )
+        record('mdbSort-keyset-pagination: Page 2 first should be Bob', page2[0]?.fname === 'Bob', names(page2))
+        record('mdbSort-keyset-pagination: Page 2 second should be Charlie', page2[1]?.fname === 'Charlie', names(page2))
+      })
+
+      // Test 6: mdbSort with projection (ensure both work together)
+      await step('mdbSort-with-projection', async () => {
         const results = await sdk.api.endusers.getSome({
           filter: { id: { _in: enduserIds } },
           mdbSort: { fname: -1 },
           projection: { fname: 1, lname: 1 },
         })
-        assert(results.length === 4, 'Expected 4 endusers')
+        record('mdbSort-with-projection: Expected 4 endusers', results.length === 4, `Got ${results.length}`)
 
         // Verify sort order (descending)
-        assert(results[0].fname === 'Charlie', 'First should be Charlie')
+        record('mdbSort-with-projection: First should be Charlie', results[0]?.fname === 'Charlie', names(results))
 
         // Verify projection (only fname, lname, plus id and createdAt)
-        assert(results[0].fname !== undefined, 'fname should be present')
-        assert(results[0].lname !== undefined, 'lname should be present')
-        assert((results[0] as any).email === undefined, 'email should NOT be present')
-
-        return results
-      },
-      { onResult: () => true },
-    )
-
-    // Test 7: Non-admin access with mdbSort (RBA still applies)
-    await async_test(
-      'non-admin-mdbSort',
-      async () => {
+        record(
+          'mdbSort-with-projection: fname should be present',
+          results[0]?.fname !== undefined,
+          `fname=${describe(results[0]?.fname)}`,
+        )
+        record(
+          'mdbSort-with-projection: lname should be present',
+          results[0]?.lname !== undefined,
+          `lname=${describe(results[0]?.lname)}`,
+        )
+        record(
+          'mdbSort-with-projection: email should NOT be present',
+          (results[0] as any)?.email === undefined,
+          `email=${describe((results[0] as any)?.email)}`,
+        )
+      })
+
+      // Test 7: Non-admin access with mdbSort (RBA still applies)
+      await step('non-admin-mdbSort', async () => {
         const results = await sdkNonAdmin.api.endusers.getSome({
           filter: { id: { _in: enduserIds } },
           mdbSort: { fname: 1 },
         })
 
         // Non-admin should still get results (RBA should apply)
-        assert(Array.isArray(results), 'Non-admin should receive an array response')
-
-        // Verify sort order
-        if (results.length >= 2) {
-          const fnames = results.map(e => e.fname)
-          // Should be sorted alphabetically
-          assert(fnames[0]! <= fnames[1]!, 'Non-admin results should be sorted')
-        }
-
-        return results
-      },
-      { onResult: () => true },
-    )
-
-    // Test 8: mdbSort fallback behavior (no mdbSort uses sortBy default)
-    await async_test(
-      'no-mdbSort-fallback',
-      async () => {
+        record(
+          'non-admin-mdbSort: Non-admin should receive an array response',
+          Array.isArray(results),
+          `results=${describe(results.map(e => e.id))}`,
+        )
+
+        // Verify sort order. The original guarded this with `if (results.length >= 2)` and recorded
+        // nothing below that, which is how it stayed silently inert; a too-short result set is now a
+        // failure rather than an absent check.
+        const fnames = results.map(e => e.fname)
+        record(
+          'non-admin-mdbSort: Non-admin results should be sorted',
+          results.length >= 2 && fnames[0]! <= fnames[1]!,
+          `fnames=${describe(fnames)}`,
+        )
+      })
+
+      // Test 8: mdbSort fallback behavior (no mdbSort uses sortBy default)
+      await step('no-mdbSort-fallback', async () => {
         // Without mdbSort, should fall back to default sorting by _id
         const results = await sdk.api.endusers.getSome({
           filter: { id: { _in: enduserIds } },
           sortBy: 'updatedAt',
           sort: 'oldFirst',
         })
-        assert(results.length === 4, 'Expected 4 endusers')
+        record('no-mdbSort-fallback: Expected 4 endusers', results.length === 4, `Got ${results.length}`)
 
         // Verify traditional sortBy still works when mdbSort not provided
-        assert(results[0].id !== undefined, 'Should return valid endusers')
-
-        return results
-      },
-      { onResult: () => true },
-    )
-
+        record(
+          'no-mdbSort-fallback: Should return valid endusers',
+          results[0]?.id !== undefined,
+          `ids=${describe(results.map(e => e.id))}`,
+        )
+      })
+
+      // The shared-org version deleted its endusers 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('mdbSort suite ran to completion', false, `threw: ${errorMessage(e)}`)
+    }
   } finally {
-    // Cleanup: Delete test resources
-    try {
-      for (const enduserId of enduserIds) {
-        await sdk.api.endusers.deleteOne(enduserId)
-      }
-    } catch (error) {
-      console.error('Cleanup error:', error)
+    // 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 mdb_sort_tests = async () => {
+  assert_checks('mdbSort', await mdb_sort_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'mdbSort',
+  run: mdb_sort_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 mdb_sort_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  mdb_sort_tests()
     .then(() => {
       console.log("✅ mdbSort test suite completed successfully")
       process.exit(0)