make kestrel a tak server, so that it can send and receive pois as cots data

test/unit/logger.spec.js

@@ -1,71 +1,119 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initLogger, logError, logWarn, logInfo, logDebug } from '../../app/utils/logger.js'
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { info, error, warn, debug, setContext, clearContext, runWithContext } from '../../server/utils/logger.js'
 
 describe('logger', () => {
-  let fetchMock
+  let originalLog
+  let originalError
+  let originalWarn
+  let originalDebug
+  let logCalls
+  let errorCalls
+  let warnCalls
+  let debugCalls
 
   beforeEach(() => {
-    fetchMock = vi.fn().mockResolvedValue(undefined)
-    vi.stubGlobal('$fetch', fetchMock)
-    vi.useFakeTimers()
+    logCalls = []
+    errorCalls = []
+    warnCalls = []
+    debugCalls = []
+    originalLog = console.log
+    originalError = console.error
+    originalWarn = console.warn
+    originalDebug = console.debug
+    console.log = vi.fn((...args) => logCalls.push(args))
+    console.error = vi.fn((...args) => errorCalls.push(args))
+    console.warn = vi.fn((...args) => warnCalls.push(args))
+    console.debug = vi.fn((...args) => debugCalls.push(args))
   })
 
   afterEach(() => {
-    vi.useRealTimers()
-    vi.unstubAllGlobals()
+    console.log = originalLog
+    console.error = originalError
+    console.warn = originalWarn
+    console.debug = originalDebug
   })
 
-  it('initLogger sets context', () => {
-    initLogger('sess-1', 'user-1')
-    logError('test', {})
-    vi.advanceTimersByTime(10)
-    expect(fetchMock).toHaveBeenCalledWith('/api/log', expect.objectContaining({
-      method: 'POST',
-      body: expect.objectContaining({
-        sessionId: 'sess-1',
-        userId: 'user-1',
-        level: 'error',
-        message: 'test',
-      }),
-    }))
+  it('logs info message', () => {
+    info('Test message')
+    expect(logCalls.length).toBe(1)
+    const logMsg = logCalls[0][0]
+    expect(logMsg).toContain('[INFO]')
+    expect(logMsg).toContain('Test message')
   })
 
-  it('logError sends error level', () => {
-    logError('err', { code: 1 })
-    vi.advanceTimersByTime(10)
-    expect(fetchMock).toHaveBeenCalledWith('/api/log', expect.objectContaining({
-      body: expect.objectContaining({ level: 'error', message: 'err', data: { code: 1 } }),
-    }))
+  it('includes request context when set', async () => {
+    await runWithContext('req-123', 'user-456', async () => {
+      info('Test message')
+      const logMsg = logCalls[0][0]
+      expect(logMsg).toContain('req-123')
+      expect(logMsg).toContain('user-456')
+    })
   })
 
-  it('logWarn sends warn level', () => {
-    logWarn('warn', {})
-    vi.advanceTimersByTime(10)
-    expect(fetchMock).toHaveBeenCalledWith('/api/log', expect.objectContaining({
-      body: expect.objectContaining({ level: 'warn', message: 'warn' }),
-    }))
+  it('includes additional context', () => {
+    info('Test message', { key: 'value', count: 42 })
+    const logMsg = logCalls[0][0]
+    expect(logMsg).toContain('key')
+    expect(logMsg).toContain('value')
+    expect(logMsg).toContain('42')
   })
 
-  it('logInfo sends info level', () => {
-    logInfo('info', {})
-    vi.advanceTimersByTime(10)
-    expect(fetchMock).toHaveBeenCalledWith('/api/log', expect.objectContaining({
-      body: expect.objectContaining({ level: 'info', message: 'info' }),
-    }))
+  it('logs error with stack trace', () => {
+    const err = new Error('Test error')
+    error('Failed', { error: err })
+    expect(errorCalls.length).toBe(1)
+    const errorMsg = errorCalls[0][0]
+    expect(errorMsg).toContain('[ERROR]')
+    expect(errorMsg).toContain('Failed')
+    expect(errorMsg).toContain('stack')
   })
 
-  it('logDebug sends debug level', () => {
-    logDebug('debug', {})
-    vi.advanceTimersByTime(10)
-    expect(fetchMock).toHaveBeenCalledWith('/api/log', expect.objectContaining({
-      body: expect.objectContaining({ level: 'debug', message: 'debug' }),
-    }))
+  it('logs warning', () => {
+    warn('Warning message')
+    expect(warnCalls.length).toBe(1)
+    const warnMsg = warnCalls[0][0]
+    expect(warnMsg).toContain('[WARN]')
   })
 
-  it('does not throw when $fetch rejects', async () => {
-    vi.stubGlobal('$fetch', vi.fn().mockRejectedValue(new Error('network')))
-    logError('x', {})
-    vi.advanceTimersByTime(10)
-    await vi.advanceTimersByTimeAsync(0)
+  it('logs debug only in development', () => {
+    const originalEnv = process.env.NODE_ENV
+    process.env.NODE_ENV = 'development'
+    debug('Debug message')
+    expect(debugCalls.length).toBe(1)
+    process.env.NODE_ENV = originalEnv
+  })
+
+  it('does not log debug in production', () => {
+    const originalEnv = process.env.NODE_ENV
+    process.env.NODE_ENV = 'production'
+    debug('Debug message')
+    expect(debugCalls.length).toBe(0)
+    process.env.NODE_ENV = originalEnv
+  })
+
+  it('clears context', async () => {
+    await runWithContext('req-123', 'user-456', async () => {
+      info('Test with context')
+      const logMsg = logCalls[0][0]
+      expect(logMsg).toContain('req-123')
+    })
+    // Context should be cleared after runWithContext completes
+    info('Test without context')
+    const logMsg = logCalls[logCalls.length - 1][0]
+    expect(logMsg).not.toContain('req-123')
+  })
+
+  it('supports deprecated setContext/clearContext API', async () => {
+    await runWithContext(null, null, async () => {
+      setContext('req-123', 'user-456')
+      info('Test message')
+      const logMsg = logCalls[0][0]
+      expect(logMsg).toContain('req-123')
+      expect(logMsg).toContain('user-456')
+      clearContext()
+      info('Test after clear')
+      const logMsg2 = logCalls[1][0]
+      expect(logMsg2).not.toContain('req-123')
+    })
   })
 })