@ihazz/bitrix24 0.1.4 → 0.1.6

package/tests/media-service.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { existsSync, unlinkSync } from 'node:fs';
+import { MediaService } from '../src/media-service.js';
+import { Bitrix24Api } from '../src/api.js';
+
+const silentLogger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  debug: vi.fn(),
+};
+
+// Mock the API
+function mockApi(): Bitrix24Api {
+  return {
+    getFileInfo: vi.fn().mockResolvedValue({
+      DOWNLOAD_URL: 'https://example.com/download/test.txt?token=abc',
+    }),
+    getChatFolder: vi.fn().mockResolvedValue(42),
+    uploadFile: vi.fn().mockResolvedValue(100),
+    commitFileToChat: vi.fn().mockResolvedValue(true),
+  } as unknown as Bitrix24Api;
+}
+
+describe('MediaService', () => {
+  let service: MediaService;
+  let api: Bitrix24Api;
+  const savedPaths: string[] = [];
+
+  beforeEach(() => {
+    api = mockApi();
+    service = new MediaService(api, silentLogger);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    // Clean up any files created during tests
+    for (const p of savedPaths) {
+      try { unlinkSync(p); } catch { /* ignore */ }
+    }
+    savedPaths.length = 0;
+  });
+
+  describe('downloadMedia', () => {
+    it('downloads and saves a file', async () => {
+      const mockContent = Buffer.from('hello world');
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
+        new Response(mockContent, { status: 200 }),
+      );
+
+      const result = await service.downloadMedia({
+        fileId: '123',
+        fileName: 'test.txt',
+        extension: 'txt',
+        clientEndpoint: 'https://test.bitrix24.com/rest/',
+        userToken: 'user_token',
+      });
+
+      expect(result).not.toBeNull();
+      expect(result!.contentType).toBe('text/plain');
+      expect(result!.name).toBe('test.txt');
+      expect(result!.path).toContain('test.txt');
+      expect(existsSync(result!.path)).toBe(true);
+      savedPaths.push(result!.path);
+
+      expect(api.getFileInfo).toHaveBeenCalledWith(
+        'https://test.bitrix24.com/rest/',
+        'user_token',
+        123,
+      );
+    });
+
+    it('returns correct MIME for images', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
+        new Response(Buffer.from([0x89, 0x50, 0x4e, 0x47]), { status: 200 }),
+      );
+
+      const result = await service.downloadMedia({
+        fileId: '456',
+        fileName: 'photo.jpg',
+        extension: 'jpg',
+        clientEndpoint: 'https://test.bitrix24.com/rest/',
+        userToken: 'token',
+      });
+
+      expect(result).not.toBeNull();
+      expect(result!.contentType).toBe('image/jpeg');
+      if (result) savedPaths.push(result.path);
+    });
+
+    it('returns null when API fails', async () => {
+      (api.getFileInfo as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
+        new Error('API error'),
+      );
+
+      const result = await service.downloadMedia({
+        fileId: '789',
+        fileName: 'fail.txt',
+        extension: 'txt',
+        clientEndpoint: 'https://test.bitrix24.com/rest/',
+        userToken: 'token',
+      });
+
+      expect(result).toBeNull();
+      expect(silentLogger.error).toHaveBeenCalled();
+    });
+
+    it('returns null when no DOWNLOAD_URL', async () => {
+      (api.getFileInfo as ReturnType<typeof vi.fn>).mockResolvedValueOnce({});
+
+      const result = await service.downloadMedia({
+        fileId: '789',
+        fileName: 'nourl.txt',
+        extension: 'txt',
+        clientEndpoint: 'https://test.bitrix24.com/rest/',
+        userToken: 'token',
+      });
+
+      expect(result).toBeNull();
+    });
+
+    it('returns null when download fails', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
+        new Response(null, { status: 404 }),
+      );
+
+      const result = await service.downloadMedia({
+        fileId: '789',
+        fileName: 'missing.txt',
+        extension: 'txt',
+        clientEndpoint: 'https://test.bitrix24.com/rest/',
+        userToken: 'token',
+      });
+
+      expect(result).toBeNull();
+    });
+
+    it('handles unknown extensions with octet-stream', async () => {
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
+        new Response(Buffer.from('data'), { status: 200 }),
+      );
+
+      const result = await service.downloadMedia({
+        fileId: '100',
+        fileName: 'file.xyz',
+        extension: 'xyz',
+        clientEndpoint: 'https://test.bitrix24.com/rest/',
+        userToken: 'token',
+      });
+
+      expect(result).not.toBeNull();
+      expect(result!.contentType).toBe('application/octet-stream');
+      if (result) savedPaths.push(result.path);
+    });
+  });
+
+  describe('uploadMediaToChat', () => {
+    it('uploads file through 3-step process', async () => {
+      // Create a temp file to upload
+      const { writeFileSync, mkdirSync } = await import('node:fs');
+      const { join } = await import('node:path');
+      const { tmpdir } = await import('node:os');
+      const testDir = join(tmpdir(), 'openclaw-b24-test');
+      mkdirSync(testDir, { recursive: true });
+      const testPath = join(testDir, 'upload-test.txt');
+      writeFileSync(testPath, 'upload content');
+      savedPaths.push(testPath);
+
+      const result = await service.uploadMediaToChat({
+        localPath: testPath,
+        fileName: 'upload-test.txt',
+        chatId: 40985,
+        clientEndpoint: 'https://test.bitrix24.com/rest/',
+        botToken: 'bot_token',
+      });
+
+      expect(result).toBe(true);
+      expect(api.getChatFolder).toHaveBeenCalledWith(
+        'https://test.bitrix24.com/rest/',
+        'bot_token',
+        40985,
+      );
+      expect(api.uploadFile).toHaveBeenCalledWith(
+        'https://test.bitrix24.com/rest/',
+        'bot_token',
+        42,
+        'upload-test.txt',
+        expect.any(Buffer),
+      );
+      expect(api.commitFileToChat).toHaveBeenCalledWith(
+        'https://test.bitrix24.com/rest/',
+        'bot_token',
+        40985,
+        100,
+      );
+    });
+
+    it('returns false when getChatFolder fails', async () => {
+      (api.getChatFolder as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
+        new Error('folder error'),
+      );
+
+      const { writeFileSync, mkdirSync } = await import('node:fs');
+      const { join } = await import('node:path');
+      const { tmpdir } = await import('node:os');
+      const testDir = join(tmpdir(), 'openclaw-b24-test');
+      mkdirSync(testDir, { recursive: true });
+      const testPath = join(testDir, 'fail-upload.txt');
+      writeFileSync(testPath, 'content');
+      savedPaths.push(testPath);
+
+      const result = await service.uploadMediaToChat({
+        localPath: testPath,
+        fileName: 'fail-upload.txt',
+        chatId: 40985,
+        clientEndpoint: 'https://test.bitrix24.com/rest/',
+        botToken: 'bot_token',
+      });
+
+      expect(result).toBe(false);
+      expect(silentLogger.error).toHaveBeenCalled();
+    });
+  });
+});

package/tests/message-utils.test.ts

@@ -78,18 +78,16 @@ describe('splitMessage', () => {
 });
 
 describe('buildKeyboard', () => {
-  it('builds a single row keyboard', () => {
+  it('builds a single row keyboard (flat array)', () => {
     const kb = buildKeyboard([
       [{ text: 'Yes', command: 'answer', commandParams: 'yes' }],
     ]);
+    // Flat array: 1 button, no NEWLINE
     expect(kb).toHaveLength(1);
-    expect(kb[0]).toHaveLength(1);
-    expect(kb[0][0].TEXT).toBe('Yes');
-    expect(kb[0][0].COMMAND).toBe('answer');
-    expect(kb[0][0].COMMAND_PARAMS).toBe('yes');
+    expect(kb[0]).toMatchObject({ TEXT: 'Yes', COMMAND: 'answer', COMMAND_PARAMS: 'yes' });
   });
 
-  it('builds multi-row keyboard', () => {
+  it('builds multi-row keyboard with NEWLINE separators', () => {
     const kb = buildKeyboard([
       [
         { text: 'Yes', command: 'answer', commandParams: 'yes' },
@@ -97,27 +95,26 @@ describe('buildKeyboard', () => {
       ],
       [{ text: 'More info', link: 'https://example.com', fullWidth: true }],
     ]);
-    expect(kb).toHaveLength(2);
-    expect(kb[0]).toHaveLength(2);
-    expect(kb[1]).toHaveLength(1);
-    expect(kb[1][0].LINK).toBe('https://example.com');
-    expect(kb[1][0].DISPLAY).toBe('LINE');
+    // Flat: [btn, btn, NEWLINE, btn] = 4 items
+    expect(kb).toHaveLength(4);
+    expect(kb[0]).toMatchObject({ TEXT: 'Yes' });
+    expect(kb[1]).toMatchObject({ TEXT: 'No' });
+    expect(kb[2]).toMatchObject({ TYPE: 'NEWLINE' });
+    expect(kb[3]).toMatchObject({ TEXT: 'More info', LINK: 'https://example.com', DISPLAY: 'LINE' });
   });
 
   it('applies default colors', () => {
     const kb = buildKeyboard([[{ text: 'Click' }]]);
-    expect(kb[0][0].BG_COLOR).toBe('#29619b');
-    expect(kb[0][0].TEXT_COLOR).toBe('#fff');
+    expect(kb[0]).toMatchObject({ BG_COLOR: '#29619b', TEXT_COLOR: '#fff' });
   });
 
   it('applies custom colors', () => {
     const kb = buildKeyboard([[{ text: 'Click', bgColor: '#333', textColor: '#eee' }]]);
-    expect(kb[0][0].BG_COLOR).toBe('#333');
-    expect(kb[0][0].TEXT_COLOR).toBe('#eee');
+    expect(kb[0]).toMatchObject({ BG_COLOR: '#333', TEXT_COLOR: '#eee' });
   });
 
   it('sets BLOCK=Y when disableAfterClick is true', () => {
     const kb = buildKeyboard([[{ text: 'Once', command: 'once', disableAfterClick: true }]]);
-    expect(kb[0][0].BLOCK).toBe('Y');
+    expect(kb[0]).toMatchObject({ BLOCK: 'Y' });
   });
 });