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

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

@@ -1,85 +1,156 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
-import { log_header, async_test } from "@tellescope/testing"
 import { FormResponse } from "@tellescope/types-client"
-import { setup_tests } from "../setup"
+import {
+  assert_checks,
+  Check,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
 
-const host = process.env.API_URL || "http://localhost:8080"
+const host = process.env.API_URL || 'http://localhost:8080' as const
 
-export const dont_sync_to_elation_form_submission_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Submit Form Response dontSyncToElation Tests")
+const RAND = () => Math.random().toString(36).slice(2, 10)
 
-  // Elation-note-configured form: without dontSyncToElation, submission would trigger a visit-note push
-  const form = await sdk.api.forms.createOne({
-    title: 'dontSyncToElation Test Form',
-    isNonVisitElationNote: true,
-  })
-  const field = await sdk.api.form_fields.createOne({
-    formId: form.id,
-    type: 'string',
-    title: 'Consent',
-    previousFields: [{ type: 'root', info: {} }],
-  })
+/** Branches on the RAW error value, never on JSON.stringify of it: JSON.stringify('') is '""',
+ *  which is truthy, so a `JSON.stringify(err) || fallback` chain makes the fallback unreachable and
+ *  prints an empty-string rejection as `error=""` instead of explaining it. */
+const error_detail = (err: any): string => {
+  if (err?.message) return String(err.message)
+  return err ? JSON.stringify(err) : `falsy error value (${String(err)})`
+}
+
+/**
+ * Coverage for the `dontSyncToElation` flag on `submit_form_response` — the opt-out consumed at
+ * `if (!dontSyncToElation)` in api/v1/api.ts, which is what gates the Elation visit-note /
+ * non-visit-note push for a form configured with `isNonVisitElationNote`.
+ *
+ * What these checks prove: a submission carrying the flag is ACCEPTED and RECORDED exactly like one
+ * without it — `submittedAt` is set and the answer is stored. They deliberately do NOT prove that
+ * the Elation push was skipped: this tenant has no Elation integration, so `push_non_visit_note`
+ * returns at its `if (!integration) { return }` guard either way, and an assertion that no Elation
+ * `references` entry was written would pass with the flag honoured or ignored. Making the push
+ * itself observable is out of scope here.
+ *
+ * Provisions its own throwaway tenant rather than using the shared `setup_tests` org, so it enrolls
+ * in the auto-discovered parallel pool. Never calls `sdk.reset_db()`.
+ */
 
-  const enduser = await sdk.api.endusers.createOne({ fname: 'dont-sync-elation' })
+export const dont_sync_to_elation_form_submission_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
 
-  const responses = [{
-    fieldId: field.id, fieldTitle: 'Consent',
-    answer: { type: 'string' as const, value: 'verbal consent recorded' },
-  }]
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
-    // ── Submission with dontSyncToElation: true is accepted and recorded ──
+    tenant = await setup_isolated_tenant({
+      name: `DontSyncToElation ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
+    // Elation-note-configured form: without dontSyncToElation, submission would attempt a
+    // non-visit-note push
+    const form = await sdk.api.forms.createOne({
+      title: `dontSyncToElation Test Form ${RAND()}`,
+      isNonVisitElationNote: true,
+    })
+    const field = await sdk.api.form_fields.createOne({
+      formId: form.id,
+      type: 'string',
+      title: 'Consent',
+      previousFields: [{ type: 'root', info: {} }],
+    })
+
+    const enduser = await sdk.api.endusers.createOne({ fname: 'dont-sync-elation' })
+
+    const responses = [{
+      fieldId: field.id, fieldTitle: 'Consent',
+      answer: { type: 'string' as const, value: 'verbal consent recorded' },
+    }]
+
+    /* ===== A: a submission with dontSyncToElation: true is accepted and recorded ===== */
+
+    // each submission needs its own access code — a submitted responder cannot re-submit
     const { accessCode: accessCodeSkip } = await sdk.api.form_responses.prepare_form_response({
       enduserId: enduser.id, formId: form.id,
     })
-    await async_test(
-      "submit_form_response accepts dontSyncToElation: true",
-      () => sdk.api.form_responses.submit_form_response({
+
+    let skipResponse: FormResponse | undefined
+    let skipError: any = undefined
+    // a boolean, not `skipError !== undefined`: a rejection whose value IS undefined must still
+    // read as a throw rather than being reported through the success branch
+    let skipThrew = false
+    try {
+      ;({ formResponse: skipResponse } = await sdk.api.form_responses.submit_form_response({
         accessCode: accessCodeSkip,
         responses,
         dontSyncToElation: true,
-      }),
-      { onResult: ({ formResponse }: { formResponse: FormResponse }) => (
-          !!formResponse.submittedAt
-        && formResponse.responses?.length === 1
-      )}
+      }))
+    } catch (err) { skipError = err; skipThrew = true }
+
+    record(
+      'A1: submit_form_response accepts dontSyncToElation: true and records the submission',
+      !!skipResponse?.submittedAt && skipResponse?.responses?.length === 1,
+      skipThrew
+        ? `submission threw: ${error_detail(skipError)}`
+        : `submittedAt=${JSON.stringify(skipResponse?.submittedAt)}`
+          + ` responses=${skipResponse?.responses?.length}`
+          + ` (want submittedAt set and exactly 1 response)`,
     )
 
-    // ── Regression: submission without the flag still succeeds ──
+    /* ===== B: regression — a submission without the flag still succeeds ===== */
+
     const { accessCode: accessCodeDefault } = await sdk.api.form_responses.prepare_form_response({
       enduserId: enduser.id, formId: form.id,
     })
-    await async_test(
-      "submit_form_response without dontSyncToElation still succeeds",
-      () => sdk.api.form_responses.submit_form_response({
+
+    let defaultResponse: FormResponse | undefined
+    let defaultError: any = undefined
+    // a boolean, not `defaultError !== undefined`: a rejection whose value IS undefined must still
+    // read as a throw rather than being reported through the success branch
+    let defaultThrew = false
+    try {
+      ;({ formResponse: defaultResponse } = await sdk.api.form_responses.submit_form_response({
         accessCode: accessCodeDefault,
         responses,
-      }),
-      { onResult: ({ formResponse }: { formResponse: FormResponse }) => (
-          !!formResponse.submittedAt
-        && formResponse.responses?.length === 1
-      )}
+      }))
+    } catch (err) { defaultError = err; defaultThrew = true }
+
+    record(
+      'B1: a submission without dontSyncToElation still succeeds and is recorded',
+      !!defaultResponse?.submittedAt && defaultResponse?.responses?.length === 1,
+      defaultThrew
+        ? `submission threw: ${error_detail(defaultError)}`
+        : `submittedAt=${JSON.stringify(defaultResponse?.submittedAt)}`
+          + ` responses=${defaultResponse?.responses?.length}`
+          + ` (want submittedAt set and exactly 1 response)`,
     )
+
   } finally {
-    try { await sdk.api.endusers.deleteOne(enduser.id) } catch (err) { /* ignore */ }
-    try { await sdk.api.forms.deleteOne(form.id) } catch (err) { /* ignore */ }
+    // 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 and for sequential use in the suite. */
+export const dont_sync_to_elation_form_submission_tests = async () => {
+  assert_checks('dontSyncToElation form submission', await dont_sync_to_elation_form_submission_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'dontSyncToElation form submission',
+  run: dont_sync_to_elation_form_submission_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 dont_sync_to_elation_form_submission_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  dont_sync_to_elation_form_submission_tests()
     .then(() => {
       console.log("✅ dontSyncToElation form submission tests completed successfully")
       process.exit(0)

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

@@ -1,59 +1,122 @@
 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,
+  setup_isolated_tenant,
+  IsolatedSuite,
+} from "../setup_isolated"
 
 const host = process.env.API_URL || 'http://localhost:8080' as const
 
-export const elation_user_id_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Elation User ID Tests")
-
-  const randomElationUserId = Math.floor(Math.random() * 1000000)
-
-  // Admin can set elationUserId
-  await async_test(
-    `admin can update elationUserId`,
-    () => sdk.api.users.updateOne(sdk.userInfo.id, { elationUserId: randomElationUserId }),
-    { shouldError: false, onResult: (u) => u.elationUserId === randomElationUserId }
-  )
-
-  // Verify the value persists on read
-  await async_test(
-    `elationUserId persists after update`,
-    () => sdk.api.users.getOne(sdk.userInfo.id),
-    { shouldError: false, onResult: (u) => u.elationUserId === randomElationUserId }
-  )
-
-  // Non-admin cannot update elationUserId
-  await async_test(
-    `non-admin cannot update elationUserId`,
-    () => sdkNonAdmin.api.users.updateOne(sdkNonAdmin.userInfo.id, { elationUserId: 999999 }),
-    handleAnyError
-  )
-}
+const RAND = () => Math.random().toString(36).slice(2, 10)
 
-// Allow running this test file independently
-if (require.main === module) {
-  const sdk = new Session({ host })
-  const sdkNonAdmin = new Session({ host })
+/** `elationUserId` is a `numberValidator` field, so the value under test stays an integer.
+ *  Never 0: the constraint below returns early on a falsy `updates.elationUserId` (the out-of-scope
+ *  bug noted in the suite comment), which would make check C flake green once in a million runs. */
+const RANDOM_ELATION_USER_ID = () => Math.floor(Math.random() * 1000000) + 1
+
+/** The exact text of the users relationship constraint in schema.ts. The non-admin check matches on
+ *  it rather than accepting any rejection: the provisioned `Non-Admin` role carries
+ *  PROVIDER_PERMISSIONS, whose `users.update` is 'Default' (self-update allowed), so a bare rejection
+ *  could come from the permission layer and the check would pass vacuously. */
+const ADMIN_ONLY_MESSAGE = 'Only admin users can update elationUserId'
+
+/**
+ * Coverage for `User.elationUserId` — the Elation EHR provider id — and the admin-only relationship
+ * constraint that guards writes to it.
+ *
+ * Provisions its own throwaway tenant: the checks mutate an admin user record, which on the shared
+ * fixture is the same admin every other suite authenticates as.
+ *
+ * Not covered here: the constraint returns early on `!updates?.elationUserId`, so a non-admin can
+ * still write `elationUserId: 0`. That is a product bug tracked separately, not a gap this test
+ * should paper over or assert the buggy behaviour of.
+ */
+export const elation_user_id_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
+
+  // async_test/handleAnyError call process.exit on failure, which would strand the tenant.
+  // Record the outcome instead, mirroring user_preferences.test.ts.
+  const expect_rejected_with = async (label: string, needle: string, write: () => Promise<any>) => {
+    try {
+      await write()
+      record(label, false, `write was accepted, but it should have been rejected with "${needle}"`)
+    } catch (err) {
+      const message = (err as any)?.message ?? String(err)
+      record(
+        label,
+        typeof message === 'string' && message.includes(needle),
+        `rejected with: ${message || '(no message on the rejection)'}`,
+      )
+    }
+  }
+
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
+
+  try {
+    // Default user spec: users[0] is an Admin, users[1] carries the 'Non-Admin' role. No API key
+    // is needed — every call here is made through an authenticated user session.
+    tenant = await setup_isolated_tenant({
+      name: `ElationUserId ${RAND()}`,
+      apiKeys: 0,
+    })
+    const { sdk, sdkNonAdmin } = tenant
 
-  const runTests = async () => {
-    await setup_tests(sdk, sdkNonAdmin)
-    await elation_user_id_tests({ sdk, sdkNonAdmin })
+    const elationUserId = RANDOM_ELATION_USER_ID()
+
+    // Writes to the admin's OWN record: targeting another user would be rejected by the
+    // "cannot update other users" path rather than by the constraint under test.
+    const updated = await sdk.api.users.updateOne(sdk.userInfo.id, { elationUserId })
+    record(
+      'A: an admin can set elationUserId on their own record',
+      updated?.elationUserId === elationUserId,
+      `expected ${elationUserId}, update returned elationUserId=${JSON.stringify(updated?.elationUserId)}`,
+    )
+
+    const reread = await sdk.api.users.getOne(sdk.userInfo.id)
+    record(
+      'B: the value persists on a later read',
+      reread?.elationUserId === elationUserId,
+      `expected ${elationUserId}, read back elationUserId=${JSON.stringify(reread?.elationUserId)}`,
+    )
+
+    // Again on the session's OWN record, so the permission layer's "cannot update other users" path
+    // is not what rejects this; the message match below is what proves the constraint fired.
+    await expect_rejected_with(
+      'C: a non-admin cannot set elationUserId, and is refused by the admin-only constraint',
+      ADMIN_ONLY_MESSAGE,
+      () => sdkNonAdmin.api.users.updateOne(sdkNonAdmin.userInfo.id, {
+        elationUserId: RANDOM_ELATION_USER_ID(),
+      }),
+    )
+  } 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) } }
   }
 
-  runTests()
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs. */
+export const elation_user_id_tests = async () => {
+  assert_checks('Elation user id', await elation_user_id_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = { name: 'Elation user id', run: elation_user_id_checks }
+
+// Allow running this test file independently
+if (require.main === module) {
+  console.log(`🌐 Using API URL: ${host}`)
+  elation_user_id_tests()
     .then(() => {
-      console.log("✅ Elation User ID test suite completed successfully")
+      console.log("✅ Elation user id test suite completed successfully")
       process.exit(0)
     })
     .catch((error) => {
-      console.error("❌ Elation User ID test suite failed:", error)
+      console.error("❌ Elation user id test suite failed:", error)
       process.exit(1)
     })
 }