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

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

@@ -1,249 +1,336 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
 import {
-  async_test,
-  handleAnyError,
-  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 for bulk_assignment endpoint
-export const bulk_assignment_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Bulk Assignment Tests")
-
-  // Use a hardcoded custom type ID for testing (we'll use empty string for most tests)
-  const customTypeId = '507f1f77bcf86cd799439011' // Valid MongoDB ObjectId
-
-  // Create test users for care team assignments
-  const user1 = await sdk.api.users.createOne({
-    email: `test-user-1-${Date.now()}@test.com`,
-    fname: 'Test',
-    lname: 'User1',
-  })
-  const user2 = await sdk.api.users.createOne({
-    email: `test-user-2-${Date.now()}@test.com`,
-    fname: 'Test',
-    lname: 'User2',
-  })
-
-  // Create endusers with different customTypeId scenarios
-  const enduserWithCustomType = await sdk.api.endusers.createOne({
-    fname: 'Test',
-    lname: 'WithType',
-    customTypeId: customTypeId,
-    fields: { Building: ['Building A'] },
-  })
-
-  const enduserWithEmptyCustomType = await sdk.api.endusers.createOne({
-    fname: 'Test',
-    lname: 'EmptyType',
-    customTypeId: '',
-    fields: { Building: ['Building A'] },
-  })
-
-  const enduserWithoutCustomType = await sdk.api.endusers.createOne({
-    fname: 'Test',
-    lname: 'NoType',
-    // customTypeId not set (will be missing from document)
-    fields: { Building: ['Building B'] },
-  })
-
-  const enduserWithDifferentField = await sdk.api.endusers.createOne({
-    fname: 'Test',
-    lname: 'DifferentField',
-    customTypeId: '',
-    fields: { Building: ['Building C'] },
-  })
-
-  // Test 1: Add care team members with specific customTypeId
-  await async_test(
-    "bulk_assignment: Add care team with specific customTypeId",
-    () => sdk.api.endusers.bulk_assignment({
-      customTypeId: customTypeId,
-      addIds: [user1.id],
-    }),
-    {
-      onResult: r => (
-        r.updated.length === 1
-        && r.updated[0].id === enduserWithCustomType.id
-        && !!r.updated[0].assignedTo?.includes(user1.id)
-      )
-    }
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * endusers.bulk_assignment care-team coverage: adds and removes across customTypeId variants
+ * (a real id, the empty string, and the field missing entirely), the existingAssignment
+ * qualifiers, the custom-field filter, and the no-addIds-or-removeIds error case.
+ *
+ * Runs on its own provisioned tenant. bulk_assignment writes to EVERY enduser matching the filter
+ * in the business, so on the shared fixture org the "undefined customTypeId" and "empty string
+ * customTypeId" cases raced every other suite's patients: both of those checks assert an exact
+ * updated.length of 3, which only holds when no one else owns an untyped enduser in the org.
+ */
+export const bulk_assignment_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)
+  )
+  /** Only the three fields every predicate here reads. The raw response carries whole enduser
+   *  documents, several KB per check, which buries a real failure in a pooled run's output. */
+  const updatedSummary = (r: { updated: any[] }) => describe(
+    r.updated.map(e => ({ id: e.id, assignedTo: e.assignedTo, Building: e.fields?.Building }))
   )
 
-  // Test 2: Add care team members with undefined customTypeId (should match empty string AND missing)
-  await async_test(
-    "bulk_assignment: Add care team with undefined customTypeId (matches empty and missing)",
-    () => sdk.api.endusers.bulk_assignment({
-      customTypeId: undefined,
-      addIds: [user2.id],
-    }),
-    {
-      onResult: r => {
-        // Should update endusers with empty string customTypeId and missing customTypeId
-        // Should NOT update enduserWithCustomType (has actual customTypeId set)
-        const updatedIds = r.updated.map(e => e.id).sort()
-        const expectedIds = [enduserWithEmptyCustomType.id, enduserWithoutCustomType.id, enduserWithDifferentField.id].sort()
-
-        return (
-          r.updated.length === 3
-          && JSON.stringify(updatedIds) === JSON.stringify(expectedIds)
-          && r.updated.every(e => !!e.assignedTo?.includes(user2.id))
-        )
-      }
+  /**
+   * The async_test({ onResult }) equivalent, as a soft Check: a call that REJECTS is a failure
+   * (async_test treats it the same way), and a resolved call passes only when onResult agrees.
+   *
+   * The call and the predicate are caught separately, so a predicate that throws fails THIS check
+   * with its own detail instead of being misreported as an API rejection — and never escapes `run`,
+   * which would fail the whole run once the batch settles rather than failing one check.
+   */
+  const expect_result = async <T,>(
+    label: string,
+    fn: () => Promise<T>,
+    onResult: (r: T) => boolean,
+    /** Narrows the evidence line to the part under test. Without it the whole response document
+     *  lands in the summary, which makes a failing pooled run unreadable. Caught like the predicate,
+     *  so a formatter that throws cannot escape `run`. */
+    detailOf: (r: T) => string = describe,
+  ) => {
+    let resolved: { value: T }
+    try {
+      resolved = { value: await fn() }
+    } catch (e: any) {
+      record(label, false, `rejected instead of resolving: ${errorMessage(e)}`)
+      return
     }
-  )
 
-  // Test 3: Add care team members with empty string customTypeId
-  await async_test(
-    "bulk_assignment: Add care team with empty string customTypeId",
-    () => sdk.api.endusers.bulk_assignment({
-      customTypeId: '',
-      addIds: [user1.id],
-    }),
-    {
-      onResult: r => {
-        // Should update endusers with empty string customTypeId and missing customTypeId
-        const updatedIds = r.updated.map(e => e.id).sort()
-        const expectedIds = [enduserWithEmptyCustomType.id, enduserWithoutCustomType.id, enduserWithDifferentField.id].sort()
-
-        return (
-          r.updated.length === 3
-          && JSON.stringify(updatedIds) === JSON.stringify(expectedIds)
-          && r.updated.every(e => !!e.assignedTo?.includes(user1.id))
-        )
-      }
+    const { value } = resolved
+    const detail = (() => {
+      try { return detailOf(value) } catch { return describe(value) }
+    })()
+    try {
+      record(label, onResult(value), `result=${detail}`)
+    } catch (predicateError: any) {
+      record(label, false, `predicate threw on result=${detail}: ${errorMessage(predicateError)}`)
     }
-  )
+  }
 
-  // Test 4: Remove care team members with existingAssignment filter
-  await async_test(
-    "bulk_assignment: Remove care team with existingAssignment filter (All Of)",
-    () => sdk.api.endusers.bulk_assignment({
-      customTypeId: undefined,
-      existingAssignment: {
-        qualifier: 'All Of',
-        values: [user1.id, user2.id],
-      },
-      removeIds: [user2.id],
-    }),
-    {
-      onResult: r => (
-        r.updated.every(e =>
-          !e.assignedTo?.includes(user2.id) && // user2 removed
-          !!e.assignedTo?.includes(user1.id)   // user1 still present
-        )
-      )
+  /**
+   * The async_test(handleAnyError) equivalent: any rejection passes, resolving is the failure.
+   */
+  const expect_rejected = async (label: string, fn: () => Promise<any>) => {
+    try {
+      const unexpected = await fn()
+      record(label, false, `resolved instead of rejecting; result=${describe(unexpected)}`)
+    } catch (e: any) {
+      record(label, true, `rejected with ${errorMessage(e)}`)
     }
-  )
+  }
+
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
-  // Test 5: Add care team members with existingAssignment filter (One Of)
-  await async_test(
-    "bulk_assignment: Add with existingAssignment filter (One Of)",
-    () => sdk.api.endusers.bulk_assignment({
-      customTypeId: undefined,
-      existingAssignment: {
-        qualifier: 'One Of',
-        values: [user1.id],
-      },
-      addIds: [user2.id],
-    }),
-    {
-      onResult: r => (
-        r.updated.every(e =>
-          !!e.assignedTo?.includes(user1.id) &&
-          !!e.assignedTo?.includes(user2.id)
-        )
+  try {
+    tenant = await setup_isolated_tenant({
+      name: `Bulk assignment ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    try {
+      // Use a hardcoded custom type ID for testing (we'll use empty string for most tests)
+      const customTypeId = '507f1f77bcf86cd799439011' // Valid MongoDB ObjectId
+
+      // Create test users for care team assignments
+      const user1 = await sdk.api.users.createOne({
+        email: `test-user-1-${RAND()}@test.com`,
+        fname: 'Test',
+        lname: 'User1',
+      })
+      const user2 = await sdk.api.users.createOne({
+        email: `test-user-2-${RAND()}@test.com`,
+        fname: 'Test',
+        lname: 'User2',
+      })
+
+      // Create endusers with different customTypeId scenarios
+      const enduserWithCustomType = await sdk.api.endusers.createOne({
+        fname: 'Test',
+        lname: 'WithType',
+        customTypeId: customTypeId,
+        fields: { Building: ['Building A'] },
+      })
+
+      const enduserWithEmptyCustomType = await sdk.api.endusers.createOne({
+        fname: 'Test',
+        lname: 'EmptyType',
+        customTypeId: '',
+        fields: { Building: ['Building A'] },
+      })
+
+      const enduserWithoutCustomType = await sdk.api.endusers.createOne({
+        fname: 'Test',
+        lname: 'NoType',
+        // customTypeId not set (will be missing from document)
+        fields: { Building: ['Building B'] },
+      })
+
+      const enduserWithDifferentField = await sdk.api.endusers.createOne({
+        fname: 'Test',
+        lname: 'DifferentField',
+        customTypeId: '',
+        fields: { Building: ['Building C'] },
+      })
+
+      // Test 1: Add care team members with specific customTypeId
+      await expect_result(
+        "bulk_assignment: Add care team with specific customTypeId",
+        () => sdk.api.endusers.bulk_assignment({
+          customTypeId: customTypeId,
+          addIds: [user1.id],
+        }),
+        r => (
+          r.updated.length === 1
+          && r.updated[0].id === enduserWithCustomType.id
+          && !!r.updated[0].assignedTo?.includes(user1.id)
+        ),
+        updatedSummary,
       )
-    }
-  )
 
-  // Test 6: Add care team members with custom field filter (array field)
-  await async_test(
-    "bulk_assignment: Add with custom field filter (array value)",
-    () => sdk.api.endusers.bulk_assignment({
-      customTypeId: undefined,
-      field: 'Building',
-      existingFieldValue: 'Building A',
-      addIds: [sdk.userInfo.id], // Use admin user ID
-    }),
-    {
-      onResult: r => {
-        // Should match endusers where Building array contains 'Building A'
-        // Note: May return fewer than 2 if some already have this user assigned
-        const updatedIds = r.updated.map(e => e.id)
-        const hasCorrectEnduser = updatedIds.includes(enduserWithEmptyCustomType.id) || updatedIds.includes(enduserWithCustomType.id)
-
-        return (
-          r.updated.length >= 1
-          && hasCorrectEnduser
-          && r.updated.every(e => !!e.assignedTo?.includes(sdk.userInfo.id))
-          && r.updated.every(e => {
-            const building = e.fields?.Building
-            return Array.isArray(building) ? building.includes('Building A') : building === 'Building A'
-          })
-        )
-      }
-    }
-  )
+      // Test 2: Add care team members with undefined customTypeId (should match empty string AND missing)
+      await expect_result(
+        "bulk_assignment: Add care team with undefined customTypeId (matches empty and missing)",
+        () => sdk.api.endusers.bulk_assignment({
+          customTypeId: undefined,
+          addIds: [user2.id],
+        }),
+        r => {
+          // Should update endusers with empty string customTypeId and missing customTypeId
+          // Should NOT update enduserWithCustomType (has actual customTypeId set)
+          const updatedIds = r.updated.map(e => e.id).sort()
+          const expectedIds = [enduserWithEmptyCustomType.id, enduserWithoutCustomType.id, enduserWithDifferentField.id].sort()
 
-  // Test 7: Remove care team members with combined filters
-  await async_test(
-    "bulk_assignment: Remove with combined filters (customTypeId + field + existingAssignment)",
-    () => sdk.api.endusers.bulk_assignment({
-      customTypeId: '',
-      field: 'Building',
-      existingFieldValue: 'Building A',
-      existingAssignment: {
-        qualifier: 'All Of',
-        values: [user1.id],
-      },
-      removeIds: [user1.id],
-    }),
-    {
-      onResult: r => (
-        r.updated.length === 1
-        && r.updated[0].id === enduserWithEmptyCustomType.id
-        && !r.updated[0].assignedTo?.includes(user1.id)
+          return (
+            r.updated.length === 3
+            && JSON.stringify(updatedIds) === JSON.stringify(expectedIds)
+            && r.updated.every(e => !!e.assignedTo?.includes(user2.id))
+          )
+        },
+        updatedSummary,
       )
+
+      // Test 3: Add care team members with empty string customTypeId
+      await expect_result(
+        "bulk_assignment: Add care team with empty string customTypeId",
+        () => sdk.api.endusers.bulk_assignment({
+          customTypeId: '',
+          addIds: [user1.id],
+        }),
+        r => {
+          // Should update endusers with empty string customTypeId and missing customTypeId
+          const updatedIds = r.updated.map(e => e.id).sort()
+          const expectedIds = [enduserWithEmptyCustomType.id, enduserWithoutCustomType.id, enduserWithDifferentField.id].sort()
+
+          return (
+            r.updated.length === 3
+            && JSON.stringify(updatedIds) === JSON.stringify(expectedIds)
+            && r.updated.every(e => !!e.assignedTo?.includes(user1.id))
+          )
+        },
+        updatedSummary,
+      )
+
+      // Test 4: Remove care team members with existingAssignment filter
+      await expect_result(
+        "bulk_assignment: Remove care team with existingAssignment filter (All Of)",
+        () => sdk.api.endusers.bulk_assignment({
+          customTypeId: undefined,
+          existingAssignment: {
+            qualifier: 'All Of',
+            values: [user1.id, user2.id],
+          },
+          removeIds: [user2.id],
+        }),
+        r => (
+          r.updated.every(e =>
+            !e.assignedTo?.includes(user2.id) && // user2 removed
+            !!e.assignedTo?.includes(user1.id)   // user1 still present
+          )
+        ),
+        updatedSummary,
+      )
+
+      // Test 5: Add care team members with existingAssignment filter (One Of)
+      await expect_result(
+        "bulk_assignment: Add with existingAssignment filter (One Of)",
+        () => sdk.api.endusers.bulk_assignment({
+          customTypeId: undefined,
+          existingAssignment: {
+            qualifier: 'One Of',
+            values: [user1.id],
+          },
+          addIds: [user2.id],
+        }),
+        r => (
+          r.updated.every(e =>
+            !!e.assignedTo?.includes(user1.id) &&
+            !!e.assignedTo?.includes(user2.id)
+          )
+        ),
+        updatedSummary,
+      )
+
+      // Test 6: Add care team members with custom field filter (array field)
+      await expect_result(
+        "bulk_assignment: Add with custom field filter (array value)",
+        () => sdk.api.endusers.bulk_assignment({
+          customTypeId: undefined,
+          field: 'Building',
+          existingFieldValue: 'Building A',
+          addIds: [sdk.userInfo.id], // Use admin user ID
+        }),
+        r => {
+          // Should match endusers where Building array contains 'Building A'
+          // Note: May return fewer than 2 if some already have this user assigned
+          const updatedIds = r.updated.map(e => e.id)
+          const hasCorrectEnduser = updatedIds.includes(enduserWithEmptyCustomType.id) || updatedIds.includes(enduserWithCustomType.id)
+
+          return (
+            r.updated.length >= 1
+            && hasCorrectEnduser
+            && r.updated.every(e => !!e.assignedTo?.includes(sdk.userInfo.id))
+            && r.updated.every(e => {
+              const building = e.fields?.Building
+              return Array.isArray(building) ? building.includes('Building A') : building === 'Building A'
+            })
+          )
+        },
+        updatedSummary,
+      )
+
+      // Test 7: Remove care team members with combined filters
+      await expect_result(
+        "bulk_assignment: Remove with combined filters (customTypeId + field + existingAssignment)",
+        () => sdk.api.endusers.bulk_assignment({
+          customTypeId: '',
+          field: 'Building',
+          existingFieldValue: 'Building A',
+          existingAssignment: {
+            qualifier: 'All Of',
+            values: [user1.id],
+          },
+          removeIds: [user1.id],
+        }),
+        r => (
+          r.updated.length === 1
+          && r.updated[0].id === enduserWithEmptyCustomType.id
+          && !r.updated[0].assignedTo?.includes(user1.id)
+        ),
+        updatedSummary,
+      )
+
+      // Test 8: Error when neither addIds nor removeIds provided
+      await expect_rejected(
+        "bulk_assignment: Error when no addIds or removeIds",
+        () => sdk.api.endusers.bulk_assignment({
+          customTypeId: customTypeId,
+        }),
+      )
+
+      // The shared-org version deleted its endusers and users here. Teardown discards the whole
+      // tenant, so the records go with it.
+    } catch (e: any) {
+      // A bare fixture write (the ones outside a check) threw. Record it rather than letting it
+      // escape `run`, which would fail every other suite in the batch instead of just this one.
+      record('Bulk assignment suite ran to completion', false, `threw: ${errorMessage(e)}`)
     }
-  )
+  } finally {
+    // 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) }
+    }
+  }
 
-  // Test 8: Error when neither addIds nor removeIds provided
-  await async_test(
-    "bulk_assignment: Error when no addIds or removeIds",
-    () => sdk.api.endusers.bulk_assignment({
-      customTypeId: customTypeId,
-    }),
-    handleAnyError
-  )
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs. */
+export const bulk_assignment_tests = async () => {
+  assert_checks('Bulk assignment', await bulk_assignment_checks())
+}
 
-  // Cleanup
-  await Promise.all([
-    sdk.api.endusers.deleteOne(enduserWithCustomType.id),
-    sdk.api.endusers.deleteOne(enduserWithEmptyCustomType.id),
-    sdk.api.endusers.deleteOne(enduserWithoutCustomType.id),
-    sdk.api.endusers.deleteOne(enduserWithDifferentField.id),
-    sdk.api.users.deleteOne(user1.id),
-    sdk.api.users.deleteOne(user2.id),
-  ])
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Bulk assignment',
+  run: bulk_assignment_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 bulk_assignment_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  bulk_assignment_tests()
     .then(() => {
       console.log("✅ Bulk assignment test suite completed successfully")
       process.exit(0)