@tellescope/sdk 0.0.94 → 0.0.97

package/src/tests/socket_tests.ts

@@ -23,17 +23,20 @@ export const get_sha256 = (s='') => createHash('sha256').update(s).digest('hex')
 
 const VERBOSE = true
 
-const AWAIT_SOCKET_DURATION = 150 // 25ms was generally passing for Redis, 1000ms should be upper limit of performance
+const AWAIT_SOCKET_DURATION = 250 // 25ms was generally passing for Redis, 1000ms should be upper limit of performance
 
 const host = process.env.TEST_URL || 'http://localhost:8080'
 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]
 const businessId = '60398b1131a295e64f084ff6'
 
 const user1 = new Session({ host, enableSocketLogging: VERBOSE })
 const user2 = new Session({ host, enableSocketLogging: VERBOSE })
+const sdkNonAdmin = new Session({ host })
+
 const enduserSDK = new EnduserSession({ host, businessId, enableSocketLogging: VERBOSE })
-if (!(email && password && email2 && password2)) {
+if (!(email && password && email2 && password2 && nonAdminEmail && nonAdminPassword)) {
   console.error("Set TEST_EMAIL and TEST_PASSWORD")
   process.exit(1)
 }
@@ -42,7 +45,7 @@ if (!(email && password && email2 && password2)) {
 const basic_tests = async () => {
   const socket_events: Indexable[] = []
 
-  user2.subscribe({ 'endusers': 'endusers' }, {
+  user2.handle_events({
     'created-endusers': es => socket_events.push(es),
     'updated-endusers': es => socket_events.push(es),
     'deleted-endusers': es => socket_events.push(es),
@@ -68,52 +71,37 @@ const basic_tests = async () => {
 
 const access_tests = async () => {
   const user1Events: Indexable[] = []
-  const user2Events: Indexable[] = []
-  // const user1Deletions: string[] = []
-  // const user2Deletions: string[] = []
+  const nonAdminEvents: Indexable[] = []
+  const enduserEvents: Indexable[] = []
 
-  user1.handle_events({
-    'created-chat_rooms': rs => user1Events.push(...rs),
-    // 'updated-chat_rooms': rs => user1Events.push(...rs), sent message will create update event as cached messagepreview/sender updated
-    // 'deleted-chat_rooms': rs => user1Events.push(...rs),
-  })
-  user2.handle_events({
-    'created-chat_rooms': rs => user2Events.push(...rs),
-    // 'updated-chat_rooms': rs => user2Events.push(...rs),
-    // 'deleted-chat_rooms': rs => user2Events.push(...rs),
-  })
+  user1.handle_events({ 'created-chat_rooms': rs => user1Events.push(...rs) })
+  sdkNonAdmin.handle_events({ 'created-chat_rooms': rs => nonAdminEvents.push(...rs) })
 
   const user1Id = user1.userInfo.id
-  const user2Id = user2.userInfo.id
+  const user2Id = sdkNonAdmin.userInfo.id
 
   const room  = await user1.api.chat_rooms.createOne({ type: 'internal', userIds: [user1Id] })
   const sharedRoom  = await user1.api.chat_rooms.createOne({ type: 'internal', userIds: [user1Id, user2Id] })
   await wait(undefined, AWAIT_SOCKET_DURATION)
 
-  assert(user1Events.length === 0, 'bad event distribution for filter', 'verify filter socket no self')
-  assert(user2Events.length === 1 && sharedRoom.id === user2Events[0].id, 'bad event distribution for filter', 'verify filter socket push')
-
-  user1.removeAllSocketListeners('created-chat_rooms')
-  user1.removeAllSocketListeners('update-chat_rooms')
-  user1.removeAllSocketListeners('deleted-chat_rooms')
-  user2.removeAllSocketListeners('created-chat_rooms')
-  user2.removeAllSocketListeners('update-chat_rooms')
-  user2.removeAllSocketListeners('deleted-chat_rooms')
-
-  user1.subscribe({ [room.id]: 'chats' })
-  user2.subscribe({ [room.id]: 'chats' }) // connection should be rejected
-  user1.subscribe({ [sharedRoom.id]: 'chats' })
-  user2.subscribe({ [sharedRoom.id]: 'chats' })  
+  assert(user1Events.length === 2, 'bad event distribution for filter', 'creator gets socket notifications')
+  assert(nonAdminEvents.length === 1 && sharedRoom.id === nonAdminEvents[0].id, 'bad event distribution for filter', 'verify filter socket push')
 
   user1.handle_events({
+    'created-chat_rooms': rs => user1Events.push(...rs),
     'created-chats': rs => user1Events.push(...rs),
+    'created-tickets': rs => user1Events.push(...rs),
+    'created-endusers': rs => user1Events.push(...rs),
     'updated-chats': rs => user1Events.push(...rs),
     'deleted-chats': rs => user1Events.push(...rs),
   })
-  user2.handle_events({
-    'created-chats': rs => user2Events.push(...rs),
-    'updated-chats': rs => user2Events.push(...rs),
-    'deleted-chats': rs => user2Events.push(...rs),
+  sdkNonAdmin.handle_events({
+    'created-chat_rooms': rs => nonAdminEvents.push(...rs),
+    'created-chats': rs => nonAdminEvents.push(...rs),
+    'created-tickets': rs => nonAdminEvents.push(...rs),
+    'created-endusers': rs => nonAdminEvents.push(...rs),
+    'updated-chats': rs => nonAdminEvents.push(...rs),
+    'deleted-chats': rs => nonAdminEvents.push(...rs),
   })
   await wait(undefined, AWAIT_SOCKET_DURATION)
 
@@ -121,18 +109,160 @@ const access_tests = async () => {
   await user1.api.chats.createOne({ roomId: room.id, message: "Hello...", })
   await wait(undefined, AWAIT_SOCKET_DURATION)
 
-  assert(user1Events.length === 0, 'bad chats subscription', 'verify chats no self')
-  assert(user2Events.length === 1, 'bad chats subscription', 'push only for valid subscribers')
+  assert(user1Events.length === 4, 'bad chats self', 'chats to self')
+  assert(nonAdminEvents.length === 1, 'non-admin got chats', 'non admin doesnt get chats for unassigned room')
 
-  const sharedChat  = await user1.api.chats.createOne({ roomId: sharedRoom.id, message: "Hello!", })
-  const sharedChat2 = await user2.api.chats.createOne({ roomId: sharedRoom.id, message: "Hello there!", })
+  const sharedChat  = await user1.api.chats.createOne({ roomId: sharedRoom.id, message: "Hello from admin on shared", })
+  const sharedChat2 = await sdkNonAdmin.api.chats.createOne({ roomId: sharedRoom.id, message: "Hello from nonadmin on shared", })
   await wait(undefined, AWAIT_SOCKET_DURATION)
   
-  assert(user1Events.length === 1 && user1Events[0].id === sharedChat2.id, 'bad chats subscription', 'verify chat received')
+  assert(user1Events.length === 6 && !!user1Events.find((r: any) => r?.id === sharedChat2.id), 'bad chats other', 'verify chat received')
+  assert(
+    nonAdminEvents.length === 3 && !!nonAdminEvents.find((e: any) => e.id === sharedChat.id), 
+    'bad chats self, non-admin', 'push valid for non-admin default access'
+  )
+
+  const unassignedEnduser = await user1.api.endusers.createOne({ email: 'unassigned@tellescope.com' })
+  const assignedEnduser = await user1.api.endusers.createOne({ email: 'assigned@tellescope.com', assignedTo: [user2Id] })
+  await wait (undefined, AWAIT_SOCKET_DURATION)
+
+  assert(
+    !!user1Events.find(e => e.id === unassignedEnduser.id) && !!user1Events.find(e => e.id === assignedEnduser.id),
+    'admin did not get endusers',
+    'admin got assigned and unassigned endusers',
+  )
+
+  assert(
+    !nonAdminEvents.find(e => e.id === unassignedEnduser.id) && !!nonAdminEvents.find(e => e.id === assignedEnduser.id),
+    'non-admin got incorrect endusers',
+    'non-admin got assigned enduser',
+  )
+
+  await user1.api.endusers.set_password({ id: unassignedEnduser.id, password: 'enduserPassword!' })
+  await enduserSDK.authenticate(unassignedEnduser.email as string, 'enduserPassword!')
+  await enduserSDK.authenticate_socket()
+
+  enduserSDK.handle_events({  
+    'created-chat_rooms': rs => enduserEvents.push(...rs),
+    'created-chats': rs => enduserEvents.push(...rs),
+    'created-tickets': rs => enduserEvents.push(...rs),
+  })
+
+  // test admin and enduser get messages
+  const roomUnassigned = await user1.api.chat_rooms.createOne({ enduserIds: [unassignedEnduser.id] })
+  // test non-admin user in userIds gets message
+  const roomUnassignedWithUser = await user1.api.chat_rooms.createOne({ enduserIds: [unassignedEnduser.id], userIds: [user2Id] })
+  // test non-admin user who is assigned to enduser gets messages
+  const roomAssigned = await user1.api.chat_rooms.createOne({ enduserIds: [assignedEnduser.id] })
+  await wait (undefined, AWAIT_SOCKET_DURATION)
+
+  assert((
+       !!user1Events.find(e => e.id === roomUnassigned.id) 
+    && !!user1Events.find(e => e.id === roomUnassignedWithUser.id)
+    && !!user1Events.find(e => e.id === roomAssigned.id) 
+    ),
+    'enduser did not get chat rooms',
+    'enduser got chat rooms',
+  )
+  assert((
+      !nonAdminEvents.find(e => e.id === roomUnassigned.id) // shouldn't get as non-admin
+  && !!nonAdminEvents.find(e => e.id === roomUnassignedWithUser.id) // gets for in room
+  && !!nonAdminEvents.find(e => e.id === roomAssigned.id) // gets for enduser assignment
+    ),
+    'non-admin did not get chat rooms',
+    'non-admin got chat rooms',
+  )
+  assert(
+    (
+       !!enduserEvents.find(e => e.id === roomUnassigned.id) 
+    && !!enduserEvents.find(e => e.id === roomUnassignedWithUser.id)
+    && !enduserEvents.find(e => e.id === roomAssigned.id)
+    ),
+    'enduser did not get chat rooms',
+    'enduser got chat rooms',
+  )
+
+  let userMessage = await user1.api.chats.createOne({ message: 'user unassigned', roomId: roomUnassigned.id })
+  let enduserMessage = await enduserSDK.api.chats.createOne({ message: 'enduseruser unassigned', roomId: roomUnassigned.id })
+  await wait (undefined, AWAIT_SOCKET_DURATION)
+
+  assert(
+    !!enduserEvents.find(e => e.id === userMessage.id),
+    'enduser did not get message',
+    'enduser got message from user',
+  )
   assert(
-    user2Events.length === 2 && user2Events[1].id === sharedChat.id, 
-    'bad chats subscription', 'push only for valid subscribers shared'
+    !!user1Events.find(e => e.id === enduserMessage.id),
+    'user did not get message',
+    'user got message from enduser',
   )
+  assert(
+    !nonAdminEvents.find(e => e.id === enduserMessage.id) && !nonAdminEvents.find(e => e.id === userMessage.id),
+    'non-admin got unexpected message',
+    'non-admin correctly did not get message from enduser or user',
+  )
+
+
+  userMessage = await user1.api.chats.createOne({ message: 'user unassigned with user', roomId: roomUnassignedWithUser.id })
+  enduserMessage = await enduserSDK.api.chats.createOne({ message: 'enduser unassigned with user', roomId: roomUnassignedWithUser.id })
+  let nonAdminMessage = await sdkNonAdmin.api.chats.createOne({ message: 'non-admin unassigned with non', roomId: roomUnassignedWithUser.id })
+  await wait (undefined, AWAIT_SOCKET_DURATION)
+
+  assert(
+    !!enduserEvents.find(e => e.id === userMessage.id) && !!enduserEvents.find(e => e.id === nonAdminMessage.id),
+    'enduser did not get message',
+    'enduser got message from user',
+  )
+  assert(
+    !!user1Events.find(e => e.id === enduserMessage.id) && !!user1Events.find(e => e.id === nonAdminMessage.id),
+    'user did not get messages',
+    'user got messages',
+  )
+  assert(
+    !!nonAdminEvents.find(e => e.id === enduserMessage.id) && !!nonAdminEvents.find(e => e.id === userMessage.id),
+    'non-admin didnt get messages',
+    'non-admin got message from user and enduser',
+  )
+
+
+  await user1.api.endusers.set_password({ id: assignedEnduser.id, password: 'enduserPassword!' })
+  await enduserSDK.authenticate(assignedEnduser.email as string, 'enduserPassword!')
+  await enduserSDK.authenticate_socket()
+
+  enduserSDK.handle_events({  
+    'created-chats': rs => enduserEvents.push(...rs),
+  })
+
+
+  userMessage = await user1.api.chats.createOne({ message: 'user assigned', roomId: roomAssigned.id })
+  enduserMessage = await enduserSDK.api.chats.createOne({ message: 'enduser assigned', roomId: roomAssigned.id })
+  nonAdminMessage = await sdkNonAdmin.api.chats.createOne({ message: 'non-admin assigned', roomId: roomAssigned.id })
+  await wait (undefined, AWAIT_SOCKET_DURATION)
+
+  assert(
+    !!enduserEvents.find(e => e.id === userMessage.id) && !!enduserEvents.find(e => e.id === nonAdminMessage.id),
+    'enduser did not get messages',
+    'enduser got messages from users',
+  )
+  assert(
+    !!user1Events.find(e => e.id === enduserMessage.id) && !!user1Events.find(e => e.id === nonAdminMessage.id),
+    'user did not get messages',
+    'user got messages',
+  )
+  assert(
+    !!nonAdminEvents.find(e => e.id === enduserMessage.id) && !!nonAdminEvents.find(e => e.id === userMessage.id),
+    'non-admin didnt get messages',
+    'non-admin got message from user and enduser',
+  )
+
+
+  await Promise.all([
+    await user1.api.endusers.deleteOne(unassignedEnduser.id),
+    await user1.api.endusers.deleteOne(assignedEnduser.id),
+    await user1.api.chat_rooms.deleteOne(roomAssigned.id),
+    await user1.api.chat_rooms.deleteOne(roomUnassigned.id),
+    await user1.api.chat_rooms.deleteOne(roomUnassignedWithUser.id),
+  ])
 }
 
 const enduser_tests = async () => {
@@ -160,30 +290,23 @@ const enduser_tests = async () => {
     enduserIds: [enduser.id],
   })
 
-  user1.subscribe({ [room.id]: 'chats' })
-  user1.subscribe({ tickets: 'tickets' })
-  enduserSDK.subscribe({ 
-    [room.id]: 'chats', 
-    dontCache: 'chats', // prevents cacheing of otherwise identical-looking subscriptions for user1 and enduserSDK for chats
-  }) 
-
   await wait(undefined, AWAIT_SOCKET_DURATION)
 
   const messageToEnduser = await user1.api.chats.createOne({ roomId: room.id, message: "Hello!" })
   const messageToUser    = await enduserSDK.api.chats.createOne({ roomId: room.id, message: "Hello right back!" })
   await wait(undefined, AWAIT_SOCKET_DURATION)
 
-  assert(objects_equivalent(userEvents[0], messageToUser), 'no message on socket', 'push message to user')
-  assert(objects_equivalent(enduserEvents[0], messageToEnduser), 'no message on socket', 'push message to enduser')
+  assert(!!userEvents.find(e => e.id === messageToUser.id), 'no message on socket for user', 'push message to user')
+  assert(!!enduserEvents.find(e => e.id === messageToEnduser.id), 'no message on socket for enduser', 'push message to enduser')
 
   const unusedTicket = await user1.api.tickets.createOne({ enduserId: PLACEHOLDER_ID, title: "For Noone" }) // should not get pushed to enduser
   const ticketForEnduser  = await user1.api.tickets.createOne({ enduserId: enduser.id, title: "For enduser" })
   const ticketFromEnduser = await enduserSDK.api.tickets.createOne({ enduserId: enduser.id, title: "By enduser" })
   await wait(undefined, AWAIT_SOCKET_DURATION)
 
-  assert(objects_equivalent(userEvents[1], ticketFromEnduser), 'no ticket on socket for user', 'push ticket to user')
-  assert(objects_equivalent(enduserEvents[1], ticketForEnduser), 'no ticket on socket for enduser', 'push ticket to enduser')
-  assert(enduserEvents[2] === undefined, 'enduser got an orgwide ticket', 'enduser does not receive org-wide ticket')
+  assert(!!userEvents.find(t => t.id === ticketFromEnduser.id), 'no ticket on socket for user', 'push ticket to user')
+  assert(!!enduserEvents.find(t => t.id === ticketForEnduser.id), 'no ticket on socket for enduser', 'push ticket to enduser')
+  assert(!enduserEvents.find(t => t.id === unusedTicket.id), 'enduser got an orgwide ticket', 'enduser does not receive org-wide ticket')
   
   await user1.api.tickets.deleteOne(unusedTicket.id)
   await user1.api.tickets.deleteOne(ticketForEnduser.id)
@@ -222,8 +345,6 @@ const deauthentication_tests = async (byTimeout=false) => {
 
   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, AWAIT_SOCKET_DURATION)
@@ -233,9 +354,9 @@ const deauthentication_tests = async (byTimeout=false) => {
   } else {
     await wait(undefined, TEST_SESSION_DURATION * 1000 + SESSION_TIMEOUT_DELAY) 
   }
-  await user1.api.chats.createOne({ roomId: room.id, message: "Hello!" })
+  const badChatEnduser = await user1.api.chats.createOne({ roomId: room.id, message: "Hello!" })
   await wait(undefined, AWAIT_SOCKET_DURATION)
-  assert(objects_equivalent(enduserEvents[0], undefined), 'enduser got message after logout on socket', 'enduser logged out')
+  assert(enduserEvents.find(c => c.id === badChatEnduser.id) === 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!')
@@ -248,9 +369,9 @@ const deauthentication_tests = async (byTimeout=false) => {
   } else {
     await wait(undefined, AWAIT_SOCKET_DURATION)
   }
-  await enduserSDK.api.chats.createOne({ roomId: room.id, message: "Hello right back!" })
+  const badChat = await enduserSDK.api.chats.createOne({ roomId: room.id, message: "Hello right back!" })
   await wait(undefined, AWAIT_SOCKET_DURATION)
-  assert(objects_equivalent(userEvents[0], undefined), 'user got message after logout', 'user logged out')
+  assert(userEvents.find(e => e.id === badChat.id) === undefined, 'user got message after logout', 'user logged out')
 
 
   // must come before cleanup, so cleanup works
@@ -303,7 +424,7 @@ const calendar_events = async () => {
   })
   await wait(undefined, AWAIT_SOCKET_DURATION)
 
-  assert(userEvents.length === 0, 'creator got calendar event', 'calendar event not gone to creator')
+  assert(userEvents.length === 1, 'creator push bad', 'calendar event gone to creator')
   assert(enduserEvents.length === 1 && enduserEvents[0].id === event.id, 'enduser did not get calendar event', 'calendar event on create for attending enduser')
 
   // cleanup
@@ -317,10 +438,11 @@ const calendar_events = async () => {
     await user1.authenticate(email, password)
     await user1.reset_db()
     await user2.authenticate(email2, password2) // generate authToken + socket connection for API keyj
+    await sdkNonAdmin.authenticate(nonAdminEmail, nonAdminPassword)
 
     await user1.connectSocket()
     await user2.connectSocket()
-
+    await sdkNonAdmin.connectSocket()
 
     await basic_tests()
     await access_tests()
@@ -330,7 +452,6 @@ const calendar_events = async () => {
 
     await deauthentication_tests() // should come last!
     await deauthentication_tests(true) // should come last!
-
   } catch(err) {
     console.error(err)
   }

package/src/tests/tests.ts

@@ -923,7 +923,7 @@ const chat_room_tests = async () => {
   let roomWithMessage = await sdk.api.chat_rooms.getOne(room.id)
   assert(roomWithMessage.numMessages === 1, 'num mesages no update', 'num messages on send message')
   assert((roomWithMessage?.recentMessageSentAt ?? 0) > Date.now() - 1000, 'recent message timestamp bad', 'recent message timestamp')
-  assert(roomWithMessage?.infoForUser?.[userId]?.unreadCount === 1, 'bad unread count for user', 'unread count for user')
+  assert(roomWithMessage?.infoForUser?.[userId]?.unreadCount === undefined, 'bad unread count for user', 'unread count for user')
   assert(roomWithMessage?.infoForUser?.[enduserSDK.userInfo.id]?.unreadCount === 1, 'bad unread count for enduser', 'unread count for enduser')
 
   roomWithMessage = await sdk.api.chat_rooms.updateOne(roomWithMessage.id, { infoForUser: { [userId]: { unreadCount: 0 }}})
@@ -1389,141 +1389,7 @@ const calendar_events_tests = async () => {
 
 const automation_events_tests = async () => {
   log_header("Automation Events")
-  const form = await sdk.api.forms.createOne({ 
-    title: 'Form', fields: [{ title: 'Question 1', type: 'string' }]
-  })
-
-  const state1 = "State 1", state2 = "State 2";
-  const journey = await sdk.api.journeys.createOne({ 
-    title: "Automations Test", 
-    defaultState: state1,
-    states: [
-      { name: state1, priority: 'N/A' },
-      { name: state2, priority: 'N/A' },
-    ]
-  })
-
-  await async_test(
-    `enterState cannot match updateStateForJourney`,
-    () => sdk.api.automation_steps.createOne({
-      journeyId: journey.id,
-      event: {
-        type: "enterState",
-        info: { state: state1, journeyId: journey.id }
-      },
-      action: {
-        type: 'updateStateForJourney',
-        info: { state: state1, journeyId: journey.id },
-      },
-    }),
-    { shouldError: true, onError: e => e.message === 'updateStateForJourney cannot have the same journey and state as the enterState event' }
-  ) 
-  await async_test(
-    `leaveState cannot match updateStateForJourney`,
-    () => sdk.api.automation_steps.createOne({
-      journeyId: journey.id,
-      event: {
-        type: "leaveState",
-        info: { state: state1, journeyId: journey.id }
-      },
-      action: {
-        type: 'updateStateForJourney',
-        info: { state: state1, journeyId: journey.id },
-      },
-    }),
-    { shouldError: true, onError: e => e.message === 'updateStateForJourney cannot have the same journey and state as the leaveState event' }
-  ) 
-
-  const testAction: AutomationAction = {
-    type: 'sendWebhook',
-    info: { message: 'test' }
-  }
-  await sdk.api.automation_steps.createOne({
-    journeyId: journey.id,
-    event: {
-      type: "enterState",
-      info: { state: state1, journeyId: journey.id }
-    },
-    action: testAction,
-  })
-  await sdk.api.automation_steps.createOne({
-    journeyId: journey.id,
-    event: {
-      type: "leaveState",
-      info: { state: state1, journeyId: journey.id }
-    },
-    action: testAction,
-  })
-  await sdk.api.automation_steps.createOne({
-    journeyId: journey.id,
-    event: {
-      type: "enterState",
-      info: { state: state2, journeyId: journey.id }
-    },
-    action: testAction,
-  })
-
-  await sdk.api.automation_steps.createOne({
-    journeyId: journey.id,
-    event: {
-      type: "formResponse",
-      info: { formId: form.id },
-    },
-    conditions: [
-      {
-        type: 'atJourneyState',
-        info: { state: state2, journeyId: journey.id }
-      } 
-    ],
-    action: testAction,
-  })
-
-  await async_test(
-    `Cannot insert duplicate event/action pair`,
-    () => sdk.api.automation_steps.createOne({
-      journeyId: journey.id,
-      event: {
-        type: "enterState",
-        info: { state: state2, journeyId: journey.id }
-      },
-      action: testAction,
-    }),
-    { shouldError: true, onError: e => e.message === "You cannot create two identical event automations" }
-  ) 
-
-  // trigger a1 on create
-  const enduser = await sdk.api.endusers.createOne({ 
-    email: "automations@tellescope.com", 
-    journeys: { [journey.id]: journey.defaultState } 
-  })
-
-  // should NOT trigger while user not in state 2
-  await sdk.api.form_responses.submit_form_response({ 
-    accessCode: (await sdk.api.form_responses.prepare_form_response({ formId: form.id, enduserId: enduser.id })).accessCode,
-    responses: ['Answer'] 
-  })
-
-  // trigger a2 and a3 by leaving state 1 an going to state 2
-  await sdk.api.endusers.updateOne(enduser.id, { journeys: { [journey.id]: state2 } })
-
-  // SHOULD trigger now that user is in state 2
-  await sdk.api.form_responses.submit_form_response({ 
-    accessCode: (await sdk.api.form_responses.prepare_form_response({ formId: form.id, enduserId: enduser.id })).accessCode,
-    responses: ['Answer 2'] 
-  })
-
-  await async_test(
-    `Automation events triggered correctly`,
-    () => sdk.api.automated_actions.getSome({ filter: { enduserId: enduser.id }}),
-    { onResult: es => es && es.length === 4 && es.filter(a => a.automationStepId === "ONE_TIME").length === 4 }
-  )  
-
-  // cleanup
-  await Promise.all([
-    sdk.api.journeys.deleteOne(journey.id), // automation events deleted as side effect
-    sdk.api.endusers.deleteOne(enduser.id),
-    sdk.api.forms.deleteOne(form.id),
-  ])
+  console.warn("Need new test coverage for automation stemps")
 }
 
 const form_response_tests = async () => {
@@ -1543,19 +1409,19 @@ const form_response_tests = async () => {
       intakeField: stringIntakeField
     }]
   })
-  await sdk.api.automation_steps.createOne({
-    event: { type: "formResponse", info: { formId: form.id } },
-    action: { type: 'sendWebhook', info: { message: 'test' } },
-  })
+  // await sdk.api.automation_steps.createOne({
+  //   event: { type: "formResponse", info: { formId: form.id } },
+  //   action: { type: 'sendWebhook', info: { message: 'test' } },
+  // })
 
   const { accessCode } = await sdk.api.form_responses.prepare_form_response({ formId: form.id, enduserId: enduser.id })
   await sdk.api.form_responses.submit_form_response({ accessCode, responses: [stringResponse]  })
 
-  const [triggeredAutomation] = await sdk.api.automated_actions.getSome()
+  // const [triggeredAutomation] = await sdk.api.automated_actions.getSome()
   const enduserWithUpdate = await sdk.api.endusers.getOne(enduser.id)
   const recordedResponse = await sdk.api.form_responses.getOne({ accessCode })
 
-  assert(triggeredAutomation?.event?.type === 'formResponse', 'no form response event', 'form response event triggered')
+  // assert(triggeredAutomation?.event?.type === 'formResponse', 'no form response event', 'form response event triggered')
   assert(enduserWithUpdate?.fields?.[stringIntakeField] === stringResponse, 'no enduser update', 'enduser updated')
   assert(
     recordedResponse?.responses?.length === 1 && recordedResponse.responses[0]?.[stringTitle] === stringResponse, 
@@ -1622,19 +1488,19 @@ const notifications_tests = async () => {
   const chat = await sdk.api.chats.createOne({ message: 'test', roomId: room.id, })
   const ticket = await sdk.api.tickets.createOne({ title: 'Ticket for notification', owner: sdkNonAdmin.userInfo.id })
   
-  await wait(undefined, 50) // notifications may be created in background
+  await wait(undefined, 250) // notifications may be created in background
 
   // neither should throw error
-  const ticketNotification = await sdk.api.user_notifications.getOne({ type: 'newTicket' }) 
-  const chatNotifications = await sdk.api.user_notifications.getSome({ filter: { type: 'newChatMessage' } }) 
+  const ticketNotifications = await sdk.api.user_notifications.getSome({ filter: { type: 'newTicket' } }) 
+  const chatNotifications = await sdk.api.user_notifications.getSome({ filter: { type: 'newTeamChatMessage' } }) 
 
-  assert(!!ticketNotification.relatedRecords?.find(r => r.id === ticket.id), 'No ticket notification', 'Got notification for new new ticket')
+  assert(!!ticketNotifications.find(n => n.relatedRecords?.find(r => r.id === ticket.id)), 'No ticket notification', 'Got notification for new new ticket')
   assert(!!chatNotifications.find(notification => notification.relatedRecords?.find(r => r.id === chat.id)), 'No chat notification', 'Got notification for new chat')
 
   await Promise.all([
     sdk.api.chat_rooms.deleteOne(room.id),
     sdk.api.tickets.deleteOne(ticket.id),
-    sdk.api.user_notifications.deleteOne(ticketNotification.id),
+    sdk.api.user_notifications.deleteOne(ticketNotifications.find(n => n.relatedRecords?.find(r => r.id === ticket.id))!.id),
     ...chatNotifications.map(n => 
       sdk.api.user_notifications.deleteOne(n.id),
     ),
@@ -1793,8 +1659,27 @@ const role_based_access_tests = async () => {
     sdk.api.sms_messages.deleteOne(sms.id),
     sdk.api.calendar_events.deleteOne(calendarEvent.id),
     sdk.api.chat_rooms.deleteOne(chatRoom.id),
-    sdk.api.chats.deleteOne(chatMessage.id),
-    sdk.api.chats.deleteOne(chatMessage2.id),
+  ])
+}
+
+const status_update_tests = async () => {
+  log_header("Enduser Status Updates")
+
+  const journey = await sdk.api.journeys.createOne({ title: 'test' })
+  const enduser = await sdk.api.endusers.createOne({ email: 'delete@tellescope.com'  })
+  const status  = await sdk.api.enduser_status_updates.createOne({ enduserId: enduser.id, journeyId: journey.id, status: "Working"})
+
+  // status update on enduser is a side effect
+  await wait(undefined, 100)
+  await async_test(
+    `status update`, () => sdk.api.endusers.getOne(enduser.id), {
+      onResult: e => e.journeys?.[journey.id] === status.status
+    },
+  )  
+
+  await Promise.all([
+    sdk.api.journeys.deleteOne(journey.id), // status deleted as side effect 
+    sdk.api.endusers.deleteOne(enduser.id), // status deleted as side effect
   ])
 }
 
@@ -1822,6 +1707,7 @@ const tests: { [K in keyof ClientModelForName]: () => void } = {
   automation_steps: automation_events_tests,
   sequence_automations: NO_TEST,
   automated_actions: NO_TEST,
+  enduser_status_updates: status_update_tests,
   user_logs: NO_TEST,
   user_notifications: notifications_tests,
 };

package/src/tests/webhooks_tests.ts

@@ -42,7 +42,7 @@ const app = express()
 app.use(bodyParser.urlencoded({ extended: true, limit: '25mb' }))
 app.use(bodyParser.json({ limit: "25mb" }))
 
-const PORT = 4000
+const PORT = 3999 
 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}`
@@ -98,7 +98,7 @@ const check_next_webhook = async (evaluate: (hook: WebhookCall) => boolean, name
   if (noHookExpected) {
     assert(!event, error, name)
   } else {
-    assert(!!event, 'did not get hook', 'got hook')
+    assert(!!event, error || 'did not get hook', name || 'got hook')
   }
   if (!event) return // ensure webhookIndex not incremented
 
@@ -190,7 +190,7 @@ const meetings_tests = async (isSubscribed: boolean) => {
   await sdk.api.endusers.deleteOne(enduser.id)
 }
 
-const AUTOMATION_POLLING_DELAY_MS = 2000 - CHECK_WEBHOOK_DELAY_MS
+const AUTOMATION_POLLING_DELAY_MS = 3000 - CHECK_WEBHOOK_DELAY_MS
 const test_automation_webhooks = async () => {
   log_header("Automation Events")
   const state1 = "State 1", state2 = "State 2";
@@ -221,12 +221,11 @@ const test_automation_webhooks = async () => {
   
   await check_next_webhook(
     ({ message }) => message === testMessage,
-    'Automation webhook error', 
     'Automation webhook received', 
+    'Automation webhook error', 
     true
   )
 
-
   // cleanup
   await sdk.api.journeys.deleteOne(journey.id) // automation events deleted as side effect
   await sdk.api.endusers.deleteOne(enduser.id)