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

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

@@ -1,209 +1,319 @@
 require('source-map-support').install();
 
-import { Session } from "../../sdk"
 import {
-  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
 
-export const organization_settings_duplicates_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
-  log_header("Organization Settings Duplicate Validation Tests")
-
-  const orgId = sdk.userInfo.businessId
-
-  // === A. replaceObjectFields: false (merge/push behavior) ===
-
-  // A1. Duplicate tags via merge
-  await sdk.api.organizations.updateOne(orgId, {
-    settings: { endusers: { tags: ['tag1', 'tag2'] } }
-  }, { replaceObjectFields: true })
-
-  await async_test(
-    "Merge tags rejects duplicates (tag2 appears in both old and new)",
-    () => sdk.api.organizations.updateOne(orgId, {
-      settings: { endusers: { tags: ['tag2', 'tag3'] } }
-    }),
-    { shouldError: true, onError: (e: { message: string }) => e.message.includes('Duplicate value in settings.endusers.tags') }
-  )
-
-  // A2. Duplicate customFields via merge
-  await sdk.api.organizations.updateOne(orgId, {
-    settings: { endusers: { customFields: [{ type: 'Text' as const, field: 'myField', info: {} }] } }
-  }, { replaceObjectFields: true })
-
-  await async_test(
-    "Merge customFields rejects duplicate field name",
-    () => sdk.api.organizations.updateOne(orgId, {
-      settings: { endusers: { customFields: [{ type: 'Text' as const, field: 'myField', info: {} }] } }
-    }),
-    { shouldError: true, onError: (e: { message: string }) => e.message.includes('Duplicate field in settings.endusers.customFields') }
-  )
-
-  // A3. Duplicate builtinFields via merge
-  await sdk.api.organizations.updateOne(orgId, {
-    settings: { endusers: { builtinFields: [{ field: 'fname', label: 'First Name' }] } }
-  }, { replaceObjectFields: true })
-
-  await async_test(
-    "Merge builtinFields rejects duplicate field name",
-    () => sdk.api.organizations.updateOne(orgId, {
-      settings: { endusers: { builtinFields: [{ field: 'fname', label: 'First Name Copy' }] } }
-    }),
-    { shouldError: true, onError: (e: { message: string }) => e.message.includes('Duplicate field in settings.endusers.builtinFields') }
-  )
-
-  // A4. Duplicate dontRecordCallsToPhone via merge
-  await sdk.api.organizations.updateOne(orgId, {
-    settings: { endusers: { dontRecordCallsToPhone: ['+15551234567'] } }
-  }, { replaceObjectFields: true })
-
-  await async_test(
-    "Merge dontRecordCallsToPhone rejects duplicates",
-    () => sdk.api.organizations.updateOne(orgId, {
-      settings: { endusers: { dontRecordCallsToPhone: ['+15551234567'] } }
-    }),
-    { shouldError: true, onError: (e: { message: string }) => e.message.includes('Duplicate value in settings.endusers.dontRecordCallsToPhone') }
+const RAND = () => Math.random().toString(36).slice(2, 10)
+
+/**
+ * Duplicate-rejection coverage for organization settings: settings.endusers.tags / customFields /
+ * builtinFields / dontRecordCallsToPhone and settings.calendar.cancelReasons, under both the merge
+ * (replaceObjectFields omitted) and the replace (replaceObjectFields: true) write paths.
+ *
+ * Runs on its own provisioned tenant. It used to run on the shared fixture org, where it overwrote
+ * settings.endusers.tags / .customFields / .builtinFields nine times with replaceObjectFields and had
+ * no finally and no restore — so whatever it wrote last simply stayed on the fixture org. Custom-field
+ * and tag definitions are org-wide, so that mutated state other suites read, permanently.
+ *
+ * The tenant is thrown away at teardown, so no restore is needed: the explicit "clean up settings to
+ * avoid affecting other tests" write the shared-org version ended with is gone with it.
+ */
+export const organization_settings_duplicates_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 settings — the raw organization document is several KB per check, which buries a real
+   *  failure in a pooled run's output. */
+  const settingsOf = (org: any) => describe(org?.settings)
+
+  /**
+   * 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
+    }
 
-  // A5. Duplicate cancelReasons via merge
-  await sdk.api.organizations.updateOne(orgId, {
-    settings: { calendar: { cancelReasons: ['No show'] } }
-  }, { replaceObjectFields: true })
-
-  await async_test(
-    "Merge cancelReasons rejects duplicates",
-    () => sdk.api.organizations.updateOne(orgId, {
-      settings: { calendar: { cancelReasons: ['No show'] } }
-    }),
-    { shouldError: true, onError: (e: { message: string }) => e.message.includes('Duplicate value in settings.calendar.cancelReasons') }
-  )
+    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)}`)
+    }
+  }
 
-  // === B. replaceObjectFields: true (full replacement) ===
+  /**
+   * The async_test({ shouldError: true, onError }) equivalent: a call that RESOLVES is a failure,
+   * and a rejection passes only when onError agrees.
+   */
+  const expect_rejected = async (label: string, fn: () => Promise<any>, onError: (e: any) => boolean) => {
+    let rejection: { e: any }
+    try {
+      const unexpected = await fn()
+      record(label, false, `resolved instead of rejecting; result=${describe(unexpected)}`)
+      return
+    } catch (e: any) {
+      rejection = { e }
+    }
 
-  // B1. Replace that grows the array with dupes should be rejected
-  await sdk.api.organizations.updateOne(orgId, {
-    settings: { endusers: { tags: ['tag1'] } }
-  }, { replaceObjectFields: true })
+    // Evaluated after the error is captured, and caught in its own right: an uncaught throw from
+    // the predicate would escape `run` and, per run_isolated_in_parallel, fail the whole run once
+    // the batch settles instead of failing this one check.
+    const { e } = rejection
+    try {
+      record(label, onError(e), `rejected with ${errorMessage(e)}`)
+    } catch (predicateError: any) {
+      record(label, false, `predicate threw on rejection "${errorMessage(e)}": ${errorMessage(predicateError)}`)
+    }
+  }
 
-  await async_test(
-    "Replace tags rejects duplicates when array grows",
-    () => sdk.api.organizations.updateOne(orgId, {
-      settings: { endusers: { tags: ['tag1', 'tag1', 'tag2'] } }
-    }, { replaceObjectFields: true }),
-    { shouldError: true, onError: (e: { message: string }) => e.message.includes('Duplicate value in settings.endusers.tags') }
-  )
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
-  // B2. Replace with dupes that shrinks the array should be allowed
-  await sdk.api.organizations.updateOne(orgId, {
-    settings: { endusers: { tags: ['a', 'b', 'c'] } }
-  }, { replaceObjectFields: true })
-
-  await async_test(
-    "Replace with dupes that shrinks array succeeds",
-    () => sdk.api.organizations.updateOne(orgId, {
-      settings: { endusers: { tags: ['a', 'a'] } }
-    }, { replaceObjectFields: true }),
-    { shouldError: false, onResult: () => true }
-  )
+  try {
+    tenant = await setup_isolated_tenant({
+      name: `Org settings duplicates ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+    const orgId = tenant.businessId
 
-  // B3. Replace with unique values always succeeds
-  await async_test(
-    "Replace tags succeeds with unique values",
-    () => sdk.api.organizations.updateOne(orgId, {
-      settings: { endusers: { tags: ['tag1', 'tag2'] } }
-    }, { replaceObjectFields: true }),
-    { shouldError: false, onResult: () => true }
-  )
+    try {
+      // === A. replaceObjectFields: false (merge/push behavior) ===
 
-  // === C. Non-duplicate updates still succeed ===
+      // A1. Duplicate tags via merge
+      await sdk.api.organizations.updateOne(orgId, {
+        settings: { endusers: { tags: ['tag1', 'tag2'] } }
+      }, { replaceObjectFields: true })
+
+      await expect_rejected(
+        "Merge tags rejects duplicates (tag2 appears in both old and new)",
+        () => sdk.api.organizations.updateOne(orgId, {
+          settings: { endusers: { tags: ['tag2', 'tag3'] } }
+        }),
+        (e: { message: string }) => e.message.includes('Duplicate value in settings.endusers.tags'),
+      )
+
+      // A2. Duplicate customFields via merge
+      await sdk.api.organizations.updateOne(orgId, {
+        settings: { endusers: { customFields: [{ type: 'Text' as const, field: 'myField', info: {} }] } }
+      }, { replaceObjectFields: true })
+
+      await expect_rejected(
+        "Merge customFields rejects duplicate field name",
+        () => sdk.api.organizations.updateOne(orgId, {
+          settings: { endusers: { customFields: [{ type: 'Text' as const, field: 'myField', info: {} }] } }
+        }),
+        (e: { message: string }) => e.message.includes('Duplicate field in settings.endusers.customFields'),
+      )
+
+      // A3. Duplicate builtinFields via merge
+      await sdk.api.organizations.updateOne(orgId, {
+        settings: { endusers: { builtinFields: [{ field: 'fname', label: 'First Name' }] } }
+      }, { replaceObjectFields: true })
+
+      await expect_rejected(
+        "Merge builtinFields rejects duplicate field name",
+        () => sdk.api.organizations.updateOne(orgId, {
+          settings: { endusers: { builtinFields: [{ field: 'fname', label: 'First Name Copy' }] } }
+        }),
+        (e: { message: string }) => e.message.includes('Duplicate field in settings.endusers.builtinFields'),
+      )
+
+      // A4. Duplicate dontRecordCallsToPhone via merge
+      await sdk.api.organizations.updateOne(orgId, {
+        settings: { endusers: { dontRecordCallsToPhone: ['+15551234567'] } }
+      }, { replaceObjectFields: true })
+
+      await expect_rejected(
+        "Merge dontRecordCallsToPhone rejects duplicates",
+        () => sdk.api.organizations.updateOne(orgId, {
+          settings: { endusers: { dontRecordCallsToPhone: ['+15551234567'] } }
+        }),
+        (e: { message: string }) => e.message.includes('Duplicate value in settings.endusers.dontRecordCallsToPhone'),
+      )
+
+      // A5. Duplicate cancelReasons via merge
+      await sdk.api.organizations.updateOne(orgId, {
+        settings: { calendar: { cancelReasons: ['No show'] } }
+      }, { replaceObjectFields: true })
 
-  // C1. Set initial tags then add different tags via merge
-  await sdk.api.organizations.updateOne(orgId, {
-    settings: { endusers: { tags: ['tagA', 'tagB'] } }
-  }, { replaceObjectFields: true })
+      await expect_rejected(
+        "Merge cancelReasons rejects duplicates",
+        () => sdk.api.organizations.updateOne(orgId, {
+          settings: { calendar: { cancelReasons: ['No show'] } }
+        }),
+        (e: { message: string }) => e.message.includes('Duplicate value in settings.calendar.cancelReasons'),
+      )
 
-  await async_test(
-    "Merge with unique new tags succeeds",
-    () => sdk.api.organizations.updateOne(orgId, {
-      settings: { endusers: { tags: ['tagC', 'tagD'] } }
-    }),
-    { shouldError: false, onResult: () => true }
-  )
+      // === B. replaceObjectFields: true (full replacement) ===
 
-  // C2. Replace with unique values
-  await async_test(
-    "Replace customFields with unique values succeeds",
-    () => sdk.api.organizations.updateOne(orgId, {
-      settings: { endusers: { customFields: [
-        { type: 'Text' as const, field: 'field1', info: {} },
-        { type: 'Text' as const, field: 'field2', info: {} },
-      ] } }
-    }, { replaceObjectFields: true }),
-    { shouldError: false, onResult: () => true }
-  )
+      // B1. Replace that grows the array with dupes should be rejected
+      await sdk.api.organizations.updateOne(orgId, {
+        settings: { endusers: { tags: ['tag1'] } }
+      }, { replaceObjectFields: true })
+
+      await expect_rejected(
+        "Replace tags rejects duplicates when array grows",
+        () => sdk.api.organizations.updateOne(orgId, {
+          settings: { endusers: { tags: ['tag1', 'tag1', 'tag2'] } }
+        }, { replaceObjectFields: true }),
+        (e: { message: string }) => e.message.includes('Duplicate value in settings.endusers.tags'),
+      )
+
+      // B2. Replace with dupes that shrinks the array should be allowed
+      await sdk.api.organizations.updateOne(orgId, {
+        settings: { endusers: { tags: ['a', 'b', 'c'] } }
+      }, { replaceObjectFields: true })
+
+      await expect_result(
+        "Replace with dupes that shrinks array succeeds",
+        () => sdk.api.organizations.updateOne(orgId, {
+          settings: { endusers: { tags: ['a', 'a'] } }
+        }, { replaceObjectFields: true }),
+        () => true,
+        settingsOf,
+      )
+
+      // B3. Replace with unique values always succeeds
+      await expect_result(
+        "Replace tags succeeds with unique values",
+        () => sdk.api.organizations.updateOne(orgId, {
+          settings: { endusers: { tags: ['tag1', 'tag2'] } }
+        }, { replaceObjectFields: true }),
+        () => true,
+        settingsOf,
+      )
+
+      // === C. Non-duplicate updates still succeed ===
+
+      // C1. Set initial tags then add different tags via merge
+      await sdk.api.organizations.updateOne(orgId, {
+        settings: { endusers: { tags: ['tagA', 'tagB'] } }
+      }, { replaceObjectFields: true })
+
+      await expect_result(
+        "Merge with unique new tags succeeds",
+        () => sdk.api.organizations.updateOne(orgId, {
+          settings: { endusers: { tags: ['tagC', 'tagD'] } }
+        }),
+        () => true,
+        settingsOf,
+      )
+
+      // C2. Replace with unique values
+      await expect_result(
+        "Replace customFields with unique values succeeds",
+        () => sdk.api.organizations.updateOne(orgId, {
+          settings: { endusers: { customFields: [
+            { type: 'Text' as const, field: 'field1', info: {} },
+            { type: 'Text' as const, field: 'field2', info: {} },
+          ] } }
+        }, { replaceObjectFields: true }),
+        () => true,
+        settingsOf,
+      )
+
+      // C3. Updating another settings field preserves pre-existing duplicates
+      // First set tags to a longer array, then shrink to a dupe array (shrinking is allowed)
+      await sdk.api.organizations.updateOne(orgId, {
+        settings: { endusers: { tags: ['dupeTag', 'otherTag', 'anotherTag'] } }
+      }, { replaceObjectFields: true })
+      await sdk.api.organizations.updateOne(orgId, {
+        settings: { endusers: { tags: ['dupeTag', 'dupeTag'] } }
+      }, { replaceObjectFields: true })
+
+      await expect_result(
+        "Updating cancelReasons succeeds even when tags has pre-existing duplicates",
+        () => sdk.api.organizations.updateOne(orgId, {
+          settings: { calendar: { cancelReasons: ['new reason'] } }
+        }, { replaceObjectFields: true }),
+        () => true,
+        settingsOf,
+      )
+
+      // The shared-org version reset settings.endusers / settings.calendar here "to avoid affecting
+      // other tests". Nothing reads this org after teardown, so the reset is gone rather than kept.
+
+      // === D. subdomain is readonly ===
+      const orgBefore = await sdk.api.organizations.getOne(orgId)
+      await expect_result(
+        "subdomain field is readonly — update does not change persisted value",
+        async () => {
+          await sdk.api.organizations.updateOne(orgId, {
+            subdomain: `readonly-attempt-${Date.now()}`,
+          } as any).catch(() => undefined) // tolerate either silent-drop or unknown-field rejection
+          const orgAfter = await sdk.api.organizations.getOne(orgId)
+          return orgAfter.subdomain === orgBefore.subdomain
+        },
+        (unchanged: boolean) => unchanged === true,
+      )
+    } catch (e: any) {
+      // A bare setup 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('Organization settings duplicate 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) }
+    }
+  }
 
-  // C3. Updating another settings field preserves pre-existing duplicates
-  // First set tags to a longer array, then shrink to a dupe array (shrinking is allowed)
-  await sdk.api.organizations.updateOne(orgId, {
-    settings: { endusers: { tags: ['dupeTag', 'otherTag', 'anotherTag'] } }
-  }, { replaceObjectFields: true })
-  await sdk.api.organizations.updateOne(orgId, {
-    settings: { endusers: { tags: ['dupeTag', 'dupeTag'] } }
-  }, { replaceObjectFields: true })
-
-  await async_test(
-    "Updating cancelReasons succeeds even when tags has pre-existing duplicates",
-    () => sdk.api.organizations.updateOne(orgId, {
-      settings: { calendar: { cancelReasons: ['new reason'] } }
-    }, { replaceObjectFields: true }),
-    { shouldError: false, onResult: () => true }
-  )
+  return checks
+}
 
-  // Clean up settings to avoid affecting other tests
-  await sdk.api.organizations.updateOne(orgId, {
-    settings: {
-      endusers: {
-        tags: [],
-        customFields: [],
-        builtinFields: [],
-        dontRecordCallsToPhone: [],
-      },
-      calendar: {
-        cancelReasons: [],
-      },
-    }
-  }, { replaceObjectFields: true })
+/** Asserting wrapper, for standalone runs. */
+export const organization_settings_duplicates_tests = async () => {
+  assert_checks('Organization settings duplicates', await organization_settings_duplicates_checks())
+}
 
-  // === D. subdomain is readonly ===
-  const orgBefore = await sdk.api.organizations.getOne(orgId)
-  await async_test(
-    "subdomain field is readonly — update does not change persisted value",
-    async () => {
-      await sdk.api.organizations.updateOne(orgId, {
-        subdomain: `readonly-attempt-${Date.now()}`,
-      } as any).catch(() => undefined) // tolerate either silent-drop or unknown-field rejection
-      const orgAfter = await sdk.api.organizations.getOne(orgId)
-      return orgAfter.subdomain === orgBefore.subdomain
-    },
-    { onResult: (unchanged: boolean) => unchanged === true }
-  )
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Organization settings duplicates',
+  run: organization_settings_duplicates_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 organization_settings_duplicates_tests({ sdk, sdkNonAdmin })
-  }
-
-  runTests()
+  organization_settings_duplicates_tests()
     .then(() => {
       console.log("✅ Organization settings duplicate validation tests completed successfully")
       process.exit(0)