@ihazz/bitrix24 0.2.4 → 1.0.0

package/tests/send-service.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { SendService } from '../src/send-service.js';
+import type { Bitrix24Api } from '../src/api.js';
+
+const silentLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  debug: vi.fn(),
+};
+
+function mockApi(): Bitrix24Api {
+  return {
+    answerCommand: vi.fn().mockResolvedValue(true),
+    notifyInputAction: vi.fn().mockResolvedValue(true),
+    sendTyping: vi.fn().mockResolvedValue(true),
+    readMessage: vi.fn().mockResolvedValue({
+      chatId: 1,
+      lastId: 123,
+      counter: 0,
+      viewedMessages: [123],
+    }),
+    sendMessage: vi.fn(),
+    updateMessage: vi.fn(),
+  } as unknown as Bitrix24Api;
+}
+
+describe('SendService', () => {
+  let api: Bitrix24Api;
+  let service: SendService;
+
+  const ctx = {
+    webhookUrl: 'https://test.bitrix24.com/rest/1/token/',
+    bot: { botId: 7, botToken: 'bot_token' },
+    dialogId: '42',
+  };
+  const commandCtx = {
+    ...ctx,
+    commandId: 55,
+    messageId: 123,
+  };
+
+  beforeEach(() => {
+    api = mockApi();
+    service = new SendService(api, silentLogger);
+    vi.clearAllMocks();
+  });
+
+  it('sends explicit input action status', async () => {
+    await service.sendStatus(ctx, 'IMBOT_AGENT_ACTION_COMPOSING', 45);
+
+    expect(api.notifyInputAction).toHaveBeenCalledWith(
+      ctx.webhookUrl,
+      ctx.bot,
+      ctx.dialogId,
+      {
+        statusMessageCode: 'IMBOT_AGENT_ACTION_COMPOSING',
+        duration: 45,
+      },
+    );
+  });
+
+  it('uses notifyInputAction for sendTyping', async () => {
+    await service.sendTyping(ctx);
+
+    expect(api.notifyInputAction).toHaveBeenCalledWith(
+      ctx.webhookUrl,
+      ctx.bot,
+      ctx.dialogId,
+    );
+  });
+
+  it('marks a specific message as read', async () => {
+    await service.markRead(ctx, 123);
+
+    expect(api.readMessage).toHaveBeenCalledWith(
+      ctx.webhookUrl,
+      ctx.bot,
+      ctx.dialogId,
+      123,
+    );
+  });
+
+  it('swallows read failures', async () => {
+    (api.readMessage as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error('read failed'));
+
+    await expect(service.markRead(ctx, 123)).resolves.toBeUndefined();
+    expect(silentLogger.debug).toHaveBeenCalled();
+  });
+
+  it('answers native commands via imbot.v2.Command.answer', async () => {
+    await service.answerCommandText(commandCtx, 'Status ok');
+
+    expect(api.answerCommand).toHaveBeenCalledWith(
+      ctx.webhookUrl,
+      ctx.bot,
+      55,
+      123,
+      ctx.dialogId,
+      'Status ok',
+      undefined,
+    );
+    expect(api.sendMessage).not.toHaveBeenCalled();
+  });
+
+  it('sends command follow-up chunks as regular chat messages', async () => {
+    (api.sendMessage as ReturnType<typeof vi.fn>).mockResolvedValueOnce(777);
+    const longText = `${'A'.repeat(20000)}${'B'.repeat(50)}`;
+
+    const result = await service.answerCommandText(commandCtx, longText);
+
+    expect(result.ok).toBe(true);
+    expect(api.answerCommand).toHaveBeenCalledOnce();
+    expect(api.sendMessage).toHaveBeenCalledOnce();
+    expect(api.sendMessage).toHaveBeenCalledWith(
+      ctx.webhookUrl,
+      ctx.bot,
+      ctx.dialogId,
+      'B'.repeat(50),
+      undefined,
+    );
+  });
+
+  it('throws when sendText cannot deliver a chunk', async () => {
+    (api.sendMessage as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error('send failed'));
+
+    await expect(service.sendText(ctx, 'Hello')).rejects.toThrow('send failed');
+    expect(silentLogger.error).toHaveBeenCalled();
+  });
+
+  it('throws when command answer fails on the first chunk', async () => {
+    (api.answerCommand as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error('answer failed'));
+
+    await expect(service.answerCommandText(commandCtx, 'Status ok')).rejects.toThrow('answer failed');
+    expect(silentLogger.error).toHaveBeenCalled();
+  });
+
+  it('throws when command follow-up chunk cannot be sent', async () => {
+    (api.sendMessage as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error('follow-up failed'));
+    const longText = `${'A'.repeat(20000)}${'B'.repeat(50)}`;
+
+    await expect(service.answerCommandText(commandCtx, longText)).rejects.toThrow('follow-up failed');
+    expect(silentLogger.error).toHaveBeenCalled();
+  });
+});