@tellescope/sdk 0.0.17 → 0.0.21

package/src/tests/socket_tests.ts

@@ -1,3 +1,4 @@
+import { createHash } from "crypto"
 import {
   assert,
   async_test,
@@ -17,6 +18,7 @@ import { EnduserSession } from "../enduser"
 import { Session, /* APIQuery */ } from "../sdk"
 import { PLACEHOLDER_ID } from "@tellescope/constants"
 
+export const get_sha256 = (s='') => createHash('sha256').update(s).digest('hex')
 
 const host = process.env.TEST_URL || 'http://localhost:8080'
 const [email, password] = [process.env.TEST_EMAIL, process.env.TEST_PASSWORD]
@@ -198,28 +200,89 @@ const enduser_tests = async () => {
   // await user1.api.chats.deleteOne(messageToUser.id)
 }
 
+const TEST_SESSION_DURATION = 2 // seconds
+const SESSION_TIMEOUT_DELAY = 2000 // ms
+const deauthentication_tests = async (byTimeout=false) => {
+  log_header(`Unauthenticated Tests ${byTimeout ? '- With Timeout, requires Worker' : '- With Manual Logout' }`)
+  
+  const enduser = await user1.api.endusers.createOne({ email: "socketenduser@tellescope.com" })
+  await user1.api.endusers.set_password({ id: enduser.id, password: 'enduserPassword!' })
+  await enduserSDK.authenticate(enduser.email as string, 'enduserPassword!', { expirationInSeconds: byTimeout ? TEST_SESSION_DURATION : undefined })
+  await wait(undefined, 25)
+  
+  const room  = await user1.api.chat_rooms.createOne({ 
+    type: 'external', 
+    userIds: [user1.userInfo.id],
+    enduserIds: [enduser.id],
+  })
+
+  const userEvents = [] as ChatMessage[]
+  const enduserEvents = [] as ChatMessage[]
+  user1.subscribe({ [room.id]: 'chats' })
+  enduserSDK.subscribe({ [room.id]: 'chats' }) 
+  user1.handle_events({ 'created-chats': rs => userEvents.push(...rs) }) 
+  enduserSDK.handle_events({ 'created-chats': rs => enduserEvents.push(...rs) }) 
+  await wait(undefined, 10)
+
+  if (!byTimeout) {
+    await enduserSDK.api.endusers.logout()
+  } else {
+    await wait(undefined, TEST_SESSION_DURATION * 1000 + SESSION_TIMEOUT_DELAY) 
+  }
+  await user1.api.chats.createOne({ roomId: room.id, message: "Hello!" })
+  await wait(undefined, 25)
+  assert(objects_equivalent(enduserEvents[0], undefined), 'enduser got message after logout on socket', 'enduser logged out')
+
+  // re-authenticate enduser to send message to user
+  await enduserSDK.authenticate(enduser.email as string, 'enduserPassword!')
+
+  // ensure user logged out appropriately for not receiving message
+  await user1.logout()
+  if (byTimeout) {
+    await user1.authenticate(email, password, { expirationInSeconds: byTimeout ? TEST_SESSION_DURATION : undefined } )
+    await wait(undefined, TEST_SESSION_DURATION * 1000 + SESSION_TIMEOUT_DELAY) 
+  }
+  await enduserSDK.api.chats.createOne({ roomId: room.id, message: "Hello right back!" })
+  await wait(undefined, 25)
+  assert(objects_equivalent(userEvents[0], undefined), 'user got message after logout', 'user logged out')
+
+  // must come before cleanup, so cleanup works
+  await user1.authenticate(email, password), // reauthenticate for later tests as needed
+
+  // cleanup
+  await Promise.all([
+    user1.api.endusers.deleteOne(enduser.id),
+    user1.api.chat_rooms.deleteOne(room.id), // deletes chats as side effect
+  ])
+}
+
 (async () => {
   log_header("Sockets")
 
   try {
-    await user1.authenticate(email, password, host)
+    await user1.authenticate(email, password)
     await user1.reset_db()
-    await user2.authenticate(email2, password2, host) // generate authToken + socket connection for API keyj
+    await user2.authenticate(email2, password2) // generate authToken + socket connection for API keyj
     await wait(undefined, 25)
 
     let loopCount = 0
     while (!(user1.socketAuthenticated && user2.socketAuthenticated) && ++loopCount < 10) {
-      user2.authenticate_socket()
+      if (!user1.socketAuthenticated) user1.authenticate_socket()
+      if (!user2.socketAuthenticated) user2.authenticate_socket()
       await wait(undefined, 100)
     }
     if (loopCount === 10) {
       console.log("Failed to authenticate")
       process.exit()
     }
-    
+
     await enduser_tests()
     await basic_tests()
     await access_tests()
+
+    await deauthentication_tests() // should come last!
+    await deauthentication_tests(true) // should come last!
+
   } catch(err) {
     console.error(err)
   }

package/src/tests/tests.ts

@@ -71,7 +71,7 @@ const userId = '60398b0231a295e64f084fd9'
 //   await sdk.api.endusers.deleteOne(enduser.id)
 // }
 
-const sdk = new Session()
+const sdk = new Session({ host })
 const sdkOther = new Session({ host, apiKey: "ba745e25162bb95a795c5fa1af70df188d93c4d3aac9c48b34a5c8c9dd7b80f7" })
 const enduserSDK = new EnduserSession({ host })
 // const sdkOtherEmail = "sebass@tellescope.com"
@@ -90,8 +90,6 @@ const setup_tests = async () => {
   await async_test('test_online', sdk.test_online, { expectedResult: 'API V1 Online' })
   await async_test('test_authenticated', sdk.test_authenticated, { expectedResult: 'Authenticated!' })
 
-  // console.log(await sdk.api.api_keys.createOne({}))
-
   await async_test(
     'test_authenticated (with API Key)', 
     (new Session({ host, apiKey: '3n5q0SCBT_iUvZz-b9BJtX7o7HQUVJ9v132PgHJNJsg.' /* local test key */  })).test_authenticated, 
@@ -100,7 +98,7 @@ const setup_tests = async () => {
 
   await sdk.logout()
   await async_test<string, string>('test_authenticated - (logout invalidates jwt)', sdk.test_authenticated, { shouldError: true, onError: e => e === 'Unauthenticated' })
-  await sdk.authenticate(email, password, host)
+  await sdk.authenticate(email, password)
   await async_test('test_authenticated (re-authenticated)', sdk.test_authenticated, { expectedResult: 'Authenticated!' })
 
   await async_test('reset_db', () => sdk.reset_db(), passOnVoid)
@@ -191,6 +189,20 @@ const threadKeyTests = async () => {
   ])
 }
 
+const badInputTests = async () => {
+  log_header("Bad Input Tests")
+  await async_test(
+    `_-prefixed fields are not allowed`, 
+    () => sdk.api.endusers.createOne({ email: 'failure@tellescope.com', fields: { "_notallowed": 'hello' } }), 
+    { shouldError: true, onError: e => e.message === "Error parsing field fields: Fields that start with '_' are not allowed" },
+  )
+  await async_test(
+    `_-prefixed fields are not allowed`, 
+    () => sdk.api.notes.createOne({ enduserId: PLACEHOLDER_ID, fields: { "_notallowed": 'hello' } }), 
+    { shouldError: true, onError: e => e.message === "Error parsing field fields: Fields that start with '_' are not allowed" },
+  )
+}
+
 const filterTests = async () => {
   const enduser = await sdk.api.endusers.createOne({ email: 'filtertests@tellescope.com', fname: 'test', fields: { field1: 'value1', field2: 'value2' } })
   const otherEnduser = await sdk.api.endusers.createOne({ email: 'other@tellescope.com' })
@@ -199,6 +211,17 @@ const filterTests = async () => {
     () => sdk.api.endusers.getSome({ filter: { email: 'filtertests@tellescope.com' }}), 
     { onResult: es => es.length === 1 && es[0].id === enduser.id },
   )
+  await async_test(
+    `find enduser by _exists filter`, 
+    () => sdk.api.endusers.getSome({ filter: { fname: { _exists: true } }}), 
+    { onResult: es => es.length === 1 && es[0].id === enduser.id },
+  )
+  await async_test(
+    `find enduser by _exists filter (findOne)`, 
+    // () => sdk.api.endusers.getOne({ fname: { _exists: true } }), 
+    () => sdk.api.endusers.getOne({ fname: { _exists: true } }), 
+    { onResult: e => e.id === enduser.id },
+  )
   await async_test(
     `find enduser by compound filter`, 
     () => sdk.api.endusers.getSome({ filter: { email: 'filtertests@tellescope.com', fname: 'test' }}), 
@@ -265,13 +288,21 @@ const updatesTests = async () => {
 
 const generateEnduserAuthTests = async () => {
   log_header("Generated Enduser authToken Tests")
-  const e = await sdk.api.endusers.createOne({ email: 'generated@tellescope.com', phone: '+15555555555', externalId: '1029f9v9sjd0as' })
+  const externalId = '1029f9v9sjd0as'
+  const e = await sdk.api.endusers.createOne({ email: 'generated@tellescope.com', phone: '+15555555555', externalId })
+
   const { authToken, enduser } = await sdk.api.endusers.generate_auth_token({ id: e.id })
   assert(!!authToken && !!enduser, 'invalid returned values', 'Generate authToken and get enduser')
-
   const { isAuthenticated } = await sdk.api.endusers.is_authenticated({ id: enduser.id, authToken })
   assert(isAuthenticated, 'invalid authToken generated for enduser', 'Generate authToken for enduser is valid')
 
+  const { authToken: authTokenUID, enduser: enduser2 } = await sdk.api.endusers.generate_auth_token({ externalId })
+  assert(!!authTokenUID && !!enduser2, 'invalid returned values eid', 'Generate authToken and get enduser eid')
+  assert((
+    await sdk.api.endusers.is_authenticated({ id: enduser2.id, authToken: authTokenUID })).isAuthenticated, 
+    'invalid authToken generated for enduser', 'Generate authToken for enduser is valid'
+  )
+
   await async_test(
     `auth by externalId`, () => sdk.api.endusers.generate_auth_token({ externalId: e.externalId }), passOnVoid,
   ) 
@@ -419,7 +450,7 @@ const run_generated_tests = async <N extends ModelName>({ queries, model, name,
   }
   await async_test(
     `get-${singularName}`, 
-    () => queries.getOne(_id, filter), 
+    () => queries.getOne(_id), 
     { onResult: d => {
         if (!d?.id) return false
 
@@ -452,7 +483,7 @@ const run_generated_tests = async <N extends ModelName>({ queries, model, name,
   )
   await async_test(
     `get-${singularName} (verify delete)`, 
-    () => queries.getOne(_id, filter), 
+    () => queries.getOne(_id), 
     { shouldError: true, onError: e => e.message === 'Could not find a record for the given id' } 
   )
 }
@@ -840,32 +871,22 @@ const chat_tests = async() => {
   const chat  = await sdk.api.chats.createOne({ roomId: room.id, message: "Hello!" })
   const chat2 = await sdk.api.chats.createOne({ roomId: room.id, message: "Hello..." })
 
-  await async_test(
-    `get-chat (without filter)`, 
-    () => sdk.api.chats.getOne(chat.id), 
-    { shouldError: true, onError: () => true }
-  )
+  // await async_test(
+  //   `get-chat (without filter)`, 
+  //   () => sdk.api.chats.getOne(chat.id), 
+  //   { shouldError: true, onError: () => true }
+  // )
   await async_test(
     `get-chats (without filter)`, 
     () => sdk.api.chats.getSome({}), 
     { shouldError: true, onError: () => true }
   )
-  await async_test(
-    `get-chat (with filter)`, 
-    () => sdk.api.chats.getOne(chat.id, { roomId: room.id }), 
-    { onResult: c => c?.id === chat.id }
-  )
   await async_test(
     `get-chats (with filter)`, 
     () => sdk.api.chats.getSome({ filter: { roomId: room.id } }), 
     { onResult: c => c?.length === 2 }
   )
 
-  await async_test(
-    `get-chat not allowed`, 
-    () => sdk2.api.chats.getOne(chat.id, { roomId: room.id }), 
-    { shouldError: true, onError: e => e.message === 'You do not have permission to access this resource' }
-  )
   await async_test(
     `get-chats not allowed`, 
     () => sdk2.api.chats.getSome({ filter: { roomId: room.id } }), 
@@ -894,12 +915,12 @@ const chat_tests = async() => {
   await wait(undefined, 25)
   await async_test(
     `get-chat (deleted as dependency of room 1)`,
-    () => sdk.api.chats.getOne(chat.id, { roomId: room.id }), 
+    () => sdk.api.chats.getOne(chat.id), 
     { shouldError: true, onError: e => e.message === 'Could not find a record for the given id' }
   )
   await async_test(
     `get-chat (deleted as dependency of room 2)`,
-    () => sdk.api.chats.getOne(chat2.id, { roomId: room.id }), 
+    () => sdk.api.chats.getOne(chat2.id), 
     { shouldError: true, onError: e => e.message === 'Could not find a record for the given id' }
   )
 
@@ -908,12 +929,12 @@ const chat_tests = async() => {
   const sharedChat2 = await sdk2.api.chats.createOne({ roomId: sharedRoom.id, message: "Hello there!", })
   await async_test(
     `get-chat (shared, user1)`,
-    () => sdk.api.chats.getOne(sharedChat.id, { roomId: sharedRoom.id }), 
+    () => sdk.api.chats.getOne(sharedChat.id), 
     { onResult: r => r.id === sharedChat.id }
   )
   await async_test(
     `get-chat (shared, user2)`,
-    () => sdk2.api.chats.getOne(sharedChat.id, { roomId: sharedRoom.id }), 
+    () => sdk2.api.chats.getOne(sharedChat.id), 
     { onResult: r => r.id === sharedChat.id }
   )
   await async_test(
@@ -936,7 +957,7 @@ const chat_tests = async() => {
   await sdk.api.chats.deleteOne(chatNull.id)
   await async_test(
     `get-chat (setNull working)`,
-    () => sdk.api.chats.getOne(chat2Null.id, { roomId: roomNull.id }), 
+    () => sdk.api.chats.getOne(chat2Null.id), 
     { onResult: c => c.replyId === null }
   )
 }
@@ -952,47 +973,48 @@ const enduserAccessTests = async () => {
   for (const n in schema) {
     const endpoint = url_safe_path(n)
     const model = schema[n as keyof typeof schema]
+    if (n === 'webhooks') continue // no default endpoints implemented
 
     if (!model?.enduserActions?.read && (model.defaultActions.read || model.customActions.read)) {
       await async_test(
         `no-enduser-access getOne (${endpoint})`,
         () => enduserSDK.GET(`/v1/${endpoint.substring(0, endpoint.length - 1)}/:id`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
     if (!model.enduserActions?.readMany && (model.defaultActions.readMany || model.customActions.readMany)) {
       await async_test(
         `no-enduser-access getSome (${endpoint})`,
         () => enduserSDK.GET(`/v1/${endpoint}`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
     if (!model.enduserActions?.create && (model.defaultActions.create || model.customActions.create)) {
       await async_test(
         `no-enduser-access createOne (${endpoint})`,
         () => enduserSDK.POST(`/v1/${endpoint.substring(0, endpoint.length - 1)}`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
     if (!model.enduserActions?.createMany && (model.defaultActions.createMany || model.customActions.createMany)) {
       await async_test(
         `no-enduser-access createMany (${endpoint})`,
         () => enduserSDK.POST(`/v1/${endpoint}`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
     if (!model.enduserActions?.update && (model.defaultActions.update || model.customActions.update)) {
       await async_test(
         `no-enduser-access update (${endpoint})`,
         () => enduserSDK.PATCH(`/v1/${endpoint.substring(0, endpoint.length - 1)}/:id`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
     if (!model.enduserActions?.delete && (model.defaultActions.delete || model.customActions.delete)) {
       await async_test(
         `no-enduser-access delete (${endpoint})`,
         () => enduserSDK.DELETE(`/v1/${endpoint.substring(0, endpoint.length - 1)}/:id`), 
-        { shouldError: true, onError: (e: string) => e === 'Unauthenticated' }
+        { shouldError: true, onError: (e: any) => e === 'Unauthenticated' || e?.message === 'This action is not allowed' }
       )
     } 
   }
@@ -1055,16 +1077,17 @@ const tests: { [K in keyof ClientModelForName]: () => void } = {
   tickets: () => {},
   meetings: () => {},
   notes: () => {},
+  webhooks: () => {},
 };
 
 (async () => {
-  await sdk.authenticate(email, password, host)
-
   log_header("API")
-  
+
   try {
+    await sdk.authenticate(email, password)
     await setup_tests()
     await multi_tenant_tests() // should come right after setup tests
+    await badInputTests()
     await filterTests()
     await updatesTests()
     await threadKeyTests()

package/src/tests/webhooks_tests.ts

@@ -0,0 +1,183 @@
+import express from "express"
+import bodyParser from 'body-parser'
+import crypto from "crypto"
+
+import {
+  assert,
+  async_test,
+  log_header,
+  wait,
+} from "@tellescope/testing"
+import {
+  objects_equivalent
+} from "@tellescope/utilities"
+
+import {
+  WEBHOOK_MODELS,
+  WebhookSupportedModel,
+  WebhookRecord,
+  WebhookCall,
+  CUDSubscription,
+} from "@tellescope/types-models"
+
+import { Session } from "../sdk"
+
+const [email, password] = [process.env.TEST_EMAIL, process.env.TEST_PASSWORD]
+const [email2, password2] = [process.env.TEST_EMAIL_2, process.env.TEST_PASSWORD_2]
+const [nonAdminEmail, nonAdminPassword] = [process.env.NON_ADMIN_EMAIL, process.env.NON_ADMIN_PASSWORD]
+if (!(email && password && email2 && password2 && nonAdminEmail && nonAdminPassword)) {
+  console.error("Set TEST_EMAIL and TEST_PASSWORD")
+  process.exit()
+}
+
+
+const sdk = new Session({ host: 'http://localhost:8080' })
+const nonAdminSdk = new Session({ host: 'http://localhost:8080' })
+
+const app = express()
+app.use(bodyParser.urlencoded({ extended: true, limit: '25mb' }))
+app.use(bodyParser.json({ limit: "25mb" }))
+
+const PORT = 4000
+const TEST_SECRET = "this is a test secret for verifying integrity of web hooks"
+const webhookEndpoint = '/handle-webhook'
+const webhookURL = `http://127.0.0.1:${PORT}${webhookEndpoint}`
+
+const sha256 = (s: string) => crypto.createHash('sha256').update(s).digest('hex')
+
+const verify_integrity = (records: WebhookRecord[], timestamp: string, integrity: string,) => (
+  sha256(records.map(r => r.id).join('') + timestamp + TEST_SECRET) === integrity
+)
+
+const handledEvents: WebhookCall[] = []
+app.post(webhookEndpoint, (req, res) => {
+  const body = req.body as WebhookCall
+  // console.log('got hook', body.records, body.timestamp, body.integrity)
+
+  if (!verify_integrity(body.records, body.timestamp, body.integrity)) {
+    console.error("Integrity check failed for request", JSON.stringify(body, null, 2))
+    process.exit()
+  }
+
+  handledEvents.push(req.body)
+  res.status(204).end()
+})
+
+const fullSubscription = {} as { [K in WebhookSupportedModel]: CUDSubscription }
+const emptySubscription = {} as { [K in WebhookSupportedModel]: CUDSubscription }
+for (const model in WEBHOOK_MODELS) {
+  fullSubscription[model as WebhookSupportedModel] = { create: true, update: true, delete: true }
+  emptySubscription[model as WebhookSupportedModel] = { create: false, update: false, delete: false }
+}
+
+let webhookIndex = 0
+const check_next_webhook = async (evaluate: (hook: WebhookCall) => boolean, name: string, error: string, isSubscribed: boolean) => {
+  if (isSubscribed === false) return
+
+  await wait(undefined, 25) // wait for hook to post
+
+  const event = handledEvents[webhookIndex]
+  assert(!!event, 'did not get hook', 'got hook')
+  if (!event) return // ensure webhookIndex not incremented
+
+  const success = evaluate(event)
+  assert(success, error, name)
+  if (!success) { console.error('Got', event) }
+
+  webhookIndex++
+}
+
+const chats_tests = async (isSubscribed: boolean) => {
+  log_header(`Chats Tests, isSubscribed=${isSubscribed}`)
+  const room = await sdk.api.chat_rooms.createOne({ userIds: [sdk.userInfo.id] })
+
+  const chat = await sdk.api.chats.createOne({ roomId: room.id, message: "Hello hello hi hello" })
+  await check_next_webhook(a => objects_equivalent(a.records, [chat]), 'Create chat error', 'Create chat webhook', isSubscribed)
+
+  // cleanup
+  await sdk.api.chat_rooms.deleteOne(room.id) // also cleans up messages
+
+  // when chatroom support added for webhooks, check deletion here
+  // await check_next_webhook(a => objects_equivalent(a.records, [chat_room]), 'Delete chat room error', 'Delete chat room webhook', isSubscribed)
+}
+
+const meetings_tests = async (isSubscribed: boolean) => {
+  log_header(`Meetings Tests, isSubscribed=${isSubscribed}`)
+  const meeting = await sdk.api.meetings.start_meeting()
+
+  await check_next_webhook(a => objects_equivalent(a.records, [meeting]), 'Create meeting error', 'Create meeting webhook', isSubscribed)
+
+  // cleanup
+  await sdk.api.meetings.end_meeting({ id: meeting.id }) // also cleans up messages
+}
+
+const tests: { [K in WebhookSupportedModel]: (isSubscribed: boolean) => Promise<void> } = {
+  chats: chats_tests,
+  meetings: meetings_tests,
+}
+
+const run_tests = async () => {
+  log_header("Webhooks Tests")
+  await sdk.authenticate(email, password)
+  await sdk.reset_db() 
+  await nonAdminSdk.authenticate(nonAdminEmail, nonAdminPassword)
+
+  await async_test(
+    'configure webhook is admin only',
+    () => nonAdminSdk.api.webhooks.configure({ url: webhookURL, secret: TEST_SECRET }),
+    { shouldError: true, onError: e => e.message === "Inaccessible" || e.message === "Admin access only"}
+  )
+  await async_test(
+    'update webhook is admin only',
+    () => nonAdminSdk.api.webhooks.update({ subscriptionUpdates: fullSubscription }),
+    { shouldError: true, onError: e => e.message === "Inaccessible" || e.message === "Admin access only"}
+  )
+
+  await async_test(
+    'configure webhook',
+    () => sdk.api.webhooks.configure({ url: webhookURL, secret: TEST_SECRET }),
+    { onResult: _ => true }
+  )
+  await async_test(
+    'configure webhook (only callable once)',
+    () => sdk.api.webhooks.configure({ url: webhookURL, secret: TEST_SECRET }),
+    { shouldError: true, onError: e => e.message === "Only one webhook configuration is supported per organization. Use /update-webooks to update your configuration." }
+  )
+  await async_test(
+    'update webhook (set subscriptions)',
+    () => sdk.api.webhooks.update({ subscriptionUpdates: fullSubscription }),
+    { onResult: _ => true }
+  )
+  await async_test(
+    'update webhook invalid model',
+    () => sdk.api.webhooks.update({ subscriptionUpdates: { notAModel: { create: false } } as any }),
+    { shouldError: true, onError: e => e.message === "Error parsing field subscriptionUpdates: Got unexpected field(s) [notAModel]" }
+  )
+
+  log_header("Webhooks Tests with Subscriptions")
+  for (const t in tests) {
+    await tests[t as keyof typeof tests](true)
+  }
+  const finalLength = handledEvents.length
+
+  await async_test(
+    'update webhook (set subscriptions empty)',
+    () => sdk.api.webhooks.update({ subscriptionUpdates: emptySubscription }),
+    { onResult: _ => true }
+  )
+
+  log_header("Webhooks Tests without Subscriptions")
+  for (const t in tests) {
+    await tests[t as keyof typeof tests](false)
+  }
+  assert(finalLength === handledEvents.length, 'length changed after subscriptions', 'No webhooks posted when no subscription')
+
+}
+
+app.listen(PORT, async () => {
+  try { 
+    await run_tests()
+  } catch(err) { console.error(err) }
+
+  process.exit()
+})