@tellescope/sdk 0.0.9 → 0.0.10

package/src/tests/socket_tests.ts

@@ -15,6 +15,7 @@ import {
 } from "@tellescope/types-utilities"
 import { EnduserSession } from "../enduser"
 import { Session, /* APIQuery */ } from "../sdk"
+import { PLACEHOLDER_ID } from "@tellescope/constants"
 
 
 const host = process.env.TEST_URL || 'http://localhost:8080'
@@ -62,14 +63,14 @@ const access_tests = async () => {
   // const user2Deletions: string[] = []
 
   user1.handle_events({
-    'created-chat-rooms': rs => user1Events.push(...rs),
-    'updated-chat-rooms': rs => user1Events.push(...rs),
-    'deleted-chat-rooms': rs => user1Events.push(...rs),
+    '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),
+    'created-chat_rooms': rs => user2Events.push(...rs),
+    // 'updated-chat_rooms': rs => user2Events.push(...rs),
+    // 'deleted-chat_rooms': rs => user2Events.push(...rs),
   })
 
   const user1Id = user1.userInfo.id
@@ -84,6 +85,13 @@ const access_tests = async () => {
   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' })
   await wait(undefined, 10)
   user2.subscribe({ [room.id]: 'chats' }) // connection should be rejected
@@ -115,7 +123,7 @@ const access_tests = async () => {
   await wait(undefined, 25)
   const sharedChat2 = await user2.api.chats.createOne({ roomId: sharedRoom.id, message: "Hello there!", })
   await wait(undefined, 25)
-
+  
   assert(user1Events.length === 1 && user1Events[0].id === sharedChat2.id, 'bad chats subscription', 'verify chat received')
   assert(
     user2Events.length === 2 && user2Events[1].id === sharedChat.id, 
@@ -141,15 +149,18 @@ const enduser_tests = async () => {
   await wait(undefined, 25)
 
   user1.subscribe({ [room.id]: 'chats' })
+  user1.subscribe({ tickets: 'tickets' })
   await wait(undefined, 10)
   enduserSDK.subscribe({ [room.id]: 'chats' }) 
   await wait(undefined, 10)
 
   user1.handle_events({
     'created-chats': rs => userEvents.push(...rs),
+    'created-tickets': rs => userEvents.push(...rs),
   }) 
   enduserSDK.handle_events({
     'created-chats': rs => enduserEvents.push(...rs),
+    'created-tickets': rs => enduserEvents.push(...rs),
   }) 
 
   const messageToEnduser = await user1.api.chats.createOne({ roomId: room.id, message: "Hello!" })
@@ -158,7 +169,20 @@ const enduser_tests = async () => {
 
   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')
+
+  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, 25)
+
+  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')
   
+  await user1.api.tickets.deleteOne(unusedTicket.id)
+  await user1.api.tickets.deleteOne(ticketForEnduser.id)
+  await user1.api.tickets.deleteOne(ticketFromEnduser.id)
+
   // test enduser logout
   await enduserSDK.api.endusers.logout()
   await async_test(

package/src/tests/tests.ts

@@ -25,7 +25,7 @@ import {
 
 import { Session, APIQuery, EnduserSession } from "../sdk"
 import {  } from "@tellescope/utilities"
-import { DEFAULT_OPERATIONS } from "@tellescope/constants"
+import { DEFAULT_OPERATIONS, PLACEHOLDER_ID } from "@tellescope/constants"
 import { 
   schema, 
   Model, 
@@ -218,6 +218,20 @@ const filterTests = async () => {
   await sdk.api.endusers.deleteOne(otherEnduser.id)
 }
 
+const updatesTests = async () => {
+  const enduser = await sdk.api.endusers.createOne({ email: 'test@tellescope.com', phone: '+15555555555' })
+  await sdk.api.endusers.updateOne(enduser.id, { phone: '+15555555552' }) // update to new phone number 
+  await sdk.api.endusers.updateOne(enduser.id, { phone: '+15555555552' }) // update to same phone number
+  assert(!!enduser, '', 'Updated phone number')
+
+  const task = await sdk.api.tasks.createOne({ text: "do the thing", completed: false })
+  await sdk.api.tasks.updateOne(task.id, { completed: false }) // test setting false (falsey value) on update
+  assert(!!task, '', 'Set completed false')
+
+  await sdk.api.tasks.deleteOne(task.id)
+  await sdk.api.endusers.deleteOne(enduser.id)
+}
+
 const instanceForModel = <N extends ModelName, T=ClientModelForName[N], REQ=ClientModelForName_required[N]>(model: Model<T, N>, i=0) => {
   const instance = {} as Indexable
   const updates = {} as Indexable
@@ -899,6 +913,31 @@ const enduserAccessTests = async () => {
     } 
   }
 
+  const ticketAccessible = await sdk.api.tickets.createOne({ enduserId: enduser.id, title: "Accessible ticket" })
+  const ticketInaccessible = await sdk.api.tickets.createOne({ enduserId: PLACEHOLDER_ID, title: "Inaccessible ticket" })
+  await async_test(
+    `enduser cannot create ticket for another enduser`,
+    () => enduserSDK.api.tickets.createOne({ enduserId: sdk.userInfo.id, title: "Error on Creation" }),
+    { shouldError: true, onError: e => e.message === "enduserId does not match creator id for enduser session" }
+  )
+  await async_test(
+    `enduser-access default, no access constraints, matching enduserId`,
+    () => enduserSDK.api.tickets.getOne(ticketAccessible.id),
+    { onResult: t => t.id === ticketAccessible.id }
+  )
+  await async_test(
+    `no-enduser-access default, no access constraints, non-matching enduserId`,
+    () => enduserSDK.api.tickets.getOne(ticketInaccessible.id),
+    { shouldError: true, onError: e => e.message.startsWith("Could not find")}
+  )
+  await async_test(
+    `no-enduser-access default, no access constraints, get many`,
+    () => enduserSDK.api.tickets.getSome(),
+    { onResult: ts => ts.length === 1 }
+  )
+
+  await sdk.api.tickets.deleteOne(ticketAccessible.id)
+  await sdk.api.tickets.deleteOne(ticketInaccessible.id)
   await sdk.api.endusers.deleteOne(enduser.id)
 }
 
@@ -915,17 +954,27 @@ const tests: { [K in keyof ClientModelForName]: () => void } = {
   users: () => {},
   templates: () => {},
   files: () => {},
+  tickets: () => {},
 };
 
 (async () => {
   await sdk.authenticate(email, password, host)
 
   log_header("API")
-  await setup_tests()
-  await multi_tenant_tests() // should come right after setup tests
-  await filterTests()
-  await threadKeyTests()
-  await enduserAccessTests()
+  
+  try {
+    await setup_tests()
+    await multi_tenant_tests() // should come right after setup tests
+    await filterTests()
+    await updatesTests()
+    await threadKeyTests()
+    await enduserAccessTests()
+  } catch(err) {
+    console.error("Failed during custom test")
+    console.error(err)
+    process.exit()
+  }
+
 
   let n: keyof typeof schema;
   for (n in schema) {