onbuzz 3.3.0

package/src/interfaces/terminal/__tests__/smoke/imports.test.js

@@ -0,0 +1,332 @@
+/**
+ * Terminal UI Infrastructure - Smoke Tests
+ * Verifies that all Phase 1 modules can be imported and instantiated
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+describe('Terminal UI Infrastructure - Imports', () => {
+  test('constants module exports all required constants', async () => {
+    const constants = await import('../../config/constants.js');
+
+    // Verify major constant groups exist
+    expect(constants.UI_DIMENSIONS).toBeDefined();
+    expect(constants.MESSAGE_CONFIG).toBeDefined();
+    expect(constants.PAGINATION).toBeDefined();
+    expect(constants.TIMING).toBeDefined();
+    expect(constants.NETWORK).toBeDefined();
+    expect(constants.CONNECTION_STATE).toBeDefined();
+    expect(constants.AGENT_MODE).toBeDefined();
+    expect(constants.WS_MESSAGE_TYPE).toBeDefined();
+    expect(constants.API_ENDPOINTS).toBeDefined();
+    expect(constants.COMMANDS).toBeDefined();
+
+    // Verify some key values
+    expect(constants.NETWORK.DEFAULT_HOST).toBe('localhost');
+    expect(constants.NETWORK.DEFAULT_PORT).toBe(8080);
+    expect(constants.CONNECTION_STATE.DISCONNECTED).toBe('disconnected');
+    expect(constants.CONNECTION_STATE.CONNECTED).toBe('connected');
+  });
+
+  test('WebSocketManager class can be imported', async () => {
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    expect(WebSocketManager).toBeDefined();
+    expect(typeof WebSocketManager).toBe('function');
+
+    // Verify it's a class
+    const instance = new WebSocketManager('localhost', 8080);
+    expect(instance).toBeDefined();
+    expect(instance.host).toBe('localhost');
+    expect(instance.port).toBe(8080);
+    expect(instance.url).toBe('ws://localhost:8080');
+  });
+
+  test('SessionManager class can be imported', async () => {
+    const { SessionManager } = await import('../../api/session.js');
+
+    expect(SessionManager).toBeDefined();
+    expect(typeof SessionManager).toBe('function');
+
+    // Verify it's a class
+    const instance = new SessionManager('localhost', 8080);
+    expect(instance).toBeDefined();
+    expect(instance.host).toBe('localhost');
+    expect(instance.port).toBe(8080);
+    expect(instance.baseUrl).toBe('http://localhost:8080');
+  });
+
+  test('MessageRouter class can be imported', async () => {
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    expect(MessageRouter).toBeDefined();
+    expect(typeof MessageRouter).toBe('function');
+
+    // Verify it's a class (requires WebSocketManager instance)
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const instance = new MessageRouter(wsManager);
+    expect(instance).toBeDefined();
+    expect(instance.ws).toBe(wsManager);
+  });
+
+  test('MessageRouter middleware helpers can be imported', async () => {
+    const {
+      loggingMiddleware,
+      filterMiddleware,
+      transformMiddleware,
+      timestampMiddleware,
+      validationMiddleware,
+    } = await import('../../api/messageRouter.js');
+
+    expect(typeof loggingMiddleware).toBe('function');
+    expect(typeof filterMiddleware).toBe('function');
+    expect(typeof transformMiddleware).toBe('function');
+    expect(typeof timestampMiddleware).toBe('function');
+    expect(typeof validationMiddleware).toBe('function');
+  });
+
+  test('useConnection hook can be imported', async () => {
+    const { useConnection, useConnectionStatus } = await import('../../state/useConnection.js');
+
+    expect(useConnection).toBeDefined();
+    expect(typeof useConnection).toBe('function');
+    expect(useConnectionStatus).toBeDefined();
+    expect(typeof useConnectionStatus).toBe('function');
+  });
+});
+
+describe('Terminal UI Infrastructure - Basic Functionality', () => {
+  test('WebSocketManager initializes with correct state', async () => {
+    const { WebSocketManager } = await import('../../api/websocket.js');
+    const { CONNECTION_STATE } = await import('../../config/constants.js');
+
+    const wsManager = new WebSocketManager('test-host', 9090);
+
+    expect(wsManager.state).toBe(CONNECTION_STATE.DISCONNECTED);
+    expect(wsManager.sessionId).toBe(null);
+    expect(wsManager.messageQueue).toEqual([]);
+    expect(wsManager.reconnectAttempts).toBe(0);
+    expect(wsManager.shouldReconnect).toBe(true);
+  });
+
+  test('SessionManager initializes with correct state', async () => {
+    const { SessionManager } = await import('../../api/session.js');
+
+    const sessionManager = new SessionManager('test-host', 9090);
+
+    expect(sessionManager.sessionId).toBe(null);
+    expect(sessionManager.projectDir).toBe(null);
+    expect(sessionManager.loxiaApiKey).toBe(null);
+    expect(sessionManager.vendorKeys).toEqual({});
+    expect(sessionManager.isValid()).toBe(false);
+  });
+
+  test('MessageRouter initializes with default handlers', async () => {
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+    const { WS_MESSAGE_TYPE } = await import('../../config/constants.js');
+
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const router = new MessageRouter(wsManager);
+
+    // Verify default handlers are registered
+    expect(router.hasHandler(WS_MESSAGE_TYPE.MESSAGE_ADDED)).toBe(true);
+    expect(router.hasHandler(WS_MESSAGE_TYPE.AGENT_MODE_CHANGED)).toBe(true);
+    expect(router.hasHandler(WS_MESSAGE_TYPE.EXECUTION_STOPPED)).toBe(true);
+    expect(router.hasHandler(WS_MESSAGE_TYPE.COMPACTION_EVENT)).toBe(true);
+    expect(router.hasHandler(WS_MESSAGE_TYPE.IMAGE_RESULT)).toBe(true);
+  });
+
+  test('MessageRouter middleware can be added and removed', async () => {
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const router = new MessageRouter(wsManager);
+
+    const testMiddleware = (msg) => msg;
+
+    expect(router.middleware.length).toBeGreaterThanOrEqual(0);
+
+    router.use(testMiddleware);
+    const middlewareCount = router.middleware.length;
+    expect(middlewareCount).toBeGreaterThan(0);
+
+    router.removeMiddleware(testMiddleware);
+    expect(router.middleware.length).toBe(middlewareCount - 1);
+  });
+
+  test('SessionManager helper methods work', async () => {
+    const { SessionManager } = await import('../../api/session.js');
+
+    const sessionManager = new SessionManager('localhost', 8080);
+
+    // Test getter methods
+    expect(sessionManager.getSessionId()).toBe(null);
+    expect(sessionManager.getProjectDir()).toBe(null);
+    expect(sessionManager.isValid()).toBe(false);
+
+    // Test session info
+    const info = sessionManager.getSessionInfo();
+    expect(info).toHaveProperty('sessionId');
+    expect(info).toHaveProperty('projectDir');
+    expect(info).toHaveProperty('hasLoxiaKey');
+    expect(info).toHaveProperty('vendorKeysCount');
+  });
+
+  test('WebSocketManager helper methods work', async () => {
+    const { WebSocketManager } = await import('../../api/websocket.js');
+    const { CONNECTION_STATE } = await import('../../config/constants.js');
+
+    const wsManager = new WebSocketManager('localhost', 8080);
+
+    // Test state methods
+    expect(wsManager.getState()).toBe(CONNECTION_STATE.DISCONNECTED);
+    expect(wsManager.isConnected()).toBe(false);
+    expect(wsManager.getSessionId()).toBe(null);
+
+    // Test stats
+    const stats = wsManager.getStats();
+    expect(stats).toHaveProperty('state');
+    expect(stats).toHaveProperty('sessionId');
+    expect(stats).toHaveProperty('reconnectAttempts');
+    expect(stats).toHaveProperty('queuedMessages');
+    expect(stats).toHaveProperty('pendingRequests');
+  });
+
+  test('MessageRouter can register and unregister handlers', async () => {
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const router = new MessageRouter(wsManager);
+
+    const testHandler = () => {};
+
+    expect(router.hasHandler('test-message')).toBe(false);
+
+    router.registerHandler('test-message', testHandler);
+    expect(router.hasHandler('test-message')).toBe(true);
+
+    router.unregisterHandler('test-message');
+    expect(router.hasHandler('test-message')).toBe(false);
+  });
+
+  test('MessageRouter middleware helpers create valid middleware', async () => {
+    const {
+      loggingMiddleware,
+      timestampMiddleware,
+      filterMiddleware,
+    } = await import('../../api/messageRouter.js');
+
+    // Test logging middleware
+    const logMw = loggingMiddleware();
+    expect(typeof logMw).toBe('function');
+
+    // Test timestamp middleware
+    const tsMw = timestampMiddleware();
+    expect(typeof tsMw).toBe('function');
+    const testMsg = { type: 'test' };
+    const result = tsMw(testMsg);
+    expect(result).toHaveProperty('receivedAt');
+    expect(result.type).toBe('test');
+
+    // Test filter middleware
+    const filterMw = filterMiddleware(['allowed-type']);
+    expect(typeof filterMw).toBe('function');
+    expect(filterMw({ type: 'allowed-type' })).toBeTruthy();
+    expect(filterMw({ type: 'blocked-type' })).toBe(null);
+  });
+
+  test('Constants have no magic numbers', async () => {
+    const constants = await import('../../config/constants.js');
+
+    // Verify all timing values are defined
+    expect(typeof constants.TIMING.WEBSOCKET_RECONNECT_DELAY).toBe('number');
+    expect(typeof constants.TIMING.WEBSOCKET_PING_INTERVAL).toBe('number');
+
+    // Verify network defaults
+    expect(typeof constants.NETWORK.DEFAULT_PORT).toBe('number');
+    expect(typeof constants.NETWORK.MAX_RETRIES).toBe('number');
+    expect(typeof constants.NETWORK.HTTP_TIMEOUT).toBe('number');
+
+    // Verify UI dimensions
+    expect(typeof constants.UI_DIMENSIONS.MESSAGE_LIST_HEIGHT).toBe('number');
+    expect(typeof constants.UI_DIMENSIONS.SIDEBAR_WIDTH).toBe('number');
+  });
+});
+
+describe('Terminal UI Infrastructure - Error Handling', () => {
+  test('MessageRouter throws on invalid handler', async () => {
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const router = new MessageRouter(wsManager);
+
+    expect(() => {
+      router.registerHandler('test', 'not-a-function');
+    }).toThrow('Handler must be a function');
+  });
+
+  test('MessageRouter throws on invalid middleware', async () => {
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const router = new MessageRouter(wsManager);
+
+    expect(() => {
+      router.use('not-a-function');
+    }).toThrow('Middleware must be a function');
+  });
+
+  test('SessionManager clear() resets all state', async () => {
+    const { SessionManager } = await import('../../api/session.js');
+
+    const sessionManager = new SessionManager('localhost', 8080);
+
+    // Manually set some state
+    sessionManager.sessionId = 'test-123';
+    sessionManager.projectDir = '/test/dir';
+    sessionManager.loxiaApiKey = 'test-key';
+    sessionManager.vendorKeys = { openai: 'key' };
+
+    expect(sessionManager.isValid()).toBe(true);
+
+    // Clear
+    sessionManager.clear();
+
+    // Verify all cleared
+    expect(sessionManager.sessionId).toBe(null);
+    expect(sessionManager.projectDir).toBe(null);
+    expect(sessionManager.loxiaApiKey).toBe(null);
+    expect(sessionManager.vendorKeys).toEqual({});
+    expect(sessionManager.isValid()).toBe(false);
+  });
+
+  test('WebSocketManager generates unique request IDs', async () => {
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    const wsManager = new WebSocketManager('localhost', 8080);
+
+    const id1 = wsManager.generateRequestId();
+    const id2 = wsManager.generateRequestId();
+    const id3 = wsManager.generateRequestId();
+
+    expect(id1).not.toBe(id2);
+    expect(id2).not.toBe(id3);
+    expect(id1).not.toBe(id3);
+
+    // Verify format
+    expect(id1).toMatch(/^req-\d+-\d+$/);
+    expect(id2).toMatch(/^req-\d+-\d+$/);
+    expect(id3).toMatch(/^req-\d+-\d+$/);
+  });
+});

package/src/interfaces/terminal/__tests__/smoke/messages.test.js

@@ -0,0 +1,256 @@
+/**
+ * Message Management - Smoke Tests
+ * Verifies that message management modules can be imported and basic functionality works
+ */
+
+import { describe, test, expect } from '@jest/globals';
+
+describe('Message Management - Imports', () => {
+  test('useMessages hook can be imported', async () => {
+    const { useMessages } = await import('../../state/useMessages.js');
+
+    expect(useMessages).toBeDefined();
+    expect(typeof useMessages).toBe('function');
+  });
+
+  test('useMessages is default export', async () => {
+    const module = await import('../../state/useMessages.js');
+
+    expect(module.default).toBeDefined();
+    expect(typeof module.default).toBe('function');
+    expect(module.default).toBe(module.useMessages);
+  });
+
+  test('useMessageCount helper hook can be imported', async () => {
+    const { useMessageCount } = await import('../../state/useMessages.js');
+
+    expect(useMessageCount).toBeDefined();
+    expect(typeof useMessageCount).toBe('function');
+  });
+});
+
+describe('Message Management - Constants', () => {
+  test('MESSAGE_ROLE constants are defined', async () => {
+    const { MESSAGE_ROLE } = await import('../../config/constants.js');
+
+    expect(MESSAGE_ROLE).toBeDefined();
+    expect(MESSAGE_ROLE.USER).toBe('user');
+    expect(MESSAGE_ROLE.ASSISTANT).toBe('assistant');
+    expect(MESSAGE_ROLE.SYSTEM).toBe('system');
+  });
+
+  test('MESSAGE_TYPE constants are defined', async () => {
+    const { MESSAGE_TYPE } = await import('../../config/constants.js');
+
+    expect(MESSAGE_TYPE).toBeDefined();
+    expect(MESSAGE_TYPE.USER_MESSAGE).toBe('user-message');
+    expect(MESSAGE_TYPE.AGENT_RESPONSE).toBe('agent-response');
+    expect(MESSAGE_TYPE.SYSTEM_NOTIFICATION).toBe('system-notification');
+  });
+
+  test('MESSAGE_CONFIG constants are defined', async () => {
+    const { MESSAGE_CONFIG } = await import('../../config/constants.js');
+
+    expect(MESSAGE_CONFIG).toBeDefined();
+    expect(MESSAGE_CONFIG.MAX_MESSAGE_LENGTH).toBeDefined();
+    expect(MESSAGE_CONFIG.MAX_MESSAGES_DISPLAY).toBeDefined();
+    expect(typeof MESSAGE_CONFIG.MAX_MESSAGE_LENGTH).toBe('number');
+    expect(typeof MESSAGE_CONFIG.MAX_MESSAGES_DISPLAY).toBe('number');
+  });
+
+  test('PAGINATION constants are defined', async () => {
+    const { PAGINATION } = await import('../../config/constants.js');
+
+    expect(PAGINATION).toBeDefined();
+    expect(PAGINATION.PAGE_SIZE).toBeDefined();
+    expect(PAGINATION.MAX_PAGE_SIZE).toBeDefined();
+    expect(typeof PAGINATION.PAGE_SIZE).toBe('number');
+    expect(typeof PAGINATION.MAX_PAGE_SIZE).toBe('number');
+  });
+
+  test('WS_MESSAGE_TYPE includes message events', async () => {
+    const { WS_MESSAGE_TYPE } = await import('../../config/constants.js');
+
+    expect(WS_MESSAGE_TYPE).toBeDefined();
+    expect(WS_MESSAGE_TYPE.MESSAGE_ADDED).toBe('message_added');
+    expect(WS_MESSAGE_TYPE.AGENT_MODE_CHANGED).toBe('agent_mode_changed');
+    expect(WS_MESSAGE_TYPE.EXECUTION_STOPPED).toBe('execution_stopped');
+  });
+});
+
+describe('Message Management - Integration', () => {
+  test('useMessages hook integrates with Session and MessageRouter', async () => {
+    const { useMessages } = await import('../../state/useMessages.js');
+    const { SessionManager } = await import('../../api/session.js');
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+
+    // Create dependencies
+    const sessionManager = new SessionManager('localhost', 8080);
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const messageRouter = new MessageRouter(wsManager);
+
+    // Verify all components exist
+    expect(sessionManager).toBeDefined();
+    expect(messageRouter).toBeDefined();
+
+    // useMessages expects these as parameters (including currentAgentId)
+    // (we can't actually call the hook outside React, but we verify the interface)
+    expect(typeof useMessages).toBe('function');
+  });
+
+  test('Full message management stack can be imported together', async () => {
+    const [
+      constantsModule,
+      sessionModule,
+      websocketModule,
+      routerModule,
+      messagesModule,
+    ] = await Promise.all([
+      import('../../config/constants.js'),
+      import('../../api/session.js'),
+      import('../../api/websocket.js'),
+      import('../../api/messageRouter.js'),
+      import('../../state/useMessages.js'),
+    ]);
+
+    // Verify all modules loaded
+    expect(constantsModule.MESSAGE_ROLE).toBeDefined();
+    expect(constantsModule.MESSAGE_TYPE).toBeDefined();
+    expect(constantsModule.MESSAGE_CONFIG).toBeDefined();
+    expect(sessionModule.SessionManager).toBeDefined();
+    expect(websocketModule.WebSocketManager).toBeDefined();
+    expect(routerModule.MessageRouter).toBeDefined();
+    expect(messagesModule.useMessages).toBeDefined();
+  });
+});
+
+describe('Message Management - API Endpoints Validation', () => {
+  test('Orchestrator endpoint can be used for message operations', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    expect(API_ENDPOINTS.ORCHESTRATOR).toBeDefined();
+    expect(API_ENDPOINTS.ORCHESTRATOR).toBe('/api/orchestrator');
+  });
+
+  test('Message API endpoints follow RESTful pattern', async () => {
+    const { API_ENDPOINTS } = await import('../../config/constants.js');
+
+    // Verify orchestrator endpoint exists (messages use this with action: 'send-message', 'get-messages')
+    expect(API_ENDPOINTS.ORCHESTRATOR).toMatch(/^\/api\//);
+  });
+});
+
+describe('Message Management - Hook Interface Verification', () => {
+  test('useMessages returns expected interface shape', async () => {
+    const { useMessages } = await import('../../state/useMessages.js');
+
+    // We can verify the function signature
+    expect(useMessages.length).toBe(3); // sessionManager, messageRouter, currentAgentId
+  });
+
+  test('useMessageCount returns expected interface shape', async () => {
+    const { useMessageCount } = await import('../../state/useMessages.js');
+
+    // We can verify the function signature
+    expect(useMessageCount.length).toBe(1); // messages parameter
+  });
+});
+
+describe('Message Management - Constants Validation', () => {
+  test('MESSAGE_CONFIG has sensible defaults', async () => {
+    const { MESSAGE_CONFIG } = await import('../../config/constants.js');
+
+    // Verify message length is reasonable
+    expect(MESSAGE_CONFIG.MAX_MESSAGE_LENGTH).toBeGreaterThan(0);
+    expect(MESSAGE_CONFIG.MAX_MESSAGE_LENGTH).toBeLessThanOrEqual(100000);
+
+    // Verify display limit is reasonable
+    expect(MESSAGE_CONFIG.MAX_MESSAGES_DISPLAY).toBeGreaterThan(0);
+    expect(MESSAGE_CONFIG.MAX_MESSAGES_DISPLAY).toBeLessThanOrEqual(10000);
+  });
+
+  test('PAGINATION has sensible defaults', async () => {
+    const { PAGINATION } = await import('../../config/constants.js');
+
+    // Verify page size is reasonable
+    expect(PAGINATION.PAGE_SIZE).toBeGreaterThan(0);
+    expect(PAGINATION.PAGE_SIZE).toBeLessThanOrEqual(1000);
+
+    // Verify max page size is larger than or equal to page size
+    expect(PAGINATION.MAX_PAGE_SIZE).toBeGreaterThanOrEqual(PAGINATION.PAGE_SIZE);
+  });
+
+  test('MESSAGE_ROLE values are lowercase', async () => {
+    const { MESSAGE_ROLE } = await import('../../config/constants.js');
+
+    expect(MESSAGE_ROLE.USER).toBe(MESSAGE_ROLE.USER.toLowerCase());
+    expect(MESSAGE_ROLE.ASSISTANT).toBe(MESSAGE_ROLE.ASSISTANT.toLowerCase());
+    expect(MESSAGE_ROLE.SYSTEM).toBe(MESSAGE_ROLE.SYSTEM.toLowerCase());
+  });
+});
+
+describe('Message Management - WebSocket Event Handlers', () => {
+  test('MessageRouter has message event handlers registered', async () => {
+    const { MessageRouter } = await import('../../api/messageRouter.js');
+    const { WebSocketManager } = await import('../../api/websocket.js');
+    const { WS_MESSAGE_TYPE } = await import('../../config/constants.js');
+
+    const wsManager = new WebSocketManager('localhost', 8080);
+    const router = new MessageRouter(wsManager);
+
+    // Verify message event handlers are registered
+    expect(router.hasHandler(WS_MESSAGE_TYPE.MESSAGE_ADDED)).toBe(true);
+    expect(router.hasHandler(WS_MESSAGE_TYPE.AGENT_MODE_CHANGED)).toBe(true);
+  });
+});
+
+describe('Message Management - Error Handling', () => {
+  test('MESSAGE_CONFIG enforces maximum message length', async () => {
+    const { MESSAGE_CONFIG } = await import('../../config/constants.js');
+
+    // Verify max length constant exists
+    expect(MESSAGE_CONFIG.MAX_MESSAGE_LENGTH).toBeDefined();
+    expect(typeof MESSAGE_CONFIG.MAX_MESSAGE_LENGTH).toBe('number');
+
+    // This constant should be used to validate message length before sending
+    const testMessage = 'a'.repeat(MESSAGE_CONFIG.MAX_MESSAGE_LENGTH + 1);
+    expect(testMessage.length).toBeGreaterThan(MESSAGE_CONFIG.MAX_MESSAGE_LENGTH);
+  });
+
+  test('MESSAGE_CONFIG enforces maximum display messages', async () => {
+    const { MESSAGE_CONFIG } = await import('../../config/constants.js');
+
+    // Verify max display constant exists
+    expect(MESSAGE_CONFIG.MAX_MESSAGES_DISPLAY).toBeDefined();
+    expect(typeof MESSAGE_CONFIG.MAX_MESSAGES_DISPLAY).toBe('number');
+
+    // This constant should be used to trim message arrays
+    expect(MESSAGE_CONFIG.MAX_MESSAGES_DISPLAY).toBeGreaterThan(0);
+  });
+});
+
+describe('Message Management - Pagination Logic', () => {
+  test('PAGINATION supports offset-based pagination', async () => {
+    const { PAGINATION } = await import('../../config/constants.js');
+
+    const page = 0;
+    const offset = page * PAGINATION.PAGE_SIZE;
+
+    expect(offset).toBe(0); // First page should start at offset 0
+
+    const page2 = 1;
+    const offset2 = page2 * PAGINATION.PAGE_SIZE;
+
+    expect(offset2).toBe(PAGINATION.PAGE_SIZE); // Second page should start at PAGE_SIZE
+  });
+
+  test('PAGINATION limit does not exceed MAX_PAGE_SIZE', async () => {
+    const { PAGINATION } = await import('../../config/constants.js');
+
+    const requestedLimit = 1000;
+    const actualLimit = Math.min(requestedLimit, PAGINATION.MAX_PAGE_SIZE);
+
+    expect(actualLimit).toBeLessThanOrEqual(PAGINATION.MAX_PAGE_SIZE);
+  });
+});