wip: [01-stabilize] paused at task 1/1 - OCR Hallucination Immune logic via Semantic delta window and fret-isolation
This commit is contained in:
328
.agent/services/claude-mem/tests/server/error-handler.test.ts
Normal file
328
.agent/services/claude-mem/tests/server/error-handler.test.ts
Normal file
@@ -0,0 +1,328 @@
|
||||
/**
|
||||
* Tests for Express error handling middleware
|
||||
*
|
||||
* Mock Justification (~11% mock code):
|
||||
* - Logger spies: Suppress console output during tests (standard practice)
|
||||
* - Express req/res mocks: Required because Express middleware expects these
|
||||
* objects - testing the actual formatting and status code logic
|
||||
*
|
||||
* What's NOT mocked: AppError class, createErrorResponse function (tested directly)
|
||||
*/
|
||||
import { describe, it, expect, mock, beforeEach, afterEach, spyOn } from 'bun:test';
|
||||
import type { Request, Response, NextFunction } from 'express';
|
||||
import { logger } from '../../src/utils/logger.js';
|
||||
|
||||
import {
|
||||
AppError,
|
||||
createErrorResponse,
|
||||
errorHandler,
|
||||
notFoundHandler,
|
||||
} from '../../src/services/server/ErrorHandler.js';
|
||||
|
||||
// Spy on logger methods to suppress output during tests
|
||||
// Using spyOn instead of mock.module to avoid polluting global module cache
|
||||
let loggerSpies: ReturnType<typeof spyOn>[] = [];
|
||||
|
||||
describe('ErrorHandler', () => {
|
||||
beforeEach(() => {
|
||||
loggerSpies = [
|
||||
spyOn(logger, 'info').mockImplementation(() => {}),
|
||||
spyOn(logger, 'debug').mockImplementation(() => {}),
|
||||
spyOn(logger, 'warn').mockImplementation(() => {}),
|
||||
spyOn(logger, 'error').mockImplementation(() => {}),
|
||||
];
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
loggerSpies.forEach(spy => spy.mockRestore());
|
||||
mock.restore();
|
||||
});
|
||||
|
||||
describe('AppError', () => {
|
||||
it('should extend Error', () => {
|
||||
const error = new AppError('Test error');
|
||||
expect(error).toBeInstanceOf(Error);
|
||||
expect(error).toBeInstanceOf(AppError);
|
||||
});
|
||||
|
||||
it('should set default statusCode to 500', () => {
|
||||
const error = new AppError('Test error');
|
||||
expect(error.statusCode).toBe(500);
|
||||
});
|
||||
|
||||
it('should set custom statusCode', () => {
|
||||
const error = new AppError('Not found', 404);
|
||||
expect(error.statusCode).toBe(404);
|
||||
});
|
||||
|
||||
it('should set error code when provided', () => {
|
||||
const error = new AppError('Invalid input', 400, 'INVALID_INPUT');
|
||||
expect(error.code).toBe('INVALID_INPUT');
|
||||
});
|
||||
|
||||
it('should set details when provided', () => {
|
||||
const details = { field: 'email', reason: 'invalid format' };
|
||||
const error = new AppError('Validation failed', 400, 'VALIDATION_ERROR', details);
|
||||
expect(error.details).toEqual(details);
|
||||
});
|
||||
|
||||
it('should set message correctly', () => {
|
||||
const error = new AppError('Something went wrong');
|
||||
expect(error.message).toBe('Something went wrong');
|
||||
});
|
||||
|
||||
it('should set name to AppError', () => {
|
||||
const error = new AppError('Test error');
|
||||
expect(error.name).toBe('AppError');
|
||||
});
|
||||
|
||||
it('should handle all parameters together', () => {
|
||||
const details = { userId: 123 };
|
||||
const error = new AppError('User not found', 404, 'USER_NOT_FOUND', details);
|
||||
|
||||
expect(error.message).toBe('User not found');
|
||||
expect(error.statusCode).toBe(404);
|
||||
expect(error.code).toBe('USER_NOT_FOUND');
|
||||
expect(error.details).toEqual(details);
|
||||
expect(error.name).toBe('AppError');
|
||||
});
|
||||
});
|
||||
|
||||
describe('createErrorResponse', () => {
|
||||
it('should create basic error response with error and message', () => {
|
||||
const response = createErrorResponse('Error', 'Something went wrong');
|
||||
|
||||
expect(response.error).toBe('Error');
|
||||
expect(response.message).toBe('Something went wrong');
|
||||
expect(response.code).toBeUndefined();
|
||||
expect(response.details).toBeUndefined();
|
||||
});
|
||||
|
||||
it('should include code when provided', () => {
|
||||
const response = createErrorResponse('ValidationError', 'Invalid input', 'INVALID_INPUT');
|
||||
|
||||
expect(response.error).toBe('ValidationError');
|
||||
expect(response.message).toBe('Invalid input');
|
||||
expect(response.code).toBe('INVALID_INPUT');
|
||||
expect(response.details).toBeUndefined();
|
||||
});
|
||||
|
||||
it('should include details when provided', () => {
|
||||
const details = { fields: ['email', 'password'] };
|
||||
const response = createErrorResponse('ValidationError', 'Multiple errors', 'VALIDATION_ERROR', details);
|
||||
|
||||
expect(response.error).toBe('ValidationError');
|
||||
expect(response.message).toBe('Multiple errors');
|
||||
expect(response.code).toBe('VALIDATION_ERROR');
|
||||
expect(response.details).toEqual(details);
|
||||
});
|
||||
|
||||
it('should not include code or details keys when not provided', () => {
|
||||
const response = createErrorResponse('Error', 'Basic error');
|
||||
|
||||
expect(Object.keys(response)).toEqual(['error', 'message']);
|
||||
});
|
||||
|
||||
it('should handle empty string code as falsy and exclude it', () => {
|
||||
const response = createErrorResponse('Error', 'Test', '');
|
||||
|
||||
// Empty string is falsy, so code should not be set
|
||||
expect(response.code).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe('errorHandler middleware', () => {
|
||||
let mockRequest: Partial<Request>;
|
||||
let mockResponse: Partial<Response>;
|
||||
let mockNext: NextFunction;
|
||||
let statusSpy: ReturnType<typeof mock>;
|
||||
let jsonSpy: ReturnType<typeof mock>;
|
||||
|
||||
beforeEach(() => {
|
||||
statusSpy = mock(() => mockResponse);
|
||||
jsonSpy = mock(() => mockResponse);
|
||||
|
||||
mockRequest = {
|
||||
method: 'GET',
|
||||
path: '/api/test',
|
||||
};
|
||||
|
||||
mockResponse = {
|
||||
status: statusSpy as unknown as Response['status'],
|
||||
json: jsonSpy as unknown as Response['json'],
|
||||
};
|
||||
|
||||
mockNext = mock(() => {});
|
||||
});
|
||||
|
||||
it('should handle AppError with custom status code', () => {
|
||||
const error = new AppError('Not found', 404, 'NOT_FOUND');
|
||||
|
||||
errorHandler(
|
||||
error,
|
||||
mockRequest as Request,
|
||||
mockResponse as Response,
|
||||
mockNext
|
||||
);
|
||||
|
||||
expect(statusSpy).toHaveBeenCalledWith(404);
|
||||
expect(jsonSpy).toHaveBeenCalled();
|
||||
|
||||
const responseBody = jsonSpy.mock.calls[0][0];
|
||||
expect(responseBody.error).toBe('AppError');
|
||||
expect(responseBody.message).toBe('Not found');
|
||||
expect(responseBody.code).toBe('NOT_FOUND');
|
||||
});
|
||||
|
||||
it('should handle AppError with details', () => {
|
||||
const details = { resourceId: 'abc123' };
|
||||
const error = new AppError('Resource not found', 404, 'RESOURCE_NOT_FOUND', details);
|
||||
|
||||
errorHandler(
|
||||
error,
|
||||
mockRequest as Request,
|
||||
mockResponse as Response,
|
||||
mockNext
|
||||
);
|
||||
|
||||
const responseBody = jsonSpy.mock.calls[0][0];
|
||||
expect(responseBody.details).toEqual(details);
|
||||
});
|
||||
|
||||
it('should handle generic Error with 500 status code', () => {
|
||||
const error = new Error('Something went wrong');
|
||||
|
||||
errorHandler(
|
||||
error,
|
||||
mockRequest as Request,
|
||||
mockResponse as Response,
|
||||
mockNext
|
||||
);
|
||||
|
||||
expect(statusSpy).toHaveBeenCalledWith(500);
|
||||
|
||||
const responseBody = jsonSpy.mock.calls[0][0];
|
||||
expect(responseBody.error).toBe('Error');
|
||||
expect(responseBody.message).toBe('Something went wrong');
|
||||
expect(responseBody.code).toBeUndefined();
|
||||
expect(responseBody.details).toBeUndefined();
|
||||
});
|
||||
|
||||
it('should not call next after handling error', () => {
|
||||
const error = new AppError('Test error', 400);
|
||||
|
||||
errorHandler(
|
||||
error,
|
||||
mockRequest as Request,
|
||||
mockResponse as Response,
|
||||
mockNext
|
||||
);
|
||||
|
||||
expect(mockNext).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should use error name in response', () => {
|
||||
const error = new TypeError('Invalid type');
|
||||
|
||||
errorHandler(
|
||||
error,
|
||||
mockRequest as Request,
|
||||
mockResponse as Response,
|
||||
mockNext
|
||||
);
|
||||
|
||||
const responseBody = jsonSpy.mock.calls[0][0];
|
||||
expect(responseBody.error).toBe('TypeError');
|
||||
});
|
||||
|
||||
it('should handle AppError with default 500 status', () => {
|
||||
const error = new AppError('Server error');
|
||||
|
||||
errorHandler(
|
||||
error,
|
||||
mockRequest as Request,
|
||||
mockResponse as Response,
|
||||
mockNext
|
||||
);
|
||||
|
||||
expect(statusSpy).toHaveBeenCalledWith(500);
|
||||
});
|
||||
});
|
||||
|
||||
describe('notFoundHandler', () => {
|
||||
let mockRequest: Partial<Request>;
|
||||
let mockResponse: Partial<Response>;
|
||||
let statusSpy: ReturnType<typeof mock>;
|
||||
let jsonSpy: ReturnType<typeof mock>;
|
||||
|
||||
beforeEach(() => {
|
||||
statusSpy = mock(() => mockResponse);
|
||||
jsonSpy = mock(() => mockResponse);
|
||||
|
||||
mockResponse = {
|
||||
status: statusSpy as unknown as Response['status'],
|
||||
json: jsonSpy as unknown as Response['json'],
|
||||
};
|
||||
});
|
||||
|
||||
it('should return 404 status', () => {
|
||||
mockRequest = {
|
||||
method: 'GET',
|
||||
path: '/api/unknown',
|
||||
};
|
||||
|
||||
notFoundHandler(mockRequest as Request, mockResponse as Response);
|
||||
|
||||
expect(statusSpy).toHaveBeenCalledWith(404);
|
||||
});
|
||||
|
||||
it('should include method and path in message', () => {
|
||||
mockRequest = {
|
||||
method: 'POST',
|
||||
path: '/api/users',
|
||||
};
|
||||
|
||||
notFoundHandler(mockRequest as Request, mockResponse as Response);
|
||||
|
||||
const responseBody = jsonSpy.mock.calls[0][0];
|
||||
expect(responseBody.error).toBe('NotFound');
|
||||
expect(responseBody.message).toBe('Cannot POST /api/users');
|
||||
});
|
||||
|
||||
it('should handle DELETE method', () => {
|
||||
mockRequest = {
|
||||
method: 'DELETE',
|
||||
path: '/api/items/123',
|
||||
};
|
||||
|
||||
notFoundHandler(mockRequest as Request, mockResponse as Response);
|
||||
|
||||
const responseBody = jsonSpy.mock.calls[0][0];
|
||||
expect(responseBody.message).toBe('Cannot DELETE /api/items/123');
|
||||
});
|
||||
|
||||
it('should handle PUT method', () => {
|
||||
mockRequest = {
|
||||
method: 'PUT',
|
||||
path: '/api/config',
|
||||
};
|
||||
|
||||
notFoundHandler(mockRequest as Request, mockResponse as Response);
|
||||
|
||||
const responseBody = jsonSpy.mock.calls[0][0];
|
||||
expect(responseBody.message).toBe('Cannot PUT /api/config');
|
||||
});
|
||||
|
||||
it('should return structured error response', () => {
|
||||
mockRequest = {
|
||||
method: 'GET',
|
||||
path: '/missing',
|
||||
};
|
||||
|
||||
notFoundHandler(mockRequest as Request, mockResponse as Response);
|
||||
|
||||
const responseBody = jsonSpy.mock.calls[0][0];
|
||||
expect(Object.keys(responseBody)).toEqual(['error', 'message']);
|
||||
});
|
||||
});
|
||||
});
|
||||
389
.agent/services/claude-mem/tests/server/server.test.ts
Normal file
389
.agent/services/claude-mem/tests/server/server.test.ts
Normal file
@@ -0,0 +1,389 @@
|
||||
import { describe, it, expect, mock, beforeEach, afterEach, spyOn } 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 { RouteHandler, ServerOptions } from '../../src/services/server/Server.js';
|
||||
|
||||
// Spy on logger methods to suppress output during tests
|
||||
let loggerSpies: ReturnType<typeof spyOn>[] = [];
|
||||
|
||||
describe('Server', () => {
|
||||
let server: Server;
|
||||
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,
|
||||
}),
|
||||
};
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
loggerSpies.forEach(spy => spy.mockRestore());
|
||||
// Clean up server if created and still has an active http server
|
||||
if (server && server.getHttpServer()) {
|
||||
try {
|
||||
await server.close();
|
||||
} catch {
|
||||
// Ignore errors on cleanup
|
||||
}
|
||||
}
|
||||
mock.restore();
|
||||
});
|
||||
|
||||
describe('constructor', () => {
|
||||
it('should create Express app', () => {
|
||||
server = new Server(mockOptions);
|
||||
|
||||
expect(server.app).toBeDefined();
|
||||
expect(typeof server.app.get).toBe('function');
|
||||
expect(typeof server.app.post).toBe('function');
|
||||
expect(typeof server.app.use).toBe('function');
|
||||
});
|
||||
|
||||
it('should expose app as readonly property', () => {
|
||||
server = new Server(mockOptions);
|
||||
|
||||
// App should be accessible
|
||||
expect(server.app).toBeDefined();
|
||||
|
||||
// App should be an Express application
|
||||
expect(typeof server.app.listen).toBe('function');
|
||||
});
|
||||
});
|
||||
|
||||
describe('listen', () => {
|
||||
it('should start server on specified port', async () => {
|
||||
server = new Server(mockOptions);
|
||||
|
||||
// Use a random high port to avoid conflicts
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
// Server should now be listening
|
||||
const httpServer = server.getHttpServer();
|
||||
expect(httpServer).not.toBeNull();
|
||||
expect(httpServer!.listening).toBe(true);
|
||||
});
|
||||
|
||||
it('should reject if port is already in use', async () => {
|
||||
server = new Server(mockOptions);
|
||||
const server2 = new Server(mockOptions);
|
||||
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
// Start first server
|
||||
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();
|
||||
|
||||
// The server object was created but not successfully listening
|
||||
const httpServer = server2.getHttpServer();
|
||||
if (httpServer) {
|
||||
expect(httpServer.listening).toBe(false);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('close', () => {
|
||||
it('should stop server from listening after close', async () => {
|
||||
server = new Server(mockOptions);
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
// Server should exist and be listening
|
||||
const httpServerBefore = server.getHttpServer();
|
||||
expect(httpServerBefore).not.toBeNull();
|
||||
expect(httpServerBefore!.listening).toBe(true);
|
||||
|
||||
// Close the server - may throw ERR_SERVER_NOT_RUNNING on some platforms
|
||||
// because closeAllConnections() might immediately close the server
|
||||
try {
|
||||
await server.close();
|
||||
} catch (e: any) {
|
||||
// ERR_SERVER_NOT_RUNNING is acceptable - closeAllConnections() already closed it
|
||||
if (e.code !== 'ERR_SERVER_NOT_RUNNING') {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
// The server should no longer be listening (even if ref is not null due to early throw)
|
||||
const httpServerAfter = server.getHttpServer();
|
||||
if (httpServerAfter) {
|
||||
expect(httpServerAfter.listening).toBe(false);
|
||||
}
|
||||
});
|
||||
|
||||
it('should handle close when server not started', async () => {
|
||||
server = new Server(mockOptions);
|
||||
|
||||
// Should not throw when closing unstarted server
|
||||
await expect(server.close()).resolves.toBeUndefined();
|
||||
});
|
||||
|
||||
it('should allow starting a new server on same port after close', async () => {
|
||||
server = new Server(mockOptions);
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
// Close the server
|
||||
try {
|
||||
await server.close();
|
||||
} catch (e: any) {
|
||||
// ERR_SERVER_NOT_RUNNING is acceptable
|
||||
if (e.code !== 'ERR_SERVER_NOT_RUNNING') {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
// Small delay to ensure port is released
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
|
||||
// Should be able to listen again on same port with a new server
|
||||
const server2 = new Server(mockOptions);
|
||||
await server2.listen(testPort, '127.0.0.1');
|
||||
|
||||
expect(server2.getHttpServer()!.listening).toBe(true);
|
||||
|
||||
// Clean up server2
|
||||
try {
|
||||
await server2.close();
|
||||
} catch {
|
||||
// Ignore cleanup errors
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('getHttpServer', () => {
|
||||
it('should return null before listen', () => {
|
||||
server = new Server(mockOptions);
|
||||
|
||||
expect(server.getHttpServer()).toBeNull();
|
||||
});
|
||||
|
||||
it('should return http.Server after listen', async () => {
|
||||
server = new Server(mockOptions);
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
await server.listen(testPort, '127.0.0.1');
|
||||
|
||||
const httpServer = server.getHttpServer();
|
||||
expect(httpServer).not.toBeNull();
|
||||
expect(httpServer!.listening).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('registerRoutes', () => {
|
||||
it('should call setupRoutes on route handler', () => {
|
||||
server = new Server(mockOptions);
|
||||
|
||||
const setupRoutesMock = mock(() => {});
|
||||
const mockRouteHandler: RouteHandler = {
|
||||
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(() => {});
|
||||
|
||||
const handler1: RouteHandler = { setupRoutes: handler1Mock };
|
||||
const handler2: RouteHandler = { setupRoutes: handler2Mock };
|
||||
|
||||
server.registerRoutes(handler1);
|
||||
server.registerRoutes(handler2);
|
||||
|
||||
expect(handler1Mock).toHaveBeenCalledTimes(1);
|
||||
expect(handler2Mock).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('finalizeRoutes', () => {
|
||||
it('should not throw when called', () => {
|
||||
server = new Server(mockOptions);
|
||||
|
||||
expect(() => server.finalizeRoutes()).not.toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe('health endpoint', () => {
|
||||
it('should return 200 with status ok', async () => {
|
||||
server = new Server(mockOptions);
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
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');
|
||||
});
|
||||
|
||||
it('should include initialization status', async () => {
|
||||
server = new Server(mockOptions);
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
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.initialized).toBe(true);
|
||||
expect(body.mcpReady).toBe(true);
|
||||
});
|
||||
|
||||
it('should reflect initialization state changes', 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);
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
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);
|
||||
});
|
||||
|
||||
it('should include platform and pid', async () => {
|
||||
server = new Server(mockOptions);
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
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.platform).toBeDefined();
|
||||
expect(body.pid).toBeDefined();
|
||||
expect(typeof body.pid).toBe('number');
|
||||
});
|
||||
});
|
||||
|
||||
describe('readiness endpoint', () => {
|
||||
it('should return 200 when initialized', async () => {
|
||||
server = new Server(mockOptions);
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
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 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);
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
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();
|
||||
});
|
||||
});
|
||||
|
||||
describe('version endpoint', () => {
|
||||
it('should return 200 with version', async () => {
|
||||
server = new Server(mockOptions);
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
|
||||
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('404 handling', () => {
|
||||
it('should return 404 for unknown routes after finalizeRoutes', async () => {
|
||||
server = new Server(mockOptions);
|
||||
server.finalizeRoutes();
|
||||
|
||||
const testPort = 40000 + Math.floor(Math.random() * 10000);
|
||||
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');
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user