@roj-ai/transport 0.1.36 → 0.2.2

package/src/core/protocol.test.ts

@@ -1,235 +0,0 @@
-/**
- * Protocol Definition Tests
- */
-
-import { describe, expect, it } from 'bun:test'
-import { z } from 'zod'
-import { defineProtocol, method, notification } from './protocol.js'
-
-describe('Protocol Definition', () => {
-	describe('method()', () => {
-		it('should create a method definition', () => {
-			const def = method({
-				input: z.object({ id: z.string() }),
-				output: z.object({ success: z.boolean() }),
-				error: z.object({ code: z.string() }),
-			})
-
-			expect(def._type).toBe('method')
-			expect(def.input).toBeDefined()
-			expect(def.output).toBeDefined()
-			expect(def.error).toBeDefined()
-		})
-	})
-
-	describe('notification()', () => {
-		it('should create a notification definition', () => {
-			const def = notification({
-				input: z.object({ message: z.string() }),
-			})
-
-			expect(def._type).toBe('notification')
-			expect(def.input).toBeDefined()
-		})
-	})
-
-	describe('defineProtocol()', () => {
-		const testProtocol = defineProtocol({
-			subscribe: method({
-				input: z.object({ sessionId: z.string() }),
-				output: z.void(),
-				error: z.object({ code: z.enum(['SESSION_NOT_FOUND']), message: z.string() }),
-			}),
-			unsubscribe: method({
-				input: z.object({ sessionId: z.string() }),
-				output: z.void(),
-				error: z.never(),
-			}),
-			agentMessage: notification({
-				input: z.object({
-					sessionId: z.string(),
-					content: z.string(),
-					format: z.enum(['text', 'markdown']),
-				}),
-			}),
-		})
-
-		it('should expose the definition', () => {
-			expect(testProtocol._def).toBeDefined()
-			expect(testProtocol._def.subscribe).toBeDefined()
-			expect(testProtocol._def.unsubscribe).toBeDefined()
-			expect(testProtocol._def.agentMessage).toBeDefined()
-		})
-
-		describe('getEndpoint()', () => {
-			it('should return endpoint definition by name', () => {
-				const endpoint = testProtocol.getEndpoint('subscribe')
-				expect(endpoint._type).toBe('method')
-			})
-		})
-
-		describe('isMethod()', () => {
-			it('should return true for methods', () => {
-				expect(testProtocol.isMethod('subscribe')).toBe(true)
-				expect(testProtocol.isMethod('unsubscribe')).toBe(true)
-			})
-
-			it('should return false for notifications', () => {
-				expect(testProtocol.isMethod('agentMessage')).toBe(false)
-			})
-		})
-
-		describe('isNotification()', () => {
-			it('should return true for notifications', () => {
-				expect(testProtocol.isNotification('agentMessage')).toBe(true)
-			})
-
-			it('should return false for methods', () => {
-				expect(testProtocol.isNotification('subscribe')).toBe(false)
-			})
-		})
-
-		describe('getMethodNames()', () => {
-			it('should return all method names', () => {
-				const names = testProtocol.getMethodNames()
-				expect(names).toContain('subscribe')
-				expect(names).toContain('unsubscribe')
-				expect(names).not.toContain('agentMessage')
-			})
-		})
-
-		describe('getNotificationNames()', () => {
-			it('should return all notification names', () => {
-				const names = testProtocol.getNotificationNames()
-				expect(names).toContain('agentMessage')
-				expect(names).not.toContain('subscribe')
-			})
-		})
-
-		describe('validateInput()', () => {
-			it('should validate correct input', () => {
-				const result = testProtocol.validateInput('subscribe', { sessionId: 'test-123' })
-				expect(result.success).toBe(true)
-				if (result.success) {
-					expect(result.data.sessionId).toBe('test-123')
-				}
-			})
-
-			it('should reject invalid input', () => {
-				const result = testProtocol.validateInput('subscribe', { sessionId: 123 })
-				expect(result.success).toBe(false)
-				if (!result.success) {
-					expect(result.error.message).toBeDefined()
-				}
-			})
-
-			it('should reject missing required fields', () => {
-				const result = testProtocol.validateInput('subscribe', {})
-				expect(result.success).toBe(false)
-			})
-
-			it('should validate notification input', () => {
-				const result = testProtocol.validateInput('agentMessage', {
-					sessionId: 'test',
-					content: 'Hello',
-					format: 'text',
-				})
-				expect(result.success).toBe(true)
-			})
-
-			it('should reject invalid notification input', () => {
-				const result = testProtocol.validateInput('agentMessage', {
-					sessionId: 'test',
-					content: 'Hello',
-					format: 'invalid',
-				})
-				expect(result.success).toBe(false)
-			})
-		})
-
-		describe('validateOutput()', () => {
-			it('should validate method output', () => {
-				const result = testProtocol.validateOutput('subscribe', undefined)
-				expect(result.success).toBe(true)
-			})
-
-			it('should throw for notification output validation', () => {
-				expect(() => testProtocol.validateOutput('agentMessage', {})).toThrow(
-					'Endpoint agentMessage is not a method',
-				)
-			})
-		})
-	})
-
-	describe('complex schemas', () => {
-		it('should handle nested objects', () => {
-			const protocol = defineProtocol({
-				createUser: method({
-					input: z.object({
-						name: z.string(),
-						address: z.object({
-							street: z.string(),
-							city: z.string(),
-						}),
-					}),
-					output: z.object({ id: z.string() }),
-					error: z.object({ code: z.string() }),
-				}),
-			})
-
-			const valid = protocol.validateInput('createUser', {
-				name: 'John',
-				address: { street: '123 Main St', city: 'NYC' },
-			})
-			expect(valid.success).toBe(true)
-
-			const invalid = protocol.validateInput('createUser', {
-				name: 'John',
-				address: { street: '123 Main St' }, // Missing city
-			})
-			expect(invalid.success).toBe(false)
-		})
-
-		it('should handle arrays', () => {
-			const protocol = defineProtocol({
-				sendBatch: method({
-					input: z.object({
-						messages: z.array(z.object({
-							id: z.string(),
-							content: z.string(),
-						})),
-					}),
-					output: z.object({ processed: z.number() }),
-					error: z.object({ code: z.string() }),
-				}),
-			})
-
-			const valid = protocol.validateInput('sendBatch', {
-				messages: [
-					{ id: '1', content: 'Hello' },
-					{ id: '2', content: 'World' },
-				],
-			})
-			expect(valid.success).toBe(true)
-		})
-
-		it('should handle optional fields', () => {
-			const protocol = defineProtocol({
-				search: method({
-					input: z.object({
-						query: z.string(),
-						limit: z.number().optional(),
-					}),
-					output: z.array(z.string()),
-					error: z.object({ code: z.string() }),
-				}),
-			})
-
-			const withOptional = protocol.validateInput('search', { query: 'test', limit: 10 })
-			expect(withOptional.success).toBe(true)
-
-			const withoutOptional = protocol.validateInput('search', { query: 'test' })
-			expect(withoutOptional.success).toBe(true)
-		})
-	})
-})

package/src/core/router.test.ts

@@ -1,248 +0,0 @@
-/**
- * Message Router Tests
- *
- * Tests for notification-only message router.
- */
-
-import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test'
-import { z } from 'zod'
-import { defineProtocol, notification } from './protocol.js'
-import { createRouter, MessageRouter } from './router.js'
-
-// Test protocols (notification-only)
-const receiveProtocol = defineProtocol({
-	agentMessage: notification({
-		input: z.object({ sessionId: z.string(), content: z.string() }),
-	}),
-	error: notification({
-		input: z.object({ code: z.string(), message: z.string() }),
-	}),
-})
-
-const sendProtocol = defineProtocol({
-	userMessage: notification({
-		input: z.object({ sessionId: z.string(), content: z.string() }),
-	}),
-	status: notification({
-		input: z.object({ status: z.string() }),
-	}),
-})
-
-describe('MessageRouter', () => {
-	let router: MessageRouter<typeof receiveProtocol._def, typeof sendProtocol._def>
-	let sender: ReturnType<typeof mock>
-	let sentMessages: string[]
-
-	beforeEach(() => {
-		router = new MessageRouter(receiveProtocol, sendProtocol)
-		sentMessages = []
-		sender = mock((msg: string) => {
-			sentMessages.push(msg)
-			return true
-		})
-		router.setSender(sender)
-	})
-
-	afterEach(() => {
-		// No cleanup needed - no pending requests in notification-only router
-	})
-
-	describe('handleMessage - incoming notifications', () => {
-		it('should dispatch notification to handler', async () => {
-			const handler = mock().mockResolvedValue(undefined)
-			router.setHandlers({ agentMessage: handler })
-
-			await router.handleMessage(
-				JSON.stringify({
-					type: 'agentMessage',
-					payload: { sessionId: 'sess-1', content: 'Hello' },
-					ts: Date.now(),
-				}),
-				{ connectionId: 'conn-1' },
-			)
-
-			expect(handler).toHaveBeenCalledWith(
-				{ sessionId: 'sess-1', content: 'Hello' },
-				{ connectionId: 'conn-1' },
-			)
-		})
-
-		it('should not send any response for notifications', async () => {
-			const handler = mock().mockResolvedValue(undefined)
-			router.setHandlers({ agentMessage: handler })
-
-			await router.handleMessage(
-				JSON.stringify({
-					type: 'agentMessage',
-					payload: { sessionId: 'sess-1', content: 'Hello' },
-					ts: Date.now(),
-				}),
-				{ connectionId: 'conn-1' },
-			)
-
-			// Notifications don't send responses
-			expect(sentMessages.length).toBe(0)
-		})
-
-		it('should ignore invalid input without error', async () => {
-			const handler = mock().mockResolvedValue(undefined)
-			router.setHandlers({ agentMessage: handler })
-
-			await router.handleMessage(
-				JSON.stringify({
-					type: 'agentMessage',
-					payload: { sessionId: 123 }, // Should be string, missing content
-					ts: Date.now(),
-				}),
-				{ connectionId: 'conn-1' },
-			)
-
-			// Handler should not be called for invalid input
-			expect(handler).not.toHaveBeenCalled()
-			// No error response sent (notification-only)
-			expect(sentMessages.length).toBe(0)
-		})
-
-		it('should ignore messages when no handler registered', async () => {
-			// No handlers set
-
-			await router.handleMessage(
-				JSON.stringify({
-					type: 'agentMessage',
-					payload: { sessionId: 'test', content: 'Hello' },
-					ts: Date.now(),
-				}),
-				{ connectionId: 'conn-1' },
-			)
-
-			// Should not throw and not send any response
-			expect(sentMessages.length).toBe(0)
-		})
-
-		it('should silently ignore handler errors', async () => {
-			const handler = mock().mockRejectedValue(new Error('Handler failed'))
-			router.setHandlers({ agentMessage: handler })
-
-			// Should not throw
-			await router.handleMessage(
-				JSON.stringify({
-					type: 'agentMessage',
-					payload: { sessionId: 'test', content: 'Hello' },
-					ts: Date.now(),
-				}),
-				{ connectionId: 'conn-1' },
-			)
-
-			expect(handler).toHaveBeenCalled()
-			// No error response sent (notification-only)
-			expect(sentMessages.length).toBe(0)
-		})
-
-		it('should handle multiple notification types', async () => {
-			const agentHandler = mock().mockResolvedValue(undefined)
-			const errorHandler = mock().mockResolvedValue(undefined)
-			router.setHandlers({
-				agentMessage: agentHandler,
-				error: errorHandler,
-			})
-
-			await router.handleMessage(
-				JSON.stringify({
-					type: 'agentMessage',
-					payload: { sessionId: 'sess-1', content: 'Hello' },
-					ts: Date.now(),
-				}),
-				{ connectionId: 'conn-1' },
-			)
-
-			await router.handleMessage(
-				JSON.stringify({
-					type: 'error',
-					payload: { code: 'ERR_001', message: 'Something failed' },
-					ts: Date.now(),
-				}),
-				{ connectionId: 'conn-1' },
-			)
-
-			expect(agentHandler).toHaveBeenCalledTimes(1)
-			expect(errorHandler).toHaveBeenCalledTimes(1)
-		})
-	})
-
-	describe('notify - outbound notifications', () => {
-		it('should send notification', () => {
-			router.notify('userMessage', { sessionId: 'test', content: 'Hello' })
-
-			expect(sentMessages.length).toBe(1)
-			const message = JSON.parse(sentMessages[0])
-			expect(message.type).toBe('userMessage')
-			expect(message.payload).toEqual({ sessionId: 'test', content: 'Hello' })
-		})
-
-		it('should include timestamp', () => {
-			const before = Date.now()
-			router.notify('status', { status: 'online' })
-			const after = Date.now()
-
-			const message = JSON.parse(sentMessages[0])
-			expect(message.ts).toBeGreaterThanOrEqual(before)
-			expect(message.ts).toBeLessThanOrEqual(after)
-		})
-
-		it('should return true on success', () => {
-			const result = router.notify('userMessage', { sessionId: 'test', content: 'Hello' })
-			expect(result).toBe(true)
-		})
-
-		it('should return false if no sender configured', () => {
-			const noSenderRouter = new MessageRouter(receiveProtocol, sendProtocol)
-			const result = noSenderRouter.notify('userMessage', { sessionId: 'test', content: 'Hello' })
-			expect(result).toBe(false)
-		})
-
-		it('should return false if sender returns false', () => {
-			const failingRouter = new MessageRouter(receiveProtocol, sendProtocol)
-			failingRouter.setSender(() => false)
-
-			const result = failingRouter.notify('userMessage', { sessionId: 'test', content: 'Hello' })
-			expect(result).toBe(false)
-		})
-	})
-
-	describe('createRouter factory', () => {
-		it('should create a router instance', () => {
-			const router = createRouter(receiveProtocol, sendProtocol)
-			expect(router).toBeInstanceOf(MessageRouter)
-		})
-	})
-
-	describe('invalid JSON handling', () => {
-		it('should ignore invalid JSON', async () => {
-			const handler = mock()
-			router.setHandlers({ agentMessage: handler })
-
-			await router.handleMessage('not valid json', { connectionId: 'test' })
-
-			expect(handler).not.toHaveBeenCalled()
-		})
-	})
-
-	describe('unknown message types', () => {
-		it('should ignore unknown message types', async () => {
-			const handler = mock()
-			router.setHandlers({ agentMessage: handler })
-
-			await router.handleMessage(
-				JSON.stringify({
-					type: 'unknownType',
-					payload: {},
-					ts: Date.now(),
-				}),
-				{ connectionId: 'test' },
-			)
-
-			expect(handler).not.toHaveBeenCalled()
-			expect(sentMessages.length).toBe(0)
-		})
-	})
-})