chz-telegram-bot 0.7.13 → 0.7.15

package/tests/helpers/mapUtils.test.ts

@@ -1,163 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { getOrSetIfNotExists, getOrThrow } from '../../src/helpers/mapUtils';
-
-describe('mapUtils', () => {
-    describe('getOrSetIfNotExists', () => {
-        test('should return existing value if key exists', () => {
-            const map = new Map<string, number>();
-            map.set('existing', 42);
-
-            const result = getOrSetIfNotExists(map, 'existing', 100);
-
-            expect(result).toBe(42);
-            expect(map.get('existing')).toBe(42);
-        });
-
-        test('should set and return fallback if key does not exist', () => {
-            const map = new Map<string, number>();
-
-            const result = getOrSetIfNotExists(map, 'new-key', 100);
-
-            expect(result).toBe(100);
-            expect(map.get('new-key')).toBe(100);
-        });
-
-        test('should not overwrite existing value', () => {
-            const map = new Map<string, string>();
-            map.set('key', 'original');
-
-            getOrSetIfNotExists(map, 'key', 'fallback');
-
-            expect(map.get('key')).toBe('original');
-        });
-
-        test('should work with complex value types', () => {
-            const map = new Map<string, { id: number; name: string }>();
-
-            const fallback = { id: 1, name: 'test' };
-            const result = getOrSetIfNotExists(map, 'obj', fallback);
-
-            expect(result).toBe(fallback);
-            expect(map.get('obj')).toBe(fallback);
-        });
-
-        test('should work with number keys', () => {
-            const map = new Map<number, string>();
-
-            const result = getOrSetIfNotExists(map, 123, 'value');
-
-            expect(result).toBe('value');
-            expect(map.get(123)).toBe('value');
-        });
-
-        test('should handle falsy values correctly (except undefined)', () => {
-            const map = new Map<string, number>();
-            map.set('zero', 0);
-
-            // Note: current implementation treats 0 as falsy, so fallback is used
-            // This is a known edge case in the implementation
-            const result = getOrSetIfNotExists(map, 'zero', 999);
-
-            // Based on implementation: if (existingValue) - 0 is falsy
-            expect(result).toBe(999);
-        });
-
-        test('should handle empty string value', () => {
-            const map = new Map<string, string>();
-            map.set('empty', '');
-
-            // Empty string is falsy, so fallback is used
-            const result = getOrSetIfNotExists(map, 'empty', 'fallback');
-
-            expect(result).toBe('fallback');
-        });
-
-        // Real-world usage: JsonFileStorage uses this for file paths and locks
-        test('should work with Semaphore pattern (like JsonFileStorage)', () => {
-            // Simulated Semaphore-like object
-            class MockSemaphore {
-                constructor(readonly limit: number) {}
-            }
-
-            const locks = new Map<string, MockSemaphore>();
-
-            const lock1 = getOrSetIfNotExists(
-                locks,
-                'action:key',
-                new MockSemaphore(1)
-            );
-            expect(lock1.limit).toBe(1);
-            expect(locks.size).toBe(1);
-
-            // Second call should return same instance
-            const lock2 = getOrSetIfNotExists(
-                locks,
-                'action:key',
-                new MockSemaphore(5)
-            );
-            expect(lock2).toBe(lock1);
-            expect(lock2.limit).toBe(1); // Original limit, not 5
-        });
-    });
-
-    describe('getOrThrow', () => {
-        test('should return value if key exists', () => {
-            const map = new Map<string, number>();
-            map.set('key', 42);
-
-            const result = getOrThrow(map, 'key');
-
-            expect(result).toBe(42);
-        });
-
-        test('should throw default error if key does not exist', () => {
-            const map = new Map<string, number>();
-
-            expect(() => getOrThrow(map, 'missing')).toThrow(
-                'Key not found in collection'
-            );
-        });
-
-        test('should throw custom error message if provided', () => {
-            const map = new Map<string, number>();
-
-            expect(() =>
-                getOrThrow(map, 'missing', 'Custom error message')
-            ).toThrow('Custom error message');
-        });
-
-        test('should work with complex value types', () => {
-            const map = new Map<string, { data: string[] }>();
-            const value = { data: ['a', 'b', 'c'] };
-            map.set('complex', value);
-
-            const result = getOrThrow(map, 'complex');
-
-            expect(result).toBe(value);
-            expect(result.data).toEqual(['a', 'b', 'c']);
-        });
-
-        test('should work with readonly collections', () => {
-            const map = new Map<string, number>();
-            map.set('key', 100);
-
-            // Cast to readonly-like interface
-            const readonlyMap: { get: (key: string) => number | undefined } =
-                map;
-
-            const result = getOrThrow(readonlyMap, 'key');
-
-            expect(result).toBe(100);
-        });
-
-        test('should handle falsy values correctly (except undefined)', () => {
-            const map = new Map<string, number>();
-            map.set('zero', 0);
-
-            // Note: current implementation treats 0 as falsy, so it throws
-            expect(() => getOrThrow(map, 'zero')).toThrow(
-                'Key not found in collection'
-            );
-        });
-    });
-});

package/tests/helpers/timeConvertions.test.ts

@@ -1,129 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import {
-    secondsToMilliseconds,
-    hoursToMilliseconds,
-    hoursToSeconds
-} from '../../src/helpers/timeConvertions';
-import { Hours, Milliseconds, Seconds } from '../../src/types/timeValues';
-
-describe('timeConvertions', () => {
-    describe('secondsToMilliseconds', () => {
-        test('should convert 1 second to 1000 milliseconds', () => {
-            const result = secondsToMilliseconds(1 as Seconds);
-            expect(result).toBe(1000 as Milliseconds);
-        });
-
-        test('should convert 0 seconds to 0 milliseconds', () => {
-            const result = secondsToMilliseconds(0 as Seconds);
-            expect(result).toBe(0 as Milliseconds);
-        });
-
-        test('should convert fractional seconds', () => {
-            const result = secondsToMilliseconds(0.5 as Seconds);
-            expect(result).toBe(500 as Milliseconds);
-        });
-
-        test('should convert large values', () => {
-            const result = secondsToMilliseconds(3600 as Seconds); // 1 hour in seconds
-            expect(result).toBe(3600000 as Milliseconds);
-        });
-
-        test('should handle decimal precision', () => {
-            const result = secondsToMilliseconds(1.234 as Seconds);
-            expect(result).toBe(1234 as Milliseconds);
-        });
-
-        // Real usage: ScheduledActionProcessor uses this for period conversion
-        test('should convert period for scheduled action processor', () => {
-            const periodInSeconds = 3600 as Seconds; // Default 1 hour
-            const result = secondsToMilliseconds(periodInSeconds);
-            expect(result).toBe(3600000 as Milliseconds);
-        });
-    });
-
-    describe('hoursToMilliseconds', () => {
-        test('should convert 1 hour to 3600000 milliseconds', () => {
-            const result = hoursToMilliseconds(1 as Hours);
-            expect(result).toBe(3600000 as Milliseconds);
-        });
-
-        test('should convert 0 hours to 0 milliseconds', () => {
-            const result = hoursToMilliseconds(0 as Hours);
-            expect(result).toBe(0 as Milliseconds);
-        });
-
-        test('should convert 24 hours to correct milliseconds', () => {
-            const result = hoursToMilliseconds(24 as Hours);
-            expect(result).toBe(86400000 as Milliseconds); // 24 * 60 * 60 * 1000
-        });
-
-        test('should convert fractional hours', () => {
-            const result = hoursToMilliseconds(0.5 as Hours);
-            expect(result).toBe(1800000 as Milliseconds); // 30 minutes
-        });
-
-        test('should convert quarter hour', () => {
-            const result = hoursToMilliseconds(0.25 as Hours);
-            expect(result).toBe(900000 as Milliseconds); // 15 minutes
-        });
-    });
-
-    describe('hoursToSeconds', () => {
-        test('should convert 1 hour to 3600 seconds', () => {
-            const result = hoursToSeconds(1 as Hours);
-            expect(result).toBe(3600 as Seconds);
-        });
-
-        test('should convert 0 hours to 0 seconds', () => {
-            const result = hoursToSeconds(0 as Hours);
-            expect(result).toBe(0 as Seconds);
-        });
-
-        test('should convert 24 hours to correct seconds', () => {
-            const result = hoursToSeconds(24 as Hours);
-            expect(result).toBe(86400 as Seconds);
-        });
-
-        test('should convert fractional hours', () => {
-            const result = hoursToSeconds(0.5 as Hours);
-            expect(result).toBe(1800 as Seconds); // 30 minutes
-        });
-
-        // Real usage: ActionProcessingService default scheduledPeriod
-        test('should convert default scheduled period', () => {
-            const defaultPeriod = hoursToSeconds(1 as Hours);
-            expect(defaultPeriod).toBe(3600 as Seconds);
-        });
-    });
-
-    describe('conversion consistency', () => {
-        test('hoursToMilliseconds should equal hoursToSeconds * 1000', () => {
-            const hours = 2 as Hours;
-            const viaMilliseconds = hoursToMilliseconds(hours);
-            const viaSeconds = secondsToMilliseconds(hoursToSeconds(hours));
-
-            expect(viaMilliseconds).toBe(viaSeconds);
-        });
-
-        test('should maintain precision for common values', () => {
-            // Common scheduling intervals
-            expect(hoursToSeconds(1 as Hours)).toBe(3600 as Seconds);
-            expect(hoursToSeconds(6 as Hours)).toBe(21600 as Seconds);
-            expect(hoursToSeconds(12 as Hours)).toBe(43200 as Seconds);
-            expect(hoursToSeconds(24 as Hours)).toBe(86400 as Seconds);
-        });
-    });
-
-    describe('type safety', () => {
-        test('return types are correctly branded', () => {
-            const ms: Milliseconds = secondsToMilliseconds(1 as Seconds);
-            const s: Seconds = hoursToSeconds(1 as Hours);
-            const msFromHours: Milliseconds = hoursToMilliseconds(1 as Hours);
-
-            // These should compile and be usable
-            expect(typeof ms).toBe('number');
-            expect(typeof s).toBe('number');
-            expect(typeof msFromHours).toBe('number');
-        });
-    });
-});

package/tests/services/actionProcessors/baseActionProcessor.test.ts

@@ -1,359 +0,0 @@
-import { describe, test, expect, beforeEach, mock } from 'bun:test';
-import { BotEventType, TypedEventEmitter } from '../../../src/types/events';
-import { IScheduler } from '../../../src/types/scheduler';
-import { IStorageClient } from '../../../src/types/storage';
-import { ActionKey, IAction } from '../../../src/types/action';
-import { BaseActionProcessor } from '../../../src/services/actionProcessors/baseProcessor';
-import { BaseContextInternal } from '../../../src/entities/context/baseContext';
-import { ChatInfo } from '../../../src/dtos/chatInfo';
-import { TraceId } from '../../../src/types/trace';
-import {
-    createMockStorage,
-    createMockScheduler,
-    createMockAction,
-    createMockTelegramApi,
-    createMockChatInfo,
-    createMockTraceId,
-    createMockTextResponse,
-    type MockTelegramApi
-} from './processorTestHelpers';
-
-// =============================================================================
-// Concrete implementation for testing abstract BaseActionProcessor
-// =============================================================================
-
-// Helper for async delay
-const delay = (ms: number): Promise<void> =>
-    new Promise((resolve) => setTimeout(resolve, ms));
-
-// A minimal mock context that satisfies BaseContextInternal interface
-class MockBaseContext extends BaseContextInternal<IAction> {
-    constructor(
-        storage: IStorageClient,
-        scheduler: IScheduler,
-        eventEmitter: TypedEventEmitter,
-        action: IAction = createMockAction('default-action'),
-        chatInfo: ChatInfo = new ChatInfo(12345, 'Test Chat', []),
-        traceId: TraceId = 'test-trace' as TraceId,
-        botName: string = 'TestBot'
-    ) {
-        super(
-            storage,
-            scheduler,
-            eventEmitter,
-            action,
-            chatInfo,
-            traceId,
-            botName
-        );
-    }
-}
-
-class TestableBaseActionProcessor extends BaseActionProcessor {
-    // Expose protected members for testing
-    getStorage() {
-        return this.storage;
-    }
-    getScheduler() {
-        return this.scheduler;
-    }
-    getEventEmitter() {
-        return this.eventEmitter;
-    }
-    getBotName() {
-        return this.botName;
-    }
-    getApi() {
-        return this.api;
-    }
-
-    // Public wrapper for executeAction
-    testExecuteAction(
-        action: IAction,
-        ctx: MockBaseContext,
-        errorHandler?: (error: Error, ctx: MockBaseContext) => void
-    ) {
-        return this.executeAction(action, ctx, errorHandler);
-    }
-}
-
-// =============================================================================
-// BaseActionProcessor Tests
-// =============================================================================
-
-describe('BaseActionProcessor', () => {
-    let processor: TestableBaseActionProcessor;
-    let eventEmitter: TypedEventEmitter;
-    let storage: IStorageClient;
-    let scheduler: IScheduler;
-
-    beforeEach(() => {
-        eventEmitter = new TypedEventEmitter();
-        storage = createMockStorage();
-        scheduler = createMockScheduler();
-        processor = new TestableBaseActionProcessor(
-            'test-bot',
-            storage,
-            scheduler,
-            eventEmitter
-        );
-    });
-
-    describe('constructor', () => {
-        test('should store storage reference', () => {
-            expect(processor.getStorage()).toBe(storage);
-        });
-
-        test('should store scheduler reference', () => {
-            expect(processor.getScheduler()).toBe(scheduler);
-        });
-
-        test('should store eventEmitter reference', () => {
-            expect(processor.getEventEmitter()).toBe(eventEmitter);
-        });
-
-        test('should store botName', () => {
-            expect(processor.getBotName()).toBe('test-bot');
-        });
-    });
-
-    describe('initializeDependencies', () => {
-        test('should store api reference', () => {
-            const mockApi = createMockTelegramApi();
-            processor.initializeDependencies(mockApi);
-            expect(processor.getApi()).toBe(mockApi);
-        });
-    });
-
-    describe('executeAction', () => {
-        let mockApi: MockTelegramApi;
-        let mockContext: MockBaseContext;
-
-        beforeEach(() => {
-            mockApi = createMockTelegramApi();
-            processor.initializeDependencies(mockApi);
-            const action = createMockAction('ctx-action');
-            mockContext = new MockBaseContext(
-                storage,
-                scheduler,
-                eventEmitter,
-                action
-            );
-        });
-
-        test('should call action.exec with context', async () => {
-            const action = createMockAction('test-action');
-
-            await processor.testExecuteAction(action, mockContext);
-
-            expect(action.getExecCallCount()).toBe(1);
-            expect(action.getExecLastArgs()).toEqual([mockContext]);
-        });
-
-        test('should enqueue responses from action', async () => {
-            const chatInfo = createMockChatInfo();
-            const traceId = createMockTraceId();
-            const action = createMockAction('test-action');
-            const response = createMockTextResponse(chatInfo, traceId, action);
-            action.exec = mock(() => Promise.resolve([response]));
-
-            await processor.testExecuteAction(action, mockContext);
-
-            expect(mockApi.getEnqueueCallCount()).toBe(1);
-            expect(mockApi.getEnqueueLastArgs()).toEqual([response]);
-        });
-
-        test('should handle action execution', async () => {
-            const action = createMockAction('test-action');
-
-            await processor.testExecuteAction(action, mockContext);
-
-            // Verify execution completed successfully
-            expect(mockApi.getEnqueueCallCount()).toBe(1);
-        });
-
-        test('should call custom error handler on error', async () => {
-            const action = createMockAction('test-action');
-            const testError = new Error('Test error');
-            action.exec = mock(() => Promise.reject(testError));
-
-            const errorHandler = mock(() => {
-                /* no-op */
-            });
-
-            await processor.testExecuteAction(
-                action,
-                mockContext,
-                errorHandler
-            );
-
-            expect(errorHandler).toHaveBeenCalledWith(testError, mockContext);
-        });
-
-        test('should emit error event when no custom handler provided', async () => {
-            // BUG: defaultErrorHandler loses 'this' context when called via
-            // (errorHandler ?? this.defaultErrorHandler)(error, ctx)
-            // This test expects the correct behavior - fix by binding the method
-            const action = createMockAction('test-action');
-            const testError = new Error('Test error message');
-            testError.name = 'TestError';
-            action.exec = mock(() => Promise.reject(testError));
-
-            const errorEvents: unknown[] = [];
-            eventEmitter.on(BotEventType.error, (_ts, data) => {
-                errorEvents.push(data);
-            });
-
-            // Suppress console.error for cleaner test output
-            const originalConsoleError = console.error;
-            console.error = () => {};
-
-            await processor.testExecuteAction(action, mockContext);
-
-            console.error = originalConsoleError;
-
-            expect(errorEvents.length).toBe(1);
-            expect(errorEvents[0]).toMatchObject({
-                error: testError,
-                traceId: 'test-trace'
-            });
-        });
-
-        test('should log error to console with default handler', async () => {
-            // BUG: defaultErrorHandler loses 'this' context - needs binding fix
-            const action = createMockAction('test-action');
-            const testError = new Error('Console log test');
-            action.exec = mock(() => Promise.reject(testError));
-
-            const consoleErrors: unknown[] = [];
-            const originalConsoleError = console.error;
-            console.error = (...args: unknown[]) => {
-                consoleErrors.push(args[0]);
-            };
-
-            await processor.testExecuteAction(action, mockContext);
-
-            console.error = originalConsoleError;
-
-            expect(consoleErrors.length).toBe(1);
-            expect(consoleErrors[0]).toBe(testError);
-        });
-    });
-
-    describe('error handling edge cases', () => {
-        test('should handle async errors correctly with default handler', async () => {
-            // BUG: defaultErrorHandler loses 'this' context - needs binding fix
-            const localEventEmitter = new TypedEventEmitter();
-            const localStorage = createMockStorage();
-            const localScheduler = createMockScheduler();
-            const localProcessor = new TestableBaseActionProcessor(
-                'error-bot',
-                localStorage,
-                localScheduler,
-                localEventEmitter
-            );
-            const mockApi = createMockTelegramApi();
-            localProcessor.initializeDependencies(mockApi);
-
-            const asyncError = new Error('Async failure');
-            asyncError.name = 'AsyncError';
-
-            const action: IAction = {
-                key: 'error-action' as ActionKey,
-                exec: mock(async () => {
-                    await delay(10);
-                    throw asyncError;
-                })
-            };
-
-            const errorEvents: unknown[] = [];
-            localEventEmitter.on(BotEventType.error, (_ts, data) => {
-                errorEvents.push(data);
-            });
-
-            const originalConsoleError = console.error;
-            console.error = () => {
-                /* no-op */
-            };
-
-            const ctx = new MockBaseContext(
-                localStorage,
-                localScheduler,
-                localEventEmitter,
-                action
-            );
-            await localProcessor.testExecuteAction(action, ctx);
-
-            console.error = originalConsoleError;
-
-            expect(errorEvents.length).toBe(1);
-            expect(errorEvents[0]).toMatchObject({
-                error: asyncError,
-                traceId: 'test-trace'
-            });
-        });
-
-        test('should handle empty response array', async () => {
-            const localStorage = createMockStorage();
-            const localScheduler = createMockScheduler();
-            const localEventEmitter = new TypedEventEmitter();
-            const localProcessor = new TestableBaseActionProcessor(
-                'empty-bot',
-                localStorage,
-                localScheduler,
-                localEventEmitter
-            );
-            const localMockApi = createMockTelegramApi();
-            localProcessor.initializeDependencies(localMockApi);
-
-            const action = createMockAction('empty-action', []);
-            const ctx = new MockBaseContext(
-                localStorage,
-                localScheduler,
-                localEventEmitter,
-                action
-            );
-
-            await localProcessor.testExecuteAction(action, ctx);
-
-            expect(localMockApi.getEnqueueCallCount()).toBe(1);
-            expect(localMockApi.getEnqueueLastArgs()).toEqual([]);
-        });
-
-        test('should handle multiple responses', async () => {
-            const localStorage = createMockStorage();
-            const localScheduler = createMockScheduler();
-            const localEventEmitter = new TypedEventEmitter();
-            const localProcessor = new TestableBaseActionProcessor(
-                'multi-response-bot',
-                localStorage,
-                localScheduler,
-                localEventEmitter
-            );
-            const localMockApi = createMockTelegramApi();
-            localProcessor.initializeDependencies(localMockApi);
-
-            const chatInfo = createMockChatInfo();
-            const traceId = createMockTraceId();
-            const action = createMockAction('multi-action');
-
-            const responses = [
-                createMockTextResponse(chatInfo, traceId, action),
-                createMockTextResponse(chatInfo, traceId, action),
-                createMockTextResponse(chatInfo, traceId, action)
-            ];
-            action.exec = mock(() => Promise.resolve(responses));
-
-            const ctx = new MockBaseContext(
-                localStorage,
-                localScheduler,
-                localEventEmitter,
-                action
-            );
-            await localProcessor.testExecuteAction(action, ctx);
-
-            expect(localMockApi.getEnqueueCallCount()).toBe(1);
-            expect(localMockApi.getEnqueueLastArgs()).toEqual(responses);
-        });
-    });
-});