@tellescope/sdk 1.254.1 → 1.255.1

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

@@ -0,0 +1,207 @@
+require('source-map-support').install();
+
+import { Session } from "../../sdk"
+import {
+  assert,
+  async_test,
+  log_header,
+  wait,
+} from "@tellescope/testing"
+import { setup_tests } from "../setup"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+// fields that the admin org-wide list endpoint is allowed to return
+const ALLOWED_FIELDS = ['id', 'creator', 'businessId', 'updatedAt'].sort()
+
+export const organization_api_keys_tests = async (
+  { sdk, sdkNonAdmin }: { sdk: Session, sdkNonAdmin: Session }
+) => {
+  log_header("Organization API Keys (admin org-wide management)")
+
+  // We never mutate sdkNonAdmin's roles here (throwaway-user rule). Instead we create a
+  // dedicated throwaway user in the SAME org that DOES have api_keys access (via a custom
+  // role), so it can create its own key (the offboarded-employee scenario) and so the
+  // admin-gating negative tests below exercise the adminOnly gate (401) rather than the
+  // access-permission gate (403) — a non-admin without api_keys access is rejected with
+  // "Inaccessible" before adminOnly is ever reached.
+  const adminKeyIds: string[] = []
+  let otherKeyId: string | undefined
+  let otherUserId: string | undefined
+  let apiKeysRoleId: string | undefined
+
+  try {
+    // A custom role that grants api_keys access (merged over PROVIDER_PERMISSIONS server-side)
+    const apiKeysRole = await sdk.api.role_based_access_permissions.createOne({
+      role: 'api-keys-test-role',
+      permissions: { api_keys: { create: 'All', read: 'All', update: 'All', delete: 'All' } },
+    })
+    apiKeysRoleId = apiKeysRole.id
+
+    // A throwaway non-admin user in the same org, holding that role
+    const otherUser = (
+      await sdk.api.users.getOne({ email: 'api.keys.other.user@tellescope.com' }).catch(() => null)
+    ) || (
+      await sdk.api.users.createOne({ email: 'api.keys.other.user@tellescope.com', notificationEmailsDisabled: true, verifiedEmail: true })
+    )
+    otherUserId = otherUser.id
+    await sdk.api.users.updateOne(otherUser.id, { roles: [apiKeysRole.role] }, { replaceObjectFields: true })
+    await wait(undefined, 2000) // wait for the role change to propagate before authenticating
+
+    const otherSdk = new Session({
+      host,
+      authToken: (await sdk.api.users.generate_auth_token({ id: otherUser.id })).authToken,
+    })
+
+    // A key created by the admin...
+    const adminKey = await sdk.api.api_keys.createOne({})
+    adminKeyIds.push(adminKey.id)
+
+    // ...and a key created by ANOTHER user in the org (the offboarded-employee scenario)
+    const otherKey = await otherSdk.api.api_keys.createOne({})
+    otherKeyId = otherKey.id
+
+    // =============================================
+    // CORE: admin sees keys created by other users
+    // =============================================
+    const { apiKeys } = await sdk.api.api_keys.get_organization_api_keys()
+
+    assert(
+      apiKeys.some(k => k.id === otherKeyId),
+      `admin list did not include another user's key ${otherKeyId}`,
+      "admin get_organization_api_keys returns keys created by other users in the org"
+    )
+    assert(
+      apiKeys.some(k => k.id === adminKey.id),
+      "admin list did not include the admin's own key",
+      "admin get_organization_api_keys returns the admin's own keys"
+    )
+    assert(
+      !!apiKeys.find(k => k.id === otherKeyId && k.creator === otherUser.id),
+      "creator on the other user's key did not match",
+      "returned key reports the correct creator"
+    )
+
+    // =============================================
+    // SECRET REDACTION (server-side, allowlist)
+    // =============================================
+    assert(
+      apiKeys.every(k => (k as any).key === undefined),
+      "a returned record exposed a plaintext `key`",
+      "no returned record exposes a plaintext key (legacy field)"
+    )
+    assert(
+      apiKeys.every(k => (k as any).hashedKey === undefined),
+      "a returned record exposed `hashedKey`",
+      "no returned record exposes hashedKey"
+    )
+    // Strict allowlist: every returned field must be in the allowlist (no extra/sensitive field
+    // ever leaks). We can't require all allowlisted fields to be PRESENT — never-updated keys
+    // have no `updatedAt`, and res.json() drops undefined values — so this is a subset check.
+    const offending = apiKeys
+      .map(k => Object.keys(k).filter(key => !ALLOWED_FIELDS.includes(key)))
+      .find(extra => extra.length > 0)
+    assert(
+      offending === undefined,
+      `a returned record exposed non-allowlisted fields: ${JSON.stringify(offending)}`,
+      "returned records contain only allowlisted fields (subset of id, creator, businessId, updatedAt)"
+    )
+
+    // =============================================
+    // CROSS-ORG ISOLATION (no leakage across businesses)
+    // =============================================
+    assert(
+      apiKeys.every(k => k.businessId === sdk.userInfo.businessId),
+      "a returned key belonged to a different business",
+      "all returned keys are scoped to the admin's businessId"
+    )
+
+    // =============================================
+    // ADMIN GATING (negative tests)
+    // =============================================
+    await async_test(
+      "non-admin get_organization_api_keys is rejected (401)",
+      () => otherSdk.api.api_keys.get_organization_api_keys(),
+      { shouldError: true, onError: (e: any) => e.statusCode === 401 || /admin access only/i.test(e.message || '') }
+    )
+    await async_test(
+      "non-admin delete_organization_api_key is rejected (401)",
+      () => otherSdk.api.api_keys.delete_organization_api_key({ id: adminKey.id }),
+      { shouldError: true, onError: (e: any) => e.statusCode === 401 || /admin access only/i.test(e.message || '') }
+    )
+
+    // confirm the gating did not delete the key
+    const afterGating = await sdk.api.api_keys.get_organization_api_keys()
+    assert(
+      afterGating.apiKeys.some(k => k.id === adminKey.id),
+      "rejected non-admin delete still removed the key",
+      "rejected non-admin delete left the key intact"
+    )
+
+    // =============================================
+    // ADMIN DELETE another user's key
+    // =============================================
+    await async_test(
+      "admin delete_organization_api_key deletes another user's key",
+      () => sdk.api.api_keys.delete_organization_api_key({ id: otherKeyId! }),
+      { shouldError: false, onResult: () => true }
+    )
+
+    const afterDelete = await sdk.api.api_keys.get_organization_api_keys()
+    assert(
+      !afterDelete.apiKeys.some(k => k.id === otherKeyId),
+      "deleted key still present in org-wide list",
+      "deleted key no longer appears in the org-wide list"
+    )
+    otherKeyId = undefined // successfully deleted; nothing to clean up
+
+    // deleting a key in a different org (fabricated id) must be a no-op for our org
+    await async_test(
+      "admin delete of a non-existent/cross-org key id is a safe no-op",
+      () => sdk.api.api_keys.delete_organization_api_key({ id: '000000000000000000000000' }),
+      { shouldError: false, onResult: () => true }
+    )
+    const afterNoop = await sdk.api.api_keys.get_organization_api_keys()
+    assert(
+      afterNoop.apiKeys.some(k => k.id === adminKey.id),
+      "no-op delete removed an unrelated key",
+      "no-op cross-org delete left our org's keys intact"
+    )
+  } finally {
+    // cleanup: remove any keys we created (creator-only default delete)
+    for (const id of adminKeyIds) {
+      await sdk.api.api_keys.deleteOne(id).catch(() => {})
+    }
+    // the admin can clean up the throwaway user's key org-wide; fall through is harmless
+    if (otherKeyId) {
+      await sdk.api.api_keys.delete_organization_api_key({ id: otherKeyId }).catch(() => {})
+    }
+    if (otherUserId) {
+      await sdk.api.users.deleteOne(otherUserId).catch(() => {})
+    }
+    if (apiKeysRoleId) {
+      await sdk.api.role_based_access_permissions.deleteOne(apiKeysRoleId).catch(() => {})
+    }
+  }
+}
+
+// Allow running this test file independently
+if (require.main === module) {
+  const sdk = new Session({ host })
+  const sdkNonAdmin = new Session({ host })
+
+  const runTests = async () => {
+    await setup_tests(sdk, sdkNonAdmin)
+    await organization_api_keys_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ Organization API keys test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Organization API keys test suite failed:", error)
+      process.exit(1)
+    })
+}

package/src/tests/tests.ts

@@ -48,6 +48,8 @@ import { concurrent_build_threads_tests } from "./api_tests/concurrent_build_thr
 import { appointment_completed_trigger_tests } from "./api_tests/appointment_completed_trigger.test"
 import { purchase_made_trigger_tests } from "./api_tests/purchase_made_trigger.test"
 import { appointment_rescheduled_trigger_tests } from "./api_tests/appointment_rescheduled_trigger.test"
+import { appointment_no_showed_trigger_tests } from "./api_tests/appointment_no_showed_trigger.test"
+import { group_event_attendee_status_triggers_tests } from "./api_tests/group_event_attendee_status_triggers.test"
 import { journey_error_branching_tests } from "./api_tests/journey_error_branching.test"
 import { afteraction_day_of_month_delay_tests } from "./api_tests/afteraction_day_of_month_delay.test"
 import { push_forms_to_portal_group_completion_tests } from "./api_tests/push_forms_to_portal_group_completion.test"
@@ -80,6 +82,7 @@ import { enduser_login_tests } from "./api_tests/enduser_login.test";
 import { enduser_login_rate_limits_tests } from "./api_tests/enduser_login_rate_limits.test";
 import { eom_procedure_codes_tests } from "./api_tests/eom_procedure_codes.test";
 import { cross_org_api_key_tests } from "./api_tests/cross_org_api_key.test";
+import { organization_api_keys_tests } from "./api_tests/organization_api_keys.test";
 import { custom_dashboards_tests } from "./api_tests/custom_dashboards.test";
 import { message_assignment_trigger_tests } from "./api_tests/message_assignment_trigger.test";
 import { outbound_chat_sent_trigger_tests } from "./api_tests/outbound_chat_sent_trigger.test";
@@ -3493,6 +3496,39 @@ const order_status_equals_tests = async () => {
     title: "Protocol Condition"
   })
 
+  // Frequency filter triggers (exact-match array filter, mirrors fills/skus). All use a dedicated
+  // source/status so their assertions stay isolated from the t1-t9 incremental tag-count checks above.
+  const tf1 = await sdk.api.automation_triggers.createOne({
+    event: { type: 'Order Status Equals', info: { source: 'FreqSource', status: "FreqStatus" } }, // no frequencies -> fires for all
+    action: { type: 'Add Tags', info: { tags: ['Freq No Filter'] }},
+    status: 'Active',
+    title: "Frequency - no filter (backward compat)"
+  })
+  const tf2 = await sdk.api.automation_triggers.createOne({
+    event: { type: 'Order Status Equals', info: { source: 'FreqSource', status: "FreqStatus", frequencies: ['4', '12'] } },
+    action: { type: 'Add Tags', info: { tags: ['Freq Match'] }},
+    status: 'Active',
+    title: "Frequency - multi-value match"
+  })
+  const tf3 = await sdk.api.automation_triggers.createOne({
+    event: { type: 'Order Status Equals', info: { source: 'FreqSource', status: "FreqStatus", frequencies: [] } }, // empty array -> fires for all
+    action: { type: 'Add Tags', info: { tags: ['Freq Empty All'] }},
+    status: 'Active',
+    title: "Frequency - empty array means all"
+  })
+  const tf4 = await sdk.api.automation_triggers.createOne({
+    event: { type: 'Order Status Equals', info: { source: 'FreqSource', status: "FreqShipped", frequencies: ['4'] } },
+    action: { type: 'Add Tags', info: { tags: ['Freq Status Combo'] }},
+    status: 'Active',
+    title: "Frequency + status combination (AND semantics)"
+  })
+  const tf5 = await sdk.api.automation_triggers.createOne({
+    event: { type: 'Order Status Equals', info: { source: 'FreqSource', status: "FreqStatus", frequencies: ['12'] } },
+    action: { type: 'Add Tags', info: { tags: ['Freq Match 12'] }},
+    status: 'Active',
+    title: "Frequency - second listed value"
+  })
+
   const e = await sdk.api.endusers.createOne({})
 
   await sdk.api.enduser_orders.createOne({ status: 'Nooo', source: 'Source', title: 'nomatch', externalId: '1', enduserId: e.id })
@@ -3705,6 +3741,85 @@ const order_status_equals_tests = async () => {
     ) }
   )
 
+  // --- Frequency filter coverage (fresh enduser keeps tag-count assertions isolated) ---
+  const ef = await sdk.api.endusers.createOne({})
+
+  // Order with NO frequency: no-filter trigger (tf1) and empty-array trigger (tf3) both fire;
+  // populated-filter trigger (tf2) does NOT (missing frequency must never match a populated filter).
+  await sdk.api.enduser_orders.createOne({ status: 'FreqStatus', source: 'FreqSource', externalId: 'f1', enduserId: ef.id, title: "Freq No Frequency" })
+  await wait(undefined, 500) // allow triggers to happen
+  await async_test(
+    "Frequency: no-filter + empty-array fire for order with no frequency (backward compat)",
+    () => sdk.api.endusers.getOne(ef.id),
+    { onResult: e => !!(
+       e.tags?.length === 2
+    && e.tags?.includes('Freq No Filter')
+    && e.tags?.includes('Freq Empty All')
+    && !e.tags?.includes('Freq Match')
+    ) }
+  )
+
+  // Order with a frequency NOT in ['4','12'] -> populated-filter trigger still does not fire.
+  await sdk.api.enduser_orders.createOne({ status: 'FreqStatus', source: 'FreqSource', externalId: 'f2', enduserId: ef.id, title: "Freq 8", frequency: '8' })
+  await wait(undefined, 500) // allow triggers to happen
+  await async_test(
+    "Frequency: no match (order frequency '8' not in ['4','12'])",
+    () => sdk.api.endusers.getOne(ef.id),
+    { onResult: e => !!(
+       e.tags?.length === 2
+    && !e.tags?.includes('Freq Match')
+    ) }
+  )
+
+  // Order with frequency '4' -> ['4','12'] trigger fires.
+  await sdk.api.enduser_orders.createOne({ status: 'FreqStatus', source: 'FreqSource', externalId: 'f3', enduserId: ef.id, title: "Freq 4", frequency: '4' })
+  await wait(undefined, 500) // allow triggers to happen
+  await async_test(
+    "Frequency: match (order frequency '4' is in ['4','12'])",
+    () => sdk.api.endusers.getOne(ef.id),
+    { onResult: e => !!(
+       e.tags?.length === 3
+    && e.tags?.includes('Freq Match')
+    && !e.tags?.includes('Freq Match 12')
+    ) }
+  )
+
+  // Order with frequency '12' -> the second listed value also matches (tf5 frequencies: ['12']).
+  await sdk.api.enduser_orders.createOne({ status: 'FreqStatus', source: 'FreqSource', externalId: 'f4', enduserId: ef.id, title: "Freq 12", frequency: '12' })
+  await wait(undefined, 500) // allow triggers to happen
+  await async_test(
+    "Frequency: second listed value '12' also matches",
+    () => sdk.api.endusers.getOne(ef.id),
+    { onResult: e => !!(
+       e.tags?.length === 4
+    && e.tags?.includes('Freq Match 12')
+    ) }
+  )
+
+  // AND semantics: frequency + status must BOTH match. Right frequency, wrong status -> no fire.
+  await sdk.api.enduser_orders.createOne({ status: 'FreqShipped', source: 'FreqSource', externalId: 'f5', enduserId: ef.id, title: "Freq Combo Wrong Freq", frequency: '8' })
+  await wait(undefined, 500) // allow triggers to happen
+  await async_test(
+    "Frequency + status combo: status matches but frequency does not -> no fire",
+    () => sdk.api.endusers.getOne(ef.id),
+    { onResult: e => !!(
+       e.tags?.length === 4
+    && !e.tags?.includes('Freq Status Combo')
+    ) }
+  )
+
+  // AND semantics: right status AND right frequency -> fires.
+  await sdk.api.enduser_orders.createOne({ status: 'FreqShipped', source: 'FreqSource', externalId: 'f6', enduserId: ef.id, title: "Freq Combo Match", frequency: '4' })
+  await wait(undefined, 500) // allow triggers to happen
+  await async_test(
+    "Frequency + status combo: both match -> fires (AND semantics)",
+    () => sdk.api.endusers.getOne(ef.id),
+    { onResult: e => !!(
+       e.tags?.length === 5
+    && e.tags?.includes('Freq Status Combo')
+    ) }
+  )
+
   await Promise.all([
     sdk.api.automation_triggers.deleteOne(t1.id),
     sdk.api.automation_triggers.deleteOne(t2.id),
@@ -3715,7 +3830,13 @@ const order_status_equals_tests = async () => {
     sdk.api.automation_triggers.deleteOne(t7.id),
     sdk.api.automation_triggers.deleteOne(t8.id),
     sdk.api.automation_triggers.deleteOne(t9.id),
+    sdk.api.automation_triggers.deleteOne(tf1.id),
+    sdk.api.automation_triggers.deleteOne(tf2.id),
+    sdk.api.automation_triggers.deleteOne(tf3.id),
+    sdk.api.automation_triggers.deleteOne(tf4.id),
+    sdk.api.automation_triggers.deleteOne(tf5.id),
     sdk.api.endusers.deleteOne(e.id),
+    sdk.api.endusers.deleteOne(ef.id),
   ])
 }
 
@@ -5592,6 +5713,8 @@ const trigger_events_api_tests = async () => {
 const automation_trigger_tests = async () => {
   log_header("Automation Trigger Tests")
 
+  await appointment_no_showed_trigger_tests({ sdk, sdkNonAdmin })
+  await group_event_attendee_status_triggers_tests({ sdk, sdkNonAdmin })
   await assign_care_team_tests()
   await push_forms_to_portal_group_completion_tests({ sdk, sdkNonAdmin })
   await order_status_equals_tests()
@@ -6717,11 +6840,25 @@ export const self_serve_appointment_booking_tests = async () => {
     confirmationEmailDisabled: true,
     confirmationSMSDisabled: true,
   })
-  const event30minGroup = await sdk.api.calendar_event_templates.createOne({ 
+  const event30minGroup = await sdk.api.calendar_event_templates.createOne({
     title: 'test group', durationInMinutes: 30,
     confirmationEmailDisabled: true,
     confirmationSMSDisabled: true,
-    enduserAttendeeLimit: 2, 
+    enduserAttendeeLimit: 2,
+  })
+  const event30minTwilio = await sdk.api.calendar_event_templates.createOne({
+    title: 'test twilio', durationInMinutes: 30,
+    confirmationEmailDisabled: true,
+    confirmationSMSDisabled: true,
+    enableVideoCall: true,
+    videoIntegration: 'Twilio',
+  })
+  const event30minZoom = await sdk.api.calendar_event_templates.createOne({
+    title: 'test zoom', durationInMinutes: 30,
+    confirmationEmailDisabled: true,
+    confirmationSMSDisabled: true,
+    enableVideoCall: true,
+    videoIntegration: 'Zoom',
   })
 
   // ensure it doesn't match current day, to avoid errors on testing
@@ -7281,17 +7418,70 @@ export const self_serve_appointment_booking_tests = async () => {
     { onResult: event => !!event.rescheduledAt }
   )
 
+  // videoIntegration passthrough from template to booked event (Twilio fix + Zoom regression guard)
+  // set up fresh, dedicated availability so this doesn't interfere with the slot-accounting tests above
+  await sdk.api.users.updateOne(sdk.userInfo.id, {
+    weeklyAvailabilities: [
+      {
+        dayOfWeekStartingSundayIndexedByZero,
+        startTimeInMinutes: 60 * 9, // 9am,
+        endTimeInMinutes: 60 * 11, // 11am,
+      },
+    ],
+    timezone: 'America/New_York',
+  }, {
+    replaceObjectFields: true,
+  })
+
+  const twilioSlots = await enduserSDK.api.calendar_events.get_appointment_availability({
+    calendarEventTemplateId: event30minTwilio.id,
+    from: new Date(Date.now() - 10000),
+    to: new Date(Date.now() + 3 * 24 * 60 * 60 * 1000),
+    userIds: [sdk.userInfo.id],
+  })
+  const bookedTwilioAppointment = (await enduserSDK.api.calendar_events.book_appointment({
+    calendarEventTemplateId: event30minTwilio.id,
+    startTime: new Date(twilioSlots.availabilityBlocks[0].startTimeInMS),
+    userId: sdk.userInfo.id,
+  })).createdEvent
+  assert(
+    bookedTwilioAppointment.videoIntegration === 'Twilio',
+    'Twilio videoIntegration not propagated to booked event',
+    'Twilio videoIntegration propagated to booked event'
+  )
+
+  const zoomSlots = await enduserSDK.api.calendar_events.get_appointment_availability({
+    calendarEventTemplateId: event30minZoom.id,
+    from: new Date(Date.now() - 10000),
+    to: new Date(Date.now() + 3 * 24 * 60 * 60 * 1000),
+    userIds: [sdk.userInfo.id],
+  })
+  const bookedZoomAppointment = (await enduserSDK.api.calendar_events.book_appointment({
+    calendarEventTemplateId: event30minZoom.id,
+    startTime: new Date(zoomSlots.availabilityBlocks[0].startTimeInMS),
+    userId: sdk.userInfo.id,
+  })).createdEvent
+  assert(
+    bookedZoomAppointment.videoIntegration === 'Zoom',
+    'Zoom videoIntegration not propagated to booked event',
+    'Zoom videoIntegration propagated to booked event'
+  )
+
   await Promise.all([
     sdk.api.endusers.deleteOne(e1.id),
     sdk.api.endusers.deleteOne(e2.id),
     sdk.api.endusers.deleteOne(e3.id),
     sdk.api.calendar_event_templates.deleteOne(event30min.id),
     sdk.api.calendar_event_templates.deleteOne(event30minGroup.id),
+    sdk.api.calendar_event_templates.deleteOne(event30minTwilio.id),
+    sdk.api.calendar_event_templates.deleteOne(event30minZoom.id),
     sdk.api.calendar_event_templates.deleteOne(event15min.id),
     sdk.api.calendar_event_templates.deleteOne(templatePreserveHosts.id),
     sdk.api.calendar_event_templates.deleteOne(templateReplaceHosts.id),
     sdk.api.calendar_events.deleteOne(bookedAppointment.id),
     sdk.api.calendar_events.deleteOne(bookedMultiAppointment.id),
+    sdk.api.calendar_events.deleteOne(bookedTwilioAppointment.id),
+    sdk.api.calendar_events.deleteOne(bookedZoomAppointment.id),
     sdk.api.calendar_events.deleteOne(groupEvent.id),
     sdk.api.calendar_events.deleteOne(originalMultiHostAppt.id),
     sdk.api.calendar_events.deleteOne(rescheduledPreserveHosts.id),
@@ -11237,6 +11427,7 @@ const lockout_tests = async () => {
     () => sdk.api.users.updateOne(nonAdminId, { lockedOutUntil: -1 }),
     passOnAnyResult
   )
+  await wait(undefined, 1500) // ensure new token's iat second clears the stale deauthenticated-<id> cache marker (1s tolerance)
   await async_test(
     "non-admin can re authenciate when locked to 0",
     () => sdkNonAdmin.authenticate(nonAdminEmail, nonAdminPassword),
@@ -11269,6 +11460,7 @@ const lockout_tests = async () => {
     () => sdk.api.users.updateOne(nonAdminId, { lockedOutUntil: -1 }),
     passOnAnyResult
   )
+  await wait(undefined, 1500) // ensure new token's iat second clears the stale deauthenticated-<id> cache marker (1s tolerance)
   await async_test(
     "non-admin can re authenciate when locked to future date",
     () => sdkNonAdmin.authenticate(nonAdminEmail, nonAdminPassword),
@@ -14842,6 +15034,7 @@ const ip_address_form_tests = async () => {
     await replace_form_field_template_values_tests()
     await mfa_tests()
     await setup_tests(sdk, sdkNonAdmin)
+    await automation_trigger_tests()
     await resource_access_tags_tests({ sdk, sdkNonAdmin })
     await beluga_manual_sync_tests({ sdk, sdkNonAdmin })
     await beluga_pharmacy_mappings_tests({ sdk, sdkNonAdmin })
@@ -14852,7 +15045,6 @@ const ip_address_form_tests = async () => {
     await load_inbox_redaction_tests({ sdk, sdkNonAdmin })
     await webhook_timeout_tests({ sdk, sdkNonAdmin })
     await user_portal_settings_tests({ sdk, sdkNonAdmin })
-    await automation_trigger_tests()
     await invite_user_enumeration_tests({ sdk, sdkNonAdmin })
     await handle_incoming_communication_cross_tenant_tests({ sdk, sdkNonAdmin })
     await calendar_event_webhook_template_tests({ sdk, sdkNonAdmin })
@@ -14870,6 +15062,7 @@ const ip_address_form_tests = async () => {
     await enduser_cross_access_isolation_tests({ sdk, sdkNonAdmin })
     await eom_procedure_codes_tests({ sdk, sdkNonAdmin })
     await cross_org_api_key_tests({ sdk, sdkNonAdmin })
+    await organization_api_keys_tests({ sdk, sdkNonAdmin })
     await organization_settings_duplicates_tests({ sdk, sdkNonAdmin })
     await enduser_session_invalidation_tests({ sdk, sdkNonAdmin })
     await chats_analytics_tests({ sdk, sdkNonAdmin })