wip: [01-stabilize] paused at task 1/1 - OCR Hallucination Immune logic via Semantic delta window and fret-isolation
This commit is contained in:
@@ -0,0 +1,367 @@
|
||||
/**
|
||||
* Chroma Vector Sync Integration Tests
|
||||
*
|
||||
* Tests ChromaSync vector embedding and semantic search.
|
||||
* Skips tests if uvx/chroma not installed (CI-safe).
|
||||
*
|
||||
* Sources:
|
||||
* - ChromaSync implementation from src/services/sync/ChromaSync.ts
|
||||
* - MCP patterns from the Chroma MCP server
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach, beforeAll, afterAll, spyOn } from 'bun:test';
|
||||
import { logger } from '../../src/utils/logger.js';
|
||||
import path from 'path';
|
||||
import os from 'os';
|
||||
import fs from 'fs';
|
||||
|
||||
// Check if uvx/chroma is available
|
||||
let chromaAvailable = false;
|
||||
let skipReason = '';
|
||||
|
||||
async function checkChromaAvailability(): Promise<{ available: boolean; reason: string }> {
|
||||
try {
|
||||
// Check if uvx is available
|
||||
const uvxCheck = Bun.spawn(['uvx', '--version'], {
|
||||
stdout: 'pipe',
|
||||
stderr: 'pipe',
|
||||
});
|
||||
await uvxCheck.exited;
|
||||
|
||||
if (uvxCheck.exitCode !== 0) {
|
||||
return { available: false, reason: 'uvx not installed' };
|
||||
}
|
||||
|
||||
return { available: true, reason: '' };
|
||||
} catch (error) {
|
||||
return { available: false, reason: `uvx check failed: ${error}` };
|
||||
}
|
||||
}
|
||||
|
||||
// Suppress logger output during tests
|
||||
let loggerSpies: ReturnType<typeof spyOn>[] = [];
|
||||
|
||||
describe('ChromaSync Vector Sync Integration', () => {
|
||||
const testProject = `test-project-${Date.now()}`;
|
||||
const testVectorDbDir = path.join(os.tmpdir(), `chroma-test-${Date.now()}`);
|
||||
|
||||
beforeAll(async () => {
|
||||
const check = await checkChromaAvailability();
|
||||
chromaAvailable = check.available;
|
||||
skipReason = check.reason;
|
||||
|
||||
// Create temp directory for vector db
|
||||
if (chromaAvailable) {
|
||||
fs.mkdirSync(testVectorDbDir, { recursive: true });
|
||||
}
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
// Cleanup temp directory
|
||||
try {
|
||||
if (fs.existsSync(testVectorDbDir)) {
|
||||
fs.rmSync(testVectorDbDir, { recursive: true, force: true });
|
||||
}
|
||||
} catch {
|
||||
// Ignore cleanup errors
|
||||
}
|
||||
});
|
||||
|
||||
beforeEach(() => {
|
||||
loggerSpies = [
|
||||
spyOn(logger, 'info').mockImplementation(() => {}),
|
||||
spyOn(logger, 'debug').mockImplementation(() => {}),
|
||||
spyOn(logger, 'warn').mockImplementation(() => {}),
|
||||
spyOn(logger, 'error').mockImplementation(() => {}),
|
||||
];
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
loggerSpies.forEach(spy => spy.mockRestore());
|
||||
});
|
||||
|
||||
describe('ChromaSync availability check', () => {
|
||||
it('should detect uvx availability status', async () => {
|
||||
const check = await checkChromaAvailability();
|
||||
// This test always passes - it just logs the status
|
||||
expect(typeof check.available).toBe('boolean');
|
||||
if (!check.available) {
|
||||
console.log(`Chroma tests will be skipped: ${check.reason}`);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('ChromaSync class structure', () => {
|
||||
it('should be importable', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
expect(ChromaSync).toBeDefined();
|
||||
expect(typeof ChromaSync).toBe('function');
|
||||
});
|
||||
|
||||
it('should instantiate with project name', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync('test-project');
|
||||
expect(sync).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Document formatting', () => {
|
||||
it('should format observation documents correctly', async () => {
|
||||
if (!chromaAvailable) {
|
||||
console.log(`Skipping: ${skipReason}`);
|
||||
return;
|
||||
}
|
||||
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
|
||||
// Test the document formatting logic by examining the class
|
||||
// The formatObservationDocs method is private, but we can verify
|
||||
// the sync method signature exists
|
||||
expect(typeof sync.syncObservation).toBe('function');
|
||||
expect(typeof sync.syncSummary).toBe('function');
|
||||
expect(typeof sync.syncUserPrompt).toBe('function');
|
||||
});
|
||||
|
||||
it('should have query method', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
expect(typeof sync.queryChroma).toBe('function');
|
||||
});
|
||||
|
||||
it('should have close method for cleanup', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
expect(typeof sync.close).toBe('function');
|
||||
});
|
||||
|
||||
it('should have ensureBackfilled method', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
expect(typeof sync.ensureBackfilled).toBe('function');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Observation sync interface', () => {
|
||||
it('should accept ParsedObservation format', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
|
||||
// The syncObservation method should accept these parameters
|
||||
const observationId = 1;
|
||||
const memorySessionId = 'session-123';
|
||||
const project = 'test-project';
|
||||
const observation = {
|
||||
type: 'discovery',
|
||||
title: 'Test Title',
|
||||
subtitle: 'Test Subtitle',
|
||||
facts: ['fact1', 'fact2'],
|
||||
narrative: 'Test narrative',
|
||||
concepts: ['concept1'],
|
||||
files_read: ['/path/to/file.ts'],
|
||||
files_modified: []
|
||||
};
|
||||
const promptNumber = 1;
|
||||
const createdAtEpoch = Date.now();
|
||||
|
||||
// Verify method signature accepts these parameters
|
||||
// We don't actually call it to avoid needing a running Chroma server
|
||||
expect(sync.syncObservation.length).toBeGreaterThanOrEqual(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Summary sync interface', () => {
|
||||
it('should accept ParsedSummary format', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
|
||||
// The syncSummary method should accept these parameters
|
||||
const summaryId = 1;
|
||||
const memorySessionId = 'session-123';
|
||||
const project = 'test-project';
|
||||
const summary = {
|
||||
request: 'Test request',
|
||||
investigated: 'Test investigated',
|
||||
learned: 'Test learned',
|
||||
completed: 'Test completed',
|
||||
next_steps: 'Test next steps',
|
||||
notes: 'Test notes'
|
||||
};
|
||||
const promptNumber = 1;
|
||||
const createdAtEpoch = Date.now();
|
||||
|
||||
// Verify method exists
|
||||
expect(typeof sync.syncSummary).toBe('function');
|
||||
});
|
||||
});
|
||||
|
||||
describe('User prompt sync interface', () => {
|
||||
it('should accept prompt text format', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
|
||||
// The syncUserPrompt method should accept these parameters
|
||||
const promptId = 1;
|
||||
const memorySessionId = 'session-123';
|
||||
const project = 'test-project';
|
||||
const promptText = 'Help me write a function';
|
||||
const promptNumber = 1;
|
||||
const createdAtEpoch = Date.now();
|
||||
|
||||
// Verify method exists
|
||||
expect(typeof sync.syncUserPrompt).toBe('function');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Query interface', () => {
|
||||
it('should accept query string and options', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
|
||||
// Verify method signature
|
||||
expect(typeof sync.queryChroma).toBe('function');
|
||||
|
||||
// The method should return a promise
|
||||
// (without calling it since no server is running)
|
||||
});
|
||||
});
|
||||
|
||||
describe('Collection naming', () => {
|
||||
it('should use project-based collection name', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
|
||||
// Collection name format is cm__{project}
|
||||
const projectName = 'my-project';
|
||||
const sync = new ChromaSync(projectName);
|
||||
|
||||
// The collection name is private, but we can verify the class
|
||||
// was constructed successfully with the project name
|
||||
expect(sync).toBeDefined();
|
||||
});
|
||||
|
||||
it('should handle special characters in project names', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
|
||||
// Projects with special characters should work
|
||||
const projectName = 'my-project_v2.0';
|
||||
const sync = new ChromaSync(projectName);
|
||||
expect(sync).toBeDefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Error handling', () => {
|
||||
it('should handle connection failures gracefully', async () => {
|
||||
if (!chromaAvailable) {
|
||||
console.log(`Skipping: ${skipReason}`);
|
||||
return;
|
||||
}
|
||||
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
|
||||
// Calling syncObservation without a running server should throw
|
||||
// but not crash the process
|
||||
const observation = {
|
||||
type: 'discovery' as const,
|
||||
title: 'Test',
|
||||
subtitle: null,
|
||||
facts: [],
|
||||
narrative: null,
|
||||
concepts: [],
|
||||
files_read: [],
|
||||
files_modified: []
|
||||
};
|
||||
|
||||
// This should either throw or fail gracefully
|
||||
try {
|
||||
await sync.syncObservation(
|
||||
1,
|
||||
'session-123',
|
||||
'test',
|
||||
observation,
|
||||
1,
|
||||
Date.now()
|
||||
);
|
||||
// If it didn't throw, the connection might have succeeded
|
||||
} catch (error) {
|
||||
// Expected - server not running
|
||||
expect(error).toBeDefined();
|
||||
}
|
||||
|
||||
// Clean up
|
||||
await sync.close();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Cleanup', () => {
|
||||
it('should handle close on unconnected instance', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
|
||||
// Close without ever connecting should not throw
|
||||
await expect(sync.close()).resolves.toBeUndefined();
|
||||
});
|
||||
|
||||
it('should be safe to call close multiple times', async () => {
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
|
||||
// Multiple close calls should be safe
|
||||
await expect(sync.close()).resolves.toBeUndefined();
|
||||
await expect(sync.close()).resolves.toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('Process leak prevention (Issue #761)', () => {
|
||||
/**
|
||||
* Regression test for GitHub Issue #761:
|
||||
* "Feature Request: Option to disable Chroma (RAM usage / zombie processes)"
|
||||
*
|
||||
* Root cause: When connection errors occur (MCP error -32000, Connection closed),
|
||||
* the code was resetting `connected` and `client` but NOT closing the transport,
|
||||
* leaving the chroma-mcp subprocess alive. Each reconnection attempt spawned
|
||||
* a NEW process while old ones accumulated as zombies.
|
||||
*
|
||||
* Fix: Transport lifecycle is now managed by ChromaMcpManager (singleton),
|
||||
* which handles connect/disconnect/cleanup. ChromaSync delegates to it.
|
||||
*/
|
||||
it('should have transport cleanup in ChromaMcpManager error handlers', async () => {
|
||||
// ChromaSync now delegates connection management to ChromaMcpManager.
|
||||
// Verify that ChromaMcpManager source includes transport cleanup.
|
||||
const sourceFile = await Bun.file(
|
||||
new URL('../../src/services/sync/ChromaMcpManager.ts', import.meta.url)
|
||||
).text();
|
||||
|
||||
// Verify that error handlers include transport cleanup
|
||||
expect(sourceFile).toContain('this.transport.close()');
|
||||
|
||||
// Verify transport is set to null after close
|
||||
expect(sourceFile).toContain('this.transport = null');
|
||||
|
||||
// Verify connected is set to false after close
|
||||
expect(sourceFile).toContain('this.connected = false');
|
||||
});
|
||||
|
||||
it('should reset state after close regardless of connection status', async () => {
|
||||
// ChromaSync.close() is now a lightweight method that logs and returns.
|
||||
// Connection state is managed by ChromaMcpManager singleton.
|
||||
const { ChromaSync } = await import('../../src/services/sync/ChromaSync.js');
|
||||
const sync = new ChromaSync(testProject);
|
||||
|
||||
// close() should complete without error regardless of state
|
||||
await expect(sync.close()).resolves.toBeUndefined();
|
||||
});
|
||||
|
||||
it('should clean up transport in ChromaMcpManager close() method', async () => {
|
||||
// Read the ChromaMcpManager source to verify transport.close() is in the close path
|
||||
const sourceFile = await Bun.file(
|
||||
new URL('../../src/services/sync/ChromaMcpManager.ts', import.meta.url)
|
||||
).text();
|
||||
|
||||
// Verify the close/disconnect method properly cleans up transport
|
||||
expect(sourceFile).toContain('await this.transport.close()');
|
||||
expect(sourceFile).toContain('this.transport = null');
|
||||
expect(sourceFile).toContain('this.connected = false');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,254 @@
|
||||
/**
|
||||
* Hook Execution End-to-End Integration Tests
|
||||
*
|
||||
* Tests the full session lifecycle: SessionStart -> PostToolUse -> SessionEnd
|
||||
* Uses real worker on test port with in-memory SQLite database.
|
||||
*
|
||||
* Sources:
|
||||
* - Hook implementations from src/hooks/*.ts
|
||||
* - Session routes from src/services/worker/http/routes/SessionRoutes.ts
|
||||
* - Server patterns from tests/server/server.test.ts
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach, spyOn, mock } from 'bun:test';
|
||||
import { logger } from '../../src/utils/logger.js';
|
||||
|
||||
// Mock middleware to avoid complex dependencies
|
||||
mock.module('../../src/services/worker/http/middleware.js', () => ({
|
||||
createMiddleware: () => [],
|
||||
requireLocalhost: (_req: any, _res: any, next: any) => next(),
|
||||
summarizeRequestBody: () => 'test body',
|
||||
}));
|
||||
|
||||
// Import after mocks
|
||||
import { Server } from '../../src/services/server/Server.js';
|
||||
import type { ServerOptions } from '../../src/services/server/Server.js';
|
||||
|
||||
// Suppress logger output during tests
|
||||
let loggerSpies: ReturnType<typeof spyOn>[] = [];
|
||||
|
||||
describe('Hook Execution E2E', () => {
|
||||
let server: Server;
|
||||
let testPort: number;
|
||||
let mockOptions: ServerOptions;
|
||||
|
||||
beforeEach(() => {
|
||||
loggerSpies = [
|
||||
spyOn(logger, 'info').mockImplementation(() => {}),
|
||||
spyOn(logger, 'debug').mockImplementation(() => {}),
|
||||
spyOn(logger, 'warn').mockImplementation(() => {}),
|
||||
spyOn(logger, 'error').mockImplementation(() => {}),
|
||||
];
|
||||
|
||||
mockOptions = {
|
||||
getInitializationComplete: () => true,
|
||||
getMcpReady: () => true,
|
||||
onShutdown: mock(() => Promise.resolve()),
|
||||
onRestart: mock(() => Promise.resolve()),
|
||||
workerPath: '/test/worker-service.cjs',
|
||||
getAiStatus: () => ({
|
||||
provider: 'claude',
|
||||
authMethod: 'cli',
|
||||
lastInteraction: null,
|
||||
}),
|
||||
};
|
||||
|
||||
testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
loggerSpies.forEach(spy => spy.mockRestore());
|
||||
|
||||
if (server && server.getHttpServer()) {
|
||||
try {
|
||||
await server.close();
|
||||
} catch {
|
||||
// Ignore errors on cleanup
|
||||
}
|
||||
}
|
||||
mock.restore();
|
||||
});
|
||||
|
||||
describe('health and readiness endpoints', () => {
|
||||
it('should return 200 with status ok from /api/health', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/health`);
|
||||
expect(response.status).toBe(200);
|
||||
|
||||
const body = await response.json();
|
||||
expect(body.status).toBe('ok');
|
||||
expect(body.initialized).toBe(true);
|
||||
expect(body.mcpReady).toBe(true);
|
||||
expect(body.platform).toBeDefined();
|
||||
expect(typeof body.pid).toBe('number');
|
||||
});
|
||||
|
||||
it('should return 200 with status ready from /api/readiness when initialized', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/readiness`);
|
||||
expect(response.status).toBe(200);
|
||||
|
||||
const body = await response.json();
|
||||
expect(body.status).toBe('ready');
|
||||
});
|
||||
|
||||
it('should return 503 from /api/readiness when not initialized', async () => {
|
||||
const uninitializedOptions: ServerOptions = {
|
||||
getInitializationComplete: () => false,
|
||||
getMcpReady: () => false,
|
||||
onShutdown: mock(() => Promise.resolve()),
|
||||
onRestart: mock(() => Promise.resolve()),
|
||||
workerPath: '/test/worker-service.cjs',
|
||||
getAiStatus: () => ({ provider: 'claude', authMethod: 'cli', lastInteraction: null }),
|
||||
};
|
||||
|
||||
server = new Server(uninitializedOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/readiness`);
|
||||
expect(response.status).toBe(503);
|
||||
|
||||
const body = await response.json();
|
||||
expect(body.status).toBe('initializing');
|
||||
expect(body.message).toBeDefined();
|
||||
});
|
||||
|
||||
it('should return version from /api/version', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/version`);
|
||||
expect(response.status).toBe(200);
|
||||
|
||||
const body = await response.json();
|
||||
expect(body.version).toBeDefined();
|
||||
expect(typeof body.version).toBe('string');
|
||||
});
|
||||
});
|
||||
|
||||
describe('server lifecycle', () => {
|
||||
it('should start and stop cleanly', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const httpServer = server.getHttpServer();
|
||||
expect(httpServer).not.toBeNull();
|
||||
expect(httpServer!.listening).toBe(true);
|
||||
|
||||
// Verify health endpoint works
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/health`);
|
||||
expect(response.status).toBe(200);
|
||||
|
||||
// Close server
|
||||
try {
|
||||
await server.close();
|
||||
} catch (e: any) {
|
||||
if (e.code !== 'ERR_SERVER_NOT_RUNNING') {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
const httpServerAfter = server.getHttpServer();
|
||||
if (httpServerAfter) {
|
||||
expect(httpServerAfter.listening).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
it('should reflect initialization state changes dynamically', async () => {
|
||||
let isInitialized = false;
|
||||
const dynamicOptions: ServerOptions = {
|
||||
getInitializationComplete: () => isInitialized,
|
||||
getMcpReady: () => true,
|
||||
onShutdown: mock(() => Promise.resolve()),
|
||||
onRestart: mock(() => Promise.resolve()),
|
||||
workerPath: '/test/worker-service.cjs',
|
||||
getAiStatus: () => ({ provider: 'claude', authMethod: 'cli', lastInteraction: null }),
|
||||
};
|
||||
|
||||
server = new Server(dynamicOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
// Check when not initialized
|
||||
let response = await fetch(`http://127.0.0.1:${testPort}/api/health`);
|
||||
let body = await response.json();
|
||||
expect(body.initialized).toBe(false);
|
||||
|
||||
// Change state
|
||||
isInitialized = true;
|
||||
|
||||
// Check when initialized
|
||||
response = await fetch(`http://127.0.0.1:${testPort}/api/health`);
|
||||
body = await response.json();
|
||||
expect(body.initialized).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('route handling', () => {
|
||||
it('should return 404 for unknown routes after finalizeRoutes', async () => {
|
||||
server = new Server(mockOptions);
|
||||
server.finalizeRoutes();
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/nonexistent`);
|
||||
expect(response.status).toBe(404);
|
||||
|
||||
const body = await response.json();
|
||||
expect(body.error).toBe('NotFound');
|
||||
});
|
||||
|
||||
it('should accept JSON content type for POST requests', async () => {
|
||||
server = new Server(mockOptions);
|
||||
server.finalizeRoutes();
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
// Even though this endpoint doesn't exist, verify JSON handling
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/test-json`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ test: 'data' })
|
||||
});
|
||||
|
||||
// Should get 404 (not found), not 400 (bad request due to JSON parsing)
|
||||
expect(response.status).toBe(404);
|
||||
});
|
||||
});
|
||||
|
||||
describe('privacy tag handling simulation', () => {
|
||||
it('should demonstrate privacy skip flow for entirely private prompt', async () => {
|
||||
// This test simulates what the session init endpoint does
|
||||
// with private prompts, without needing the full route handler
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
// Import tag stripping utility
|
||||
const { stripMemoryTagsFromPrompt } = await import('../../src/utils/tag-stripping.js');
|
||||
|
||||
// Simulate the flow
|
||||
const privatePrompt = '<private>secret command</private>';
|
||||
const cleanedPrompt = stripMemoryTagsFromPrompt(privatePrompt);
|
||||
|
||||
// Verify privacy check would skip this prompt
|
||||
const shouldSkip = !cleanedPrompt || cleanedPrompt.trim() === '';
|
||||
expect(shouldSkip).toBe(true);
|
||||
});
|
||||
|
||||
it('should demonstrate partial privacy for mixed prompts', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const { stripMemoryTagsFromPrompt } = await import('../../src/utils/tag-stripping.js');
|
||||
|
||||
const mixedPrompt = '<private>my password is secret123</private> Help me write a function';
|
||||
const cleanedPrompt = stripMemoryTagsFromPrompt(mixedPrompt);
|
||||
|
||||
// Should not skip - has public content
|
||||
const shouldSkip = !cleanedPrompt || cleanedPrompt.trim() === '';
|
||||
expect(shouldSkip).toBe(false);
|
||||
expect(cleanedPrompt.trim()).toBe('Help me write a function');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,402 @@
|
||||
/**
|
||||
* Worker API Endpoints Integration Tests
|
||||
*
|
||||
* Tests all REST API endpoints with real HTTP and database.
|
||||
* Uses real Server instance with in-memory database.
|
||||
*
|
||||
* Sources:
|
||||
* - Server patterns from tests/server/server.test.ts
|
||||
* - Session routes from src/services/worker/http/routes/SessionRoutes.ts
|
||||
* - Search routes from src/services/worker/http/routes/SearchRoutes.ts
|
||||
*/
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach, spyOn, mock } from 'bun:test';
|
||||
import { logger } from '../../src/utils/logger.js';
|
||||
|
||||
// Mock middleware to avoid complex dependencies
|
||||
mock.module('../../src/services/worker/http/middleware.js', () => ({
|
||||
createMiddleware: () => [],
|
||||
requireLocalhost: (_req: any, _res: any, next: any) => next(),
|
||||
summarizeRequestBody: () => 'test body',
|
||||
}));
|
||||
|
||||
// Import after mocks
|
||||
import { Server } from '../../src/services/server/Server.js';
|
||||
import type { ServerOptions } from '../../src/services/server/Server.js';
|
||||
|
||||
// Suppress logger output during tests
|
||||
let loggerSpies: ReturnType<typeof spyOn>[] = [];
|
||||
|
||||
describe('Worker API Endpoints Integration', () => {
|
||||
let server: Server;
|
||||
let testPort: number;
|
||||
let mockOptions: ServerOptions;
|
||||
|
||||
beforeEach(() => {
|
||||
loggerSpies = [
|
||||
spyOn(logger, 'info').mockImplementation(() => {}),
|
||||
spyOn(logger, 'debug').mockImplementation(() => {}),
|
||||
spyOn(logger, 'warn').mockImplementation(() => {}),
|
||||
spyOn(logger, 'error').mockImplementation(() => {}),
|
||||
];
|
||||
|
||||
mockOptions = {
|
||||
getInitializationComplete: () => true,
|
||||
getMcpReady: () => true,
|
||||
onShutdown: mock(() => Promise.resolve()),
|
||||
onRestart: mock(() => Promise.resolve()),
|
||||
workerPath: '/test/worker-service.cjs',
|
||||
getAiStatus: () => ({
|
||||
provider: 'claude',
|
||||
authMethod: 'cli',
|
||||
lastInteraction: null,
|
||||
}),
|
||||
};
|
||||
|
||||
testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
loggerSpies.forEach(spy => spy.mockRestore());
|
||||
|
||||
if (server && server.getHttpServer()) {
|
||||
try {
|
||||
await server.close();
|
||||
} catch {
|
||||
// Ignore cleanup errors
|
||||
}
|
||||
}
|
||||
mock.restore();
|
||||
});
|
||||
|
||||
describe('Health/Readiness/Version Endpoints', () => {
|
||||
describe('GET /api/health', () => {
|
||||
it('should return status, initialized, mcpReady, platform, pid', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/health`);
|
||||
expect(response.status).toBe(200);
|
||||
|
||||
const body = await response.json();
|
||||
expect(body).toHaveProperty('status', 'ok');
|
||||
expect(body).toHaveProperty('initialized', true);
|
||||
expect(body).toHaveProperty('mcpReady', true);
|
||||
expect(body).toHaveProperty('platform');
|
||||
expect(body).toHaveProperty('pid');
|
||||
expect(typeof body.platform).toBe('string');
|
||||
expect(typeof body.pid).toBe('number');
|
||||
});
|
||||
|
||||
it('should reflect uninitialized state', async () => {
|
||||
const uninitOptions: ServerOptions = {
|
||||
getInitializationComplete: () => false,
|
||||
getMcpReady: () => false,
|
||||
onShutdown: mock(() => Promise.resolve()),
|
||||
onRestart: mock(() => Promise.resolve()),
|
||||
workerPath: '/test/worker-service.cjs',
|
||||
getAiStatus: () => ({ provider: 'claude', authMethod: 'cli', lastInteraction: null }),
|
||||
};
|
||||
|
||||
server = new Server(uninitOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/health`);
|
||||
const body = await response.json();
|
||||
|
||||
expect(body.status).toBe('ok'); // Health always returns ok
|
||||
expect(body.initialized).toBe(false);
|
||||
expect(body.mcpReady).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('GET /api/readiness', () => {
|
||||
it('should return 200 with status ready when initialized', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/readiness`);
|
||||
expect(response.status).toBe(200);
|
||||
|
||||
const body = await response.json();
|
||||
expect(body.status).toBe('ready');
|
||||
expect(body.mcpReady).toBe(true);
|
||||
});
|
||||
|
||||
it('should return 503 with status initializing when not ready', async () => {
|
||||
const uninitOptions: ServerOptions = {
|
||||
getInitializationComplete: () => false,
|
||||
getMcpReady: () => false,
|
||||
onShutdown: mock(() => Promise.resolve()),
|
||||
onRestart: mock(() => Promise.resolve()),
|
||||
workerPath: '/test/worker-service.cjs',
|
||||
getAiStatus: () => ({ provider: 'claude', authMethod: 'cli', lastInteraction: null }),
|
||||
};
|
||||
|
||||
server = new Server(uninitOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/readiness`);
|
||||
expect(response.status).toBe(503);
|
||||
|
||||
const body = await response.json();
|
||||
expect(body.status).toBe('initializing');
|
||||
expect(body.message).toContain('initializing');
|
||||
});
|
||||
});
|
||||
|
||||
describe('GET /api/version', () => {
|
||||
it('should return version string', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/version`);
|
||||
expect(response.status).toBe(200);
|
||||
|
||||
const body = await response.json();
|
||||
expect(body).toHaveProperty('version');
|
||||
expect(typeof body.version).toBe('string');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Error Handling', () => {
|
||||
describe('404 Not Found', () => {
|
||||
it('should return 404 for unknown GET routes', async () => {
|
||||
server = new Server(mockOptions);
|
||||
server.finalizeRoutes();
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/unknown-endpoint`);
|
||||
expect(response.status).toBe(404);
|
||||
|
||||
const body = await response.json();
|
||||
expect(body.error).toBe('NotFound');
|
||||
});
|
||||
|
||||
it('should return 404 for unknown POST routes', async () => {
|
||||
server = new Server(mockOptions);
|
||||
server.finalizeRoutes();
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/unknown-endpoint`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ test: 'data' })
|
||||
});
|
||||
expect(response.status).toBe(404);
|
||||
});
|
||||
|
||||
it('should return 404 for nested unknown routes', async () => {
|
||||
server = new Server(mockOptions);
|
||||
server.finalizeRoutes();
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/search/nonexistent/nested`);
|
||||
expect(response.status).toBe(404);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Method handling', () => {
|
||||
it('should handle OPTIONS requests', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/health`, {
|
||||
method: 'OPTIONS'
|
||||
});
|
||||
// OPTIONS should either return 200 or 204 (CORS preflight)
|
||||
expect([200, 204]).toContain(response.status);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Content-Type Handling', () => {
|
||||
it('should accept application/json content type', async () => {
|
||||
server = new Server(mockOptions);
|
||||
server.finalizeRoutes();
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/nonexistent`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ key: 'value' })
|
||||
});
|
||||
|
||||
// Should get 404 (route not found), not a content-type error
|
||||
expect(response.status).toBe(404);
|
||||
});
|
||||
|
||||
it('should return JSON responses with correct content type', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/health`);
|
||||
const contentType = response.headers.get('content-type');
|
||||
|
||||
expect(contentType).toContain('application/json');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Server State Management', () => {
|
||||
it('should track initialization state dynamically', async () => {
|
||||
let initialized = false;
|
||||
const dynamicOptions: ServerOptions = {
|
||||
getInitializationComplete: () => initialized,
|
||||
getMcpReady: () => true,
|
||||
onShutdown: mock(() => Promise.resolve()),
|
||||
onRestart: mock(() => Promise.resolve()),
|
||||
workerPath: '/test/worker-service.cjs',
|
||||
getAiStatus: () => ({ provider: 'claude', authMethod: 'cli', lastInteraction: null }),
|
||||
};
|
||||
|
||||
server = new Server(dynamicOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
// Check uninitialized
|
||||
let response = await fetch(`http://127.0.0.1:${testPort}/api/readiness`);
|
||||
expect(response.status).toBe(503);
|
||||
|
||||
// Initialize
|
||||
initialized = true;
|
||||
|
||||
// Check initialized
|
||||
response = await fetch(`http://127.0.0.1:${testPort}/api/readiness`);
|
||||
expect(response.status).toBe(200);
|
||||
});
|
||||
|
||||
it('should track MCP ready state dynamically', async () => {
|
||||
let mcpReady = false;
|
||||
const dynamicOptions: ServerOptions = {
|
||||
getInitializationComplete: () => true,
|
||||
getMcpReady: () => mcpReady,
|
||||
onShutdown: mock(() => Promise.resolve()),
|
||||
onRestart: mock(() => Promise.resolve()),
|
||||
workerPath: '/test/worker-service.cjs',
|
||||
getAiStatus: () => ({ provider: 'claude', authMethod: 'cli', lastInteraction: null }),
|
||||
};
|
||||
|
||||
server = new Server(dynamicOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
// Check MCP not ready
|
||||
let response = await fetch(`http://127.0.0.1:${testPort}/api/health`);
|
||||
let body = await response.json();
|
||||
expect(body.mcpReady).toBe(false);
|
||||
|
||||
// Set MCP ready
|
||||
mcpReady = true;
|
||||
|
||||
// Check MCP ready
|
||||
response = await fetch(`http://127.0.0.1:${testPort}/api/health`);
|
||||
body = await response.json();
|
||||
expect(body.mcpReady).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Server Lifecycle', () => {
|
||||
it('should start listening on specified port', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const httpServer = server.getHttpServer();
|
||||
expect(httpServer).not.toBeNull();
|
||||
expect(httpServer!.listening).toBe(true);
|
||||
});
|
||||
|
||||
it('should close gracefully', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
// Verify it's running
|
||||
const response = await fetch(`http://127.0.0.1:${testPort}/api/health`);
|
||||
expect(response.status).toBe(200);
|
||||
|
||||
// Close
|
||||
try {
|
||||
await server.close();
|
||||
} catch (e: any) {
|
||||
if (e.code !== 'ERR_SERVER_NOT_RUNNING') throw e;
|
||||
}
|
||||
|
||||
// Verify closed
|
||||
const httpServer = server.getHttpServer();
|
||||
if (httpServer) {
|
||||
expect(httpServer.listening).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
it('should handle port conflicts', async () => {
|
||||
server = new Server(mockOptions);
|
||||
const server2 = new Server(mockOptions);
|
||||
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
// Second server should fail on same port
|
||||
await expect(server2.listen(testPort, '127.0.0.1')).rejects.toThrow();
|
||||
|
||||
// Clean up second server if it has a reference
|
||||
const httpServer2 = server2.getHttpServer();
|
||||
if (httpServer2) {
|
||||
expect(httpServer2.listening).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
it('should allow restart on same port after close', async () => {
|
||||
server = new Server(mockOptions);
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
// Close first server
|
||||
try {
|
||||
await server.close();
|
||||
} catch (e: any) {
|
||||
if (e.code !== 'ERR_SERVER_NOT_RUNNING') throw e;
|
||||
}
|
||||
|
||||
// Wait for port to be released
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
|
||||
// Start second server on same port
|
||||
const server2 = new Server(mockOptions);
|
||||
await server2.listen(testPort, '127.0.0.1');
|
||||
|
||||
expect(server2.getHttpServer()!.listening).toBe(true);
|
||||
|
||||
// Clean up
|
||||
try {
|
||||
await server2.close();
|
||||
} catch {
|
||||
// Ignore cleanup errors
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('Route Registration', () => {
|
||||
it('should register route handlers', () => {
|
||||
server = new Server(mockOptions);
|
||||
|
||||
const setupRoutesMock = mock(() => {});
|
||||
const mockRouteHandler = {
|
||||
setupRoutes: setupRoutesMock,
|
||||
};
|
||||
|
||||
server.registerRoutes(mockRouteHandler);
|
||||
|
||||
expect(setupRoutesMock).toHaveBeenCalledTimes(1);
|
||||
expect(setupRoutesMock).toHaveBeenCalledWith(server.app);
|
||||
});
|
||||
|
||||
it('should register multiple route handlers', () => {
|
||||
server = new Server(mockOptions);
|
||||
|
||||
const handler1Mock = mock(() => {});
|
||||
const handler2Mock = mock(() => {});
|
||||
|
||||
server.registerRoutes({ setupRoutes: handler1Mock });
|
||||
server.registerRoutes({ setupRoutes: handler2Mock });
|
||||
|
||||
expect(handler1Mock).toHaveBeenCalledTimes(1);
|
||||
expect(handler2Mock).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user