chz-telegram-bot 0.7.13 → 0.7.15

package/tests/services/actionProcessors/processorTestHelpers.ts

@@ -1,147 +0,0 @@
-import { mock, type Mock } from 'bun:test';
-import { IScheduler } from '../../../src/types/scheduler';
-import { IStorageClient } from '../../../src/types/storage';
-import { ActionKey, IAction } from '../../../src/types/action';
-import { BotResponse } from '../../../src/types/response';
-import { ChatInfo } from '../../../src/dtos/chatInfo';
-import { TextMessage } from '../../../src/dtos/responses/textMessage';
-import { TraceId } from '../../../src/types/trace';
-import { Milliseconds } from '../../../src/types/timeValues';
-import { TelegramApiService } from '../../../src/services/telegramApi';
-
-// Re-export Mock type for use in tests
-export type { Mock } from 'bun:test';
-
-// Type-safe mock accessor - returns the mock function with proper typing
-export function getMockFn<T extends (...args: never[]) => unknown>(
-    fn: T
-): Mock<T> {
-    return fn as unknown as Mock<T>;
-}
-
-export function createMockStorage(): IStorageClient {
-    return {
-        load: mock(() => ({})) as IStorageClient['load'],
-        close: mock(() => Promise.resolve()),
-        getActionState: mock(() => ({
-            lastExecutedDate: 0,
-            pinnedMessages: []
-        })) as IStorageClient['getActionState'],
-        saveActionExecutionResult: mock(() => Promise.resolve()),
-        updateStateFor: mock(() => Promise.resolve())
-    };
-}
-
-// Extended scheduler type that exposes mock call tracking
-export interface MockScheduler extends IScheduler {
-    createTaskCallCount: () => number;
-    createOnetimeTaskCallCount: () => number;
-}
-
-export function createMockScheduler(): MockScheduler {
-    // Using arrow functions assigned to variables to avoid unbound-method ESLint errors
-    const createTaskMock = mock(
-        (
-            _name: string,
-            action: () => void,
-            _interval: Milliseconds,
-            executeRightAway: boolean,
-            _ownerName: string
-        ): void => {
-            if (executeRightAway) {
-                setImmediate(() => {
-                    action();
-                });
-            }
-        }
-    );
-
-    const createOnetimeTaskMock = mock(
-        (
-            _name: string,
-            action: () => void,
-            delay: Milliseconds,
-            _ownerName: string
-        ): void => {
-            setTimeout(() => {
-                action();
-            }, delay as number);
-        }
-    );
-
-    const stopAll = mock(() => {
-        /* no-op */
-    });
-
-    return {
-        createTask: createTaskMock,
-        createOnetimeTask: createOnetimeTaskMock,
-        stopAll,
-        createTaskCallCount: () => createTaskMock.mock.calls.length,
-        createOnetimeTaskCallCount: () =>
-            createOnetimeTaskMock.mock.calls.length
-    };
-}
-
-// Extended action type that exposes mock call tracking
-export interface MockAction extends IAction {
-    getExecCallCount: () => number;
-    getExecLastArgs: () => unknown[] | undefined;
-}
-
-export function createMockAction(
-    key: string,
-    execResult: BotResponse[] = []
-): MockAction {
-    const execMock = mock(() => Promise.resolve(execResult));
-    return {
-        key: key as ActionKey,
-        exec: execMock,
-        getExecCallCount: () => execMock.mock.calls.length,
-        getExecLastArgs: () => execMock.mock.calls.at(-1)
-    };
-}
-
-// Extended telegram api type that exposes mock call tracking
-export interface MockTelegramApi extends TelegramApiService {
-    getEnqueueCallCount: () => number;
-    getEnqueueLastArgs: () => BotResponse[] | undefined;
-}
-
-export function createMockTelegramApi(): MockTelegramApi {
-    const enqueueMock = mock((_responses: BotResponse[]) => {
-        /* no-op */
-    });
-    const flushMock = mock(() => {
-        /* no-op */
-    });
-    return {
-        enqueueBatchedResponses: enqueueMock,
-        flushResponses: flushMock,
-        getEnqueueCallCount: () => enqueueMock.mock.calls.length,
-        getEnqueueLastArgs: () => enqueueMock.mock.calls.at(-1)?.[0]
-    } as unknown as MockTelegramApi;
-}
-
-export function createMockChatInfo(): ChatInfo {
-    return new ChatInfo(12345, 'Test Chat', []);
-}
-
-export function createMockTraceId(): TraceId {
-    return 'trace-123' as TraceId;
-}
-
-export function createMockTextResponse(
-    chatInfo: ChatInfo,
-    traceId: TraceId,
-    action: IAction
-): TextMessage {
-    return new TextMessage(
-        'Hello',
-        chatInfo,
-        traceId,
-        action,
-        undefined,
-        undefined
-    );
-}

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

@@ -1,153 +0,0 @@
-import { describe, test, expect, beforeEach } from 'bun:test';
-import { TypedEventEmitter } from '../../../src/types/events';
-import { IStorageClient } from '../../../src/types/storage';
-import { Seconds } from '../../../src/types/timeValues';
-import { ScheduledActionProcessor } from '../../../src/services/actionProcessors/scheduledActionProcessor';
-import {
-    createMockStorage,
-    createMockScheduler,
-    createMockTelegramApi,
-    type MockScheduler
-} from './processorTestHelpers';
-
-// =============================================================================
-// ScheduledActionProcessor Tests
-// =============================================================================
-
-describe('ScheduledActionProcessor', () => {
-    let processor: ScheduledActionProcessor;
-    let eventEmitter: TypedEventEmitter;
-    let storage: IStorageClient;
-    let scheduler: MockScheduler;
-    const chats = { chat1: 111, chat2: 222 };
-
-    beforeEach(() => {
-        eventEmitter = new TypedEventEmitter();
-        storage = createMockStorage();
-        scheduler = createMockScheduler();
-        processor = new ScheduledActionProcessor(
-            'scheduled-bot',
-            chats,
-            storage,
-            scheduler,
-            eventEmitter
-        );
-    });
-
-    describe('constructor', () => {
-        test('should create processor with chats', () => {
-            expect(processor).toBeDefined();
-        });
-    });
-
-    describe('initialize', () => {
-        test('should store api reference', () => {
-            const mockApi = createMockTelegramApi();
-            processor.initialize(mockApi, [], 3600 as Seconds);
-
-            // If no scheduled actions, no tasks should be created
-            expect(scheduler.createTaskCallCount()).toBe(0);
-        });
-
-        test('should call initializeDependencies with api when no actions', () => {
-            const mockApi = createMockTelegramApi();
-
-            processor.initialize(mockApi, [], 3600 as Seconds);
-
-            // After initialize, the processor should still be defined
-            expect(processor).toBeDefined();
-        });
-    });
-
-    describe('edge cases', () => {
-        test('should handle empty chats object', () => {
-            const localProcessor = new ScheduledActionProcessor(
-                'empty-chats-bot',
-                {}, // Empty chats
-                createMockStorage(),
-                createMockScheduler(),
-                new TypedEventEmitter()
-            );
-
-            expect(localProcessor).toBeDefined();
-        });
-
-        test('should handle no scheduled actions', () => {
-            const localScheduler = createMockScheduler();
-            const localProcessor = new ScheduledActionProcessor(
-                'no-actions-bot',
-                { test: 123 },
-                createMockStorage(),
-                localScheduler,
-                new TypedEventEmitter()
-            );
-
-            const mockApi = createMockTelegramApi();
-            localProcessor.initialize(mockApi, [], 3600 as Seconds);
-
-            // Should not create any tasks
-            expect(localScheduler.createTaskCallCount()).toBe(0);
-            expect(localScheduler.createOnetimeTaskCallCount()).toBe(0);
-        });
-    });
-
-    describe('multi-chat configuration', () => {
-        test('should accept multiple chats in configuration', () => {
-            const multiChats = {
-                general: 100,
-                random: 200,
-                dev: 300
-            };
-
-            const localProcessor = new ScheduledActionProcessor(
-                'multi-chat-bot',
-                multiChats,
-                createMockStorage(),
-                createMockScheduler(),
-                new TypedEventEmitter()
-            );
-
-            // The processor should be properly instantiated with multiple chats
-            expect(localProcessor).toBeDefined();
-        });
-    });
-
-    describe('event emission', () => {
-        test('should emit scheduledProcessingStarted when processing begins', () => {
-            const localEventEmitter = new TypedEventEmitter();
-
-            const localProcessor = new ScheduledActionProcessor(
-                'event-bot',
-                chats,
-                storage,
-                scheduler,
-                localEventEmitter
-            );
-
-            const mockApi = createMockTelegramApi();
-            localProcessor.initialize(mockApi, [], 3600 as Seconds);
-
-            // When initialized with scheduled actions, processing started would be emitted
-            // when the periodic task runs
-            expect(localProcessor).toBeDefined();
-        });
-
-        test('should emit scheduledProcessingFinished when processing completes', () => {
-            const localEventEmitter = new TypedEventEmitter();
-
-            const localProcessor = new ScheduledActionProcessor(
-                'finish-bot',
-                chats,
-                storage,
-                scheduler,
-                localEventEmitter
-            );
-
-            const mockApi = createMockTelegramApi();
-            localProcessor.initialize(mockApi, [], 3600 as Seconds);
-
-            // When processing completes, scheduledProcessingFinished event is emitted
-            expect(localProcessor).toBeDefined();
-        });
-    });
-});