digital-workers 2.1.1 → 2.3.0

package/test/error-logging.test.ts

@@ -0,0 +1,357 @@
+/**
+ * Error Logging Tests
+ *
+ * TDD tests verifying that catch blocks log errors instead of silently returning null.
+ * Following Red-Green-Refactor methodology.
+ *
+ * Bead issue: aip-prsc
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import type { Logger } from '../src/logger.js'
+import { createSlackTransport } from '../src/transports/slack.js'
+import type { SlackTransportConfig } from '../src/transports/slack.js'
+
+// ============================================================================
+// Test Fixtures
+// ============================================================================
+
+/**
+ * Creates a mock logger for testing
+ */
+function createMockLogger(): Logger & {
+  calls: {
+    debug: Array<{ msg: string; meta?: object }>
+    info: Array<{ msg: string; meta?: object }>
+    warn: Array<{ msg: string; meta?: object }>
+    error: Array<{ msg: string; error?: Error; meta?: object }>
+  }
+} {
+  const calls = {
+    debug: [] as Array<{ msg: string; meta?: object }>,
+    info: [] as Array<{ msg: string; meta?: object }>,
+    warn: [] as Array<{ msg: string; meta?: object }>,
+    error: [] as Array<{ msg: string; error?: Error; meta?: object }>,
+  }
+
+  return {
+    calls,
+    debug(msg: string, meta?: object) {
+      calls.debug.push({ msg, meta })
+    },
+    info(msg: string, meta?: object) {
+      calls.info.push({ msg, meta })
+    },
+    warn(msg: string, meta?: object) {
+      calls.warn.push({ msg, meta })
+    },
+    error(msg: string, error?: Error, meta?: object) {
+      calls.error.push({ msg, error, meta })
+    },
+  }
+}
+
+// Test configuration
+const testConfig: Omit<SlackTransportConfig, 'transport'> = {
+  botToken: 'xoxb-test-token',
+  signingSecret: 'test-signing-secret',
+  apiUrl: 'https://slack.test/api',
+}
+
+// ============================================================================
+// Slack Transport Error Logging Tests
+// ============================================================================
+
+describe('SlackTransport Error Logging', () => {
+  let mockLogger: ReturnType<typeof createMockLogger>
+  let mockFetch: ReturnType<typeof vi.fn>
+  let originalFetch: typeof globalThis.fetch
+
+  beforeEach(() => {
+    mockLogger = createMockLogger()
+    mockFetch = vi.fn()
+    originalFetch = globalThis.fetch
+    globalThis.fetch = mockFetch
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    vi.restoreAllMocks()
+  })
+
+  describe('lookupUserByEmail', () => {
+    it('should log error when API call throws', async () => {
+      // Arrange: Make fetch throw an error
+      const apiError = new Error('Network error')
+      mockFetch.mockRejectedValue(apiError)
+
+      const transport = createSlackTransport({
+        ...testConfig,
+        logger: mockLogger,
+      })
+
+      // Act
+      const result = await transport.lookupUserByEmail('test@example.com')
+
+      // Assert: Original behavior preserved
+      expect(result).toBeNull()
+
+      // Assert: Error was logged with context
+      expect(mockLogger.calls.error.length).toBe(1)
+      expect(mockLogger.calls.error[0].msg).toContain('lookupUserByEmail')
+      expect(mockLogger.calls.error[0].error).toBe(apiError)
+      expect(mockLogger.calls.error[0].meta).toMatchObject({
+        email: 'test@example.com',
+      })
+    })
+
+    it('should not log when no error occurs', async () => {
+      // Arrange: Successful API response
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ ok: true, user: { id: 'U123' } }),
+      })
+
+      const transport = createSlackTransport({
+        ...testConfig,
+        logger: mockLogger,
+      })
+
+      // Act
+      const result = await transport.lookupUserByEmail('test@example.com')
+
+      // Assert
+      expect(result).toBe('U123')
+      expect(mockLogger.calls.error.length).toBe(0)
+    })
+
+    it('should work without logger (backward compatibility)', async () => {
+      // Arrange: Make fetch throw an error
+      mockFetch.mockRejectedValue(new Error('Network error'))
+
+      const transport = createSlackTransport(testConfig)
+
+      // Act & Assert: Should not throw when no logger provided
+      const result = await transport.lookupUserByEmail('test@example.com')
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('parseWebhookPayload', () => {
+    it('should log error when JSON parsing fails', () => {
+      // Arrange
+      const transport = createSlackTransport({
+        ...testConfig,
+        logger: mockLogger,
+      })
+
+      // Create invalid JSON payload
+      const invalidRequest = {
+        body: 'payload={invalid-json}',
+        headers: {},
+        timestamp: Date.now().toString(),
+        signature: 'v0=invalid',
+      }
+
+      // Act
+      const result = transport.parseWebhookPayloadForTesting(invalidRequest)
+
+      // Assert: Original behavior preserved
+      expect(result).toBeNull()
+
+      // Assert: Error was logged
+      expect(mockLogger.calls.error.length).toBe(1)
+      expect(mockLogger.calls.error[0].msg).toContain('parseWebhookPayload')
+      expect(mockLogger.calls.error[0].error).toBeInstanceOf(SyntaxError)
+    })
+
+    it('should not log when parsing succeeds', () => {
+      // Arrange
+      const transport = createSlackTransport({
+        ...testConfig,
+        logger: mockLogger,
+      })
+
+      const validPayload = { type: 'block_actions', user: { id: 'U123' } }
+      const validRequest = {
+        body: `payload=${encodeURIComponent(JSON.stringify(validPayload))}`,
+        headers: {},
+        timestamp: Date.now().toString(),
+        signature: 'v0=test',
+      }
+
+      // Act
+      const result = transport.parseWebhookPayloadForTesting(validRequest)
+
+      // Assert
+      expect(result).toEqual(validPayload)
+      expect(mockLogger.calls.error.length).toBe(0)
+    })
+
+    it('should work without logger (backward compatibility)', () => {
+      // Arrange
+      const transport = createSlackTransport(testConfig)
+
+      const invalidRequest = {
+        body: 'payload={invalid-json}',
+        headers: {},
+        timestamp: Date.now().toString(),
+        signature: 'v0=invalid',
+      }
+
+      // Act & Assert: Should not throw when no logger provided
+      const result = transport.parseWebhookPayloadForTesting(invalidRequest)
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('parseActionValue', () => {
+    it('should log debug when JSON parsing fails (expected for string values)', () => {
+      // Arrange
+      const transport = createSlackTransport({
+        ...testConfig,
+        logger: mockLogger,
+      })
+
+      // Act: Parse a plain string (not JSON)
+      const result = transport.parseActionValueForTesting('plain-string-value')
+
+      // Assert: Original behavior preserved (returns original value)
+      expect(result).toBe('plain-string-value')
+
+      // Assert: Debug was logged (this is expected behavior, not an error)
+      expect(mockLogger.calls.debug.length).toBe(1)
+      expect(mockLogger.calls.debug[0].msg).toContain('parseActionValue')
+    })
+
+    it('should not log when JSON parsing succeeds', () => {
+      // Arrange
+      const transport = createSlackTransport({
+        ...testConfig,
+        logger: mockLogger,
+      })
+
+      const jsonValue = { action: 'approve', data: 123 }
+
+      // Act
+      const result = transport.parseActionValueForTesting(JSON.stringify(jsonValue))
+
+      // Assert
+      expect(result).toEqual(jsonValue)
+      expect(mockLogger.calls.debug.length).toBe(0)
+    })
+  })
+})
+
+// ============================================================================
+// Logger Interface Tests
+// ============================================================================
+
+describe('Logger Interface', () => {
+  it('should define all required log levels', async () => {
+    // Import the Logger interface and verify it has all required methods
+    const { Logger } = await import('../src/logger.js')
+
+    // This test verifies the interface exists - actual type checking is done by TypeScript
+    const mockLogger: Logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    }
+
+    // Verify methods are callable
+    mockLogger.debug('test debug')
+    mockLogger.info('test info', { key: 'value' })
+    mockLogger.warn('test warn')
+    mockLogger.error('test error', new Error('test'), { context: 'test' })
+
+    expect(mockLogger.debug).toHaveBeenCalledTimes(1)
+    expect(mockLogger.info).toHaveBeenCalledTimes(1)
+    expect(mockLogger.warn).toHaveBeenCalledTimes(1)
+    expect(mockLogger.error).toHaveBeenCalledTimes(1)
+  })
+
+  it('should allow optional meta parameter', async () => {
+    const { Logger } = await import('../src/logger.js')
+
+    const mockLogger: Logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    }
+
+    // All methods should work without meta
+    mockLogger.debug('no meta')
+    mockLogger.info('no meta')
+    mockLogger.warn('no meta')
+    mockLogger.error('no meta')
+
+    // Error method should work with error but no meta
+    mockLogger.error('with error', new Error('test'))
+
+    expect(mockLogger.debug).toHaveBeenCalledWith('no meta')
+    expect(mockLogger.error).toHaveBeenCalledWith('with error', new Error('test'))
+  })
+})
+
+// ============================================================================
+// Error Context Preservation Tests
+// ============================================================================
+
+describe('Error Context Preservation', () => {
+  let mockLogger: ReturnType<typeof createMockLogger>
+  let mockFetch: ReturnType<typeof vi.fn>
+  let originalFetch: typeof globalThis.fetch
+
+  beforeEach(() => {
+    mockLogger = createMockLogger()
+    mockFetch = vi.fn()
+    originalFetch = globalThis.fetch
+    globalThis.fetch = mockFetch
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('should preserve error stack trace', async () => {
+    // Arrange
+    const apiError = new Error('API failure')
+    mockFetch.mockRejectedValue(apiError)
+
+    const transport = createSlackTransport({
+      ...testConfig,
+      logger: mockLogger,
+    })
+
+    // Act
+    await transport.lookupUserByEmail('test@example.com')
+
+    // Assert: Error object with stack trace is passed to logger
+    const loggedError = mockLogger.calls.error[0].error
+    expect(loggedError).toBe(apiError)
+    expect(loggedError?.stack).toBeDefined()
+  })
+
+  it('should include operation context in log metadata', async () => {
+    // Arrange
+    mockFetch.mockRejectedValue(new Error('Network error'))
+
+    const transport = createSlackTransport({
+      ...testConfig,
+      logger: mockLogger,
+    })
+
+    // Act
+    await transport.lookupUserByEmail('user@example.com')
+
+    // Assert: Context metadata is included
+    const meta = mockLogger.calls.error[0].meta
+    expect(meta).toMatchObject({
+      email: 'user@example.com',
+      operation: 'lookupUserByEmail',
+    })
+  })
+})

package/test/generate.test.ts

@@ -0,0 +1,319 @@
+/**
+ * Tests for generate() - Content generation primitive
+ *
+ * The generate() function provides content generation with rich metadata
+ * about the generation process. Unlike ai-functions.generate() which is a
+ * lower-level type-dispatch function, this function returns GenerateResult
+ * with content, metadata (model, tokens, duration), and content type info.
+ *
+ * These tests use real AI calls via the Cloudflare AI Gateway.
+ * Tests are skipped if AI_GATEWAY_URL is not configured.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { generate } from '../src/index.js'
+
+// Skip tests if no gateway configured
+const hasGateway = !!process.env.AI_GATEWAY_URL || !!process.env.ANTHROPIC_API_KEY
+
+describe('generate() - Content Generation Primitive', () => {
+  describe('Unit Tests (no AI)', () => {
+    it('should be exported from index', () => {
+      expect(generate).toBeDefined()
+      expect(typeof generate).toBe('function')
+    })
+
+    it('should have variations method', () => {
+      expect(generate.variations).toBeDefined()
+      expect(typeof generate.variations).toBe('function')
+    })
+
+    it('should have withTone method', () => {
+      expect(generate.withTone).toBeDefined()
+      expect(typeof generate.withTone).toBe('function')
+    })
+
+    it('should have forAudience method', () => {
+      expect(generate.forAudience).toBeDefined()
+      expect(typeof generate.forAudience).toBe('function')
+    })
+
+    it('should have withLength method', () => {
+      expect(generate.withLength).toBeDefined()
+      expect(typeof generate.withLength).toBe('function')
+    })
+
+    it('should have refine method', () => {
+      expect(generate.refine).toBeDefined()
+      expect(typeof generate.refine).toBe('function')
+    })
+  })
+
+  describe.skipIf(!hasGateway)('Integration Tests (with AI) - Text Generation', () => {
+    it('should generate text content', async () => {
+      const result = await generate('Write a haiku about coding')
+
+      expect(result).toBeDefined()
+      expect(result.content).toBeDefined()
+      expect(typeof result.content).toBe('string')
+      expect(result.type).toBe('text')
+      expect(result.metadata).toBeDefined()
+    })
+
+    it('should include metadata with duration', async () => {
+      const result = await generate('Say hello in one word')
+
+      expect(result.metadata).toBeDefined()
+      expect(result.metadata?.duration).toBeDefined()
+      expect(typeof result.metadata?.duration).toBe('number')
+      expect(result.metadata?.duration).toBeGreaterThan(0)
+    })
+
+    it('should include model in metadata', async () => {
+      const result = await generate('Generate a greeting', {
+        model: 'sonnet',
+      })
+
+      expect(result.metadata?.model).toBeDefined()
+    })
+
+    it('should respect instructions', async () => {
+      const result = await generate('Write a product description', {
+        type: 'text',
+        instructions: 'Keep it under 20 words. Be enthusiastic.',
+      })
+
+      expect(result.content).toBeDefined()
+      expect(result.type).toBe('text')
+    })
+  })
+
+  describe.skipIf(!hasGateway)('Integration Tests (with AI) - Structured Generation', () => {
+    it('should generate structured content with schema', async () => {
+      const result = await generate<{ name: string; description: string }>('Create a product', {
+        type: 'structured',
+        schema: {
+          name: 'Product name',
+          description: 'Short product description',
+        },
+      })
+
+      expect(result).toBeDefined()
+      expect(result.content).toBeDefined()
+      expect(result.type).toBe('structured')
+      expect(typeof result.content).toBe('object')
+      expect((result.content as { name: string }).name).toBeDefined()
+      expect((result.content as { description: string }).description).toBeDefined()
+    })
+
+    it('should generate complex structured content', async () => {
+      const result = await generate<{
+        title: string
+        sections: string[]
+        author: { name: string; expertise: string }
+      }>('Create a technical article outline', {
+        type: 'structured',
+        schema: {
+          title: 'Article title',
+          sections: ['List of section headings'],
+          author: {
+            name: 'Author name',
+            expertise: 'Area of expertise',
+          },
+        },
+      })
+
+      expect(result.content).toBeDefined()
+      expect((result.content as { title: string }).title).toBeDefined()
+      expect(Array.isArray((result.content as { sections: string[] }).sections)).toBe(true)
+      expect((result.content as { author: { name: string } }).author.name).toBeDefined()
+    })
+
+    it('should throw error for structured without schema', async () => {
+      await expect(generate('Generate something', { type: 'structured' })).rejects.toThrow(
+        'Schema is required'
+      )
+    })
+  })
+
+  describe.skipIf(!hasGateway)('Integration Tests (with AI) - Code Generation', () => {
+    it('should generate code', async () => {
+      const result = await generate('Write a function to add two numbers', {
+        type: 'code',
+      })
+
+      expect(result).toBeDefined()
+      expect(result.content).toBeDefined()
+      expect(result.type).toBe('code')
+      expect(result.metadata?.language).toBeDefined()
+    })
+
+    it('should include explanation for code', async () => {
+      const result = await generate('Write a TypeScript function to reverse a string', {
+        type: 'code',
+        instructions: 'Use modern ES6+ syntax',
+      })
+
+      expect(result.metadata?.explanation).toBeDefined()
+      expect(typeof result.metadata?.explanation).toBe('string')
+    })
+  })
+
+  describe.skipIf(!hasGateway)('Integration Tests (with AI) - Variations', () => {
+    it('should generate multiple variations', async () => {
+      const variations = await generate.variations('Write a catchy tagline for a coffee shop', 3, {
+        type: 'text',
+      })
+
+      expect(variations).toBeDefined()
+      expect(Array.isArray(variations)).toBe(true)
+      expect(variations.length).toBe(3)
+
+      variations.forEach((v) => {
+        expect(v.content).toBeDefined()
+        expect(v.type).toBe('text')
+      })
+    })
+
+    it('should generate unique variations', async () => {
+      const variations = await generate.variations('Generate a random color name', 2)
+
+      expect(variations.length).toBe(2)
+      // Variations should be defined (may or may not be unique)
+      variations.forEach((v) => {
+        expect(v.content).toBeDefined()
+      })
+    })
+  })
+
+  describe.skipIf(!hasGateway)('Integration Tests (with AI) - Tone', () => {
+    it('should generate with professional tone', async () => {
+      const result = await generate.withTone(
+        'Write an email declining a meeting invitation',
+        'professional'
+      )
+
+      expect(result.content).toBeDefined()
+      expect(typeof result.content).toBe('string')
+    })
+
+    it('should generate with friendly tone', async () => {
+      const result = await generate.withTone('Write a thank you message', 'friendly')
+
+      expect(result.content).toBeDefined()
+    })
+
+    it('should generate with formal tone', async () => {
+      const result = await generate.withTone('Write a business letter introduction', 'formal')
+
+      expect(result.content).toBeDefined()
+    })
+
+    it('should support all tone options', async () => {
+      const tones = [
+        'professional',
+        'casual',
+        'friendly',
+        'formal',
+        'humorous',
+        'empathetic',
+      ] as const
+
+      for (const tone of tones.slice(0, 2)) {
+        // Test just a couple to save time
+        const result = await generate.withTone('Write a greeting', tone)
+        expect(result.content).toBeDefined()
+      }
+    })
+  })
+
+  describe.skipIf(!hasGateway)('Integration Tests (with AI) - Audience', () => {
+    it('should generate for technical audience', async () => {
+      const result = await generate.forAudience('Explain how HTTP works', 'software engineers')
+
+      expect(result.content).toBeDefined()
+      expect(typeof result.content).toBe('string')
+    })
+
+    it('should generate for non-technical audience', async () => {
+      const result = await generate.forAudience(
+        'Explain how HTTP works',
+        'non-technical business stakeholders'
+      )
+
+      expect(result.content).toBeDefined()
+    })
+  })
+
+  describe.skipIf(!hasGateway)('Integration Tests (with AI) - Length', () => {
+    it('should generate brief content', async () => {
+      const result = await generate.withLength('Describe a sunset', 'brief')
+
+      expect(result.content).toBeDefined()
+      // Brief should be short
+      expect((result.content as string).length).toBeLessThan(200)
+    })
+
+    it('should generate short content', async () => {
+      const result = await generate.withLength('Describe a forest', 'short')
+
+      expect(result.content).toBeDefined()
+    })
+
+    it('should generate medium content', async () => {
+      const result = await generate.withLength('Describe a city', 'medium')
+
+      expect(result.content).toBeDefined()
+    })
+
+    it('should support all length options', async () => {
+      const lengths = ['brief', 'short', 'medium', 'long', 'detailed'] as const
+
+      // Just test brief to save time
+      const result = await generate.withLength('Write about trees', 'brief')
+      expect(result.content).toBeDefined()
+    })
+  })
+
+  describe.skipIf(!hasGateway)('Integration Tests (with AI) - Refinement', () => {
+    it('should refine content iteratively', async () => {
+      const result = await generate.refine('Write a product tagline', [
+        'Make it more memorable',
+        'Add urgency',
+      ])
+
+      expect(result).toBeDefined()
+      expect(result.content).toBeDefined()
+      // Refined content should exist
+    })
+
+    it('should apply multiple refinements', async () => {
+      const result = await generate.refine('Write a headline', [
+        'Make it shorter',
+        'Add a call to action',
+      ])
+
+      expect(result.content).toBeDefined()
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should throw for unsupported content type', async () => {
+      await expect(generate('Generate an image', { type: 'image' })).rejects.toThrow(
+        'not yet implemented'
+      )
+    })
+
+    it('should throw for video type', async () => {
+      await expect(generate('Generate a video', { type: 'video' })).rejects.toThrow(
+        'not yet implemented'
+      )
+    })
+
+    it('should throw for audio type', async () => {
+      await expect(generate('Generate audio', { type: 'audio' })).rejects.toThrow(
+        'not yet implemented'
+      )
+    })
+  })
+})