signal-sdk 0.1.1 → 0.1.3

package/dist/__tests__/SignalBot.coverage.test.js

@@ -0,0 +1,385 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalBot_1 = require("../SignalBot");
+const SignalCli_1 = require("../SignalCli");
+const fs = __importStar(require("fs"));
+const https = __importStar(require("https"));
+const events_1 = require("events");
+jest.mock('../SignalCli');
+jest.mock('fs');
+jest.mock('https');
+jest.mock('http');
+describe('SignalBot Coverage', () => {
+    let bot;
+    let mockSignalCli;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Create a real EventEmitter and mix in mocked SignalCli methods
+        const emitter = new events_1.EventEmitter();
+        mockSignalCli = Object.assign(emitter, {
+            connect: jest.fn(),
+            disconnect: jest.fn(),
+            gracefulShutdown: jest.fn(),
+            listDevices: jest.fn(),
+            sendMessage: jest.fn(),
+            sendReaction: jest.fn(),
+            sendReceipt: jest.fn(),
+            updateGroup: jest.fn(),
+            createGroup: jest.fn(),
+            listGroups: jest.fn(),
+        });
+        SignalCli_1.SignalCli.mockImplementation(() => mockSignalCli);
+        bot = new SignalBot_1.SignalBot({
+            phoneNumber: '+1234567890',
+            admins: ['+admin'],
+            settings: {
+                cooldownSeconds: 1
+            }
+        });
+    });
+    describe('Image Download and Management', () => {
+        it('should download image successfully from URL', async () => {
+            const mockResponse = new events_1.EventEmitter();
+            mockResponse.statusCode = 200;
+            mockResponse.pipe = jest.fn();
+            mockResponse.headers = {};
+            const mockFile = new events_1.EventEmitter();
+            mockFile.close = jest.fn();
+            fs.createWriteStream.mockReturnValue(mockFile);
+            const mockRequest = new events_1.EventEmitter();
+            const getMock = jest.spyOn(https, 'get').mockImplementation((url, cb) => {
+                cb(mockResponse);
+                return mockRequest;
+            });
+            const downloadPromise = bot.downloadImageFromUrl('https://example.com/image.jpg');
+            mockResponse.emit('end');
+            mockFile.emit('finish');
+            const path = await downloadPromise;
+            expect(path).toBeDefined();
+            expect(getMock).toHaveBeenCalled();
+        });
+        it('should handle redirects during image download', async () => {
+            const mockRedirectResponse = new events_1.EventEmitter();
+            mockRedirectResponse.statusCode = 301;
+            mockRedirectResponse.headers = { location: 'https://new-url.com/image.jpg' };
+            const mockSuccessResponse = new events_1.EventEmitter();
+            mockSuccessResponse.statusCode = 200;
+            mockSuccessResponse.pipe = jest.fn();
+            mockSuccessResponse.headers = {};
+            const mockFile = new events_1.EventEmitter();
+            mockFile.close = jest.fn();
+            fs.createWriteStream.mockReturnValue(mockFile);
+            const mockRequest = new events_1.EventEmitter();
+            let callCount = 0;
+            jest.spyOn(https, 'get').mockImplementation((url, cb) => {
+                if (callCount === 0) {
+                    callCount++;
+                    cb(mockRedirectResponse);
+                }
+                else {
+                    cb(mockSuccessResponse);
+                }
+                return mockRequest;
+            });
+            const downloadPromise = bot.downloadImageFromUrl('https://example.com/redirect');
+            mockFile.emit('finish');
+            const path = await downloadPromise;
+            expect(path).toBeDefined();
+        });
+        it('should process base64 avatars', async () => {
+            const base64Avatar = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==';
+            fs.writeFileSync.mockReturnValue(undefined);
+            const result = await bot.processGroupAvatar(base64Avatar);
+            expect(result).toContain('bot_avatar_');
+            expect(fs.writeFileSync).toHaveBeenCalled();
+        });
+        it('should process local file avatars', async () => {
+            fs.existsSync.mockReturnValue(true);
+            const result = await bot.processGroupAvatar('/path/to/avatar.jpg');
+            expect(result).toBe('/path/to/avatar.jpg');
+        });
+    });
+    describe('Message and Command Handling', () => {
+        it('should ignore own messages', async () => {
+            const ownMessage = {
+                envelope: {
+                    sourceNumber: '+1234567890',
+                    dataMessage: { message: 'hello' },
+                    timestamp: Date.now()
+                }
+            };
+            await bot.handleMessage(ownMessage);
+            expect(bot.getStats().messagesReceived).toBe(0);
+        });
+        it('should process authorized group messages', async () => {
+            bot.botGroupId = 'authorized-group';
+            const groupMessage = {
+                envelope: {
+                    sourceNumber: '+someone',
+                    dataMessage: {
+                        message: 'hello',
+                        groupInfo: { groupId: 'authorized-group' }
+                    },
+                    timestamp: Date.now()
+                }
+            };
+            await bot.handleMessage(groupMessage);
+            expect(bot.getStats().messagesReceived).toBe(1);
+        });
+        it('should ignore unauthorized group messages', async () => {
+            bot.botGroupId = 'authorized-group';
+            const groupMessage = {
+                envelope: {
+                    sourceNumber: '+someone',
+                    dataMessage: {
+                        message: 'hello',
+                        groupInfo: { groupId: 'unauthorized-group' }
+                    },
+                    timestamp: Date.now()
+                }
+            };
+            await bot.handleMessage(groupMessage);
+            expect(bot.getStats().messagesReceived).toBe(0);
+        });
+        it('should handle commands with cooldown', async () => {
+            const handler = jest.fn().mockResolvedValue('Response');
+            bot.addCommand({
+                name: 'test',
+                description: 'test',
+                handler
+            });
+            const message = {
+                id: '1',
+                source: '+user',
+                text: '/test',
+                timestamp: Date.now(),
+                isFromAdmin: false
+            };
+            await bot.handleCommand(message);
+            expect(handler).toHaveBeenCalledTimes(1);
+            // Immediate second call should hit cooldown
+            await bot.handleCommand(message);
+            expect(handler).toHaveBeenCalledTimes(1);
+        });
+        it('should enforce adminOnly commands', async () => {
+            const handler = jest.fn().mockResolvedValue('Secret');
+            bot.addCommand({
+                name: 'admincmd',
+                description: 'admin only',
+                adminOnly: true,
+                handler
+            });
+            const message = {
+                id: '1',
+                source: '+user',
+                text: '/admincmd',
+                timestamp: Date.now(),
+                isFromAdmin: false
+            };
+            await bot.handleCommand(message);
+            expect(handler).not.toHaveBeenCalled();
+        });
+    });
+    describe('Action Queue and Process Management', () => {
+        it('should process action queue sequentially', async () => {
+            mockSignalCli.sendMessage.mockResolvedValue({ results: [], timestamp: Date.now() });
+            await bot.sendMessage('+user1', 'msg1');
+            await bot.sendMessage('+user2', 'msg2');
+            // Wait for queue to process
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            expect(mockSignalCli.sendMessage).toHaveBeenCalledTimes(2);
+        });
+        it('should handle sendMessageWithAttachment and cleanup', async () => {
+            jest.useFakeTimers();
+            mockSignalCli.sendMessage.mockResolvedValue({ results: [], timestamp: Date.now() });
+            fs.existsSync.mockReturnValue(true);
+            await bot.sendMessageWithAttachment('+user', 'msg', ['/tmp/file'], ['/tmp/file']);
+            // Allow queue to start processing
+            jest.advanceTimersByTime(100);
+            expect(mockSignalCli.sendMessage).toHaveBeenCalled();
+            // Advance timers to trigger cleanup
+            jest.advanceTimersByTime(2500);
+            expect(fs.unlinkSync).toHaveBeenCalledWith('/tmp/file');
+            jest.useRealTimers();
+        });
+        it('should handle daemon events', () => {
+            const logSpy = jest.spyOn(console, 'log').mockImplementation();
+            bot.setupEventHandlers();
+            mockSignalCli.emit('log', { level: 'info', message: 'test log' });
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('test log'));
+            mockSignalCli.emit('close', 1);
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('error code 1'));
+            logSpy.mockRestore();
+        });
+    });
+    describe('Startup and Shutdown', () => {
+        it('should start gracefully', async () => {
+            mockSignalCli.connect.mockResolvedValue(undefined);
+            mockSignalCli.listDevices.mockResolvedValue([{ id: 1 }]);
+            await bot.start();
+            expect(mockSignalCli.connect).toHaveBeenCalled();
+            expect(bot.getStats()).toBeDefined();
+        });
+        it('should throw error if no devices linked on start', async () => {
+            mockSignalCli.connect.mockResolvedValue(undefined);
+            mockSignalCli.listDevices.mockResolvedValue([]);
+            await expect(bot.start()).rejects.toThrow('link the bot first');
+        });
+        it('should shutdown gracefully', async () => {
+            await bot.gracefulShutdown();
+            expect(mockSignalCli.gracefulShutdown).toHaveBeenCalled();
+        });
+        it('should stop bot and clear timers', async () => {
+            const timer = setTimeout(() => { }, 10000);
+            bot.activeTimers.push(timer);
+            await bot.stop();
+            expect(bot.isRunning).toBe(false);
+            expect(bot.activeTimers.length).toBe(0);
+        });
+    });
+    describe('Group Management', () => {
+        beforeEach(() => {
+            bot = new SignalBot_1.SignalBot({
+                phoneNumber: '+1234567890',
+                admins: ['+admin1'],
+                group: {
+                    name: 'Test Group',
+                    createIfNotExists: true,
+                    initialMembers: ['+member1']
+                }
+            });
+        });
+        it('should setup group and add missing admins if it already exists', async () => {
+            mockSignalCli.listGroups.mockResolvedValue([{
+                    name: 'Test Group',
+                    groupId: 'group-id',
+                    isMember: true,
+                    members: ['+1234567890'] // +admin1 is missing
+                }]);
+            await bot.setupBotGroup();
+            expect(bot.botGroupId).toBe('group-id');
+            expect(mockSignalCli.updateGroup).toHaveBeenCalledWith('group-id', expect.objectContaining({
+                addMembers: ['+admin1']
+            }));
+        });
+        it('should create group if it does not exist', async () => {
+            mockSignalCli.listGroups.mockResolvedValue([]);
+            mockSignalCli.createGroup.mockResolvedValue({
+                groupId: 'new-group-id'
+            });
+            await bot.setupBotGroup();
+            expect(bot.botGroupId).toBe('new-group-id');
+            expect(mockSignalCli.createGroup).toHaveBeenCalled();
+        });
+    });
+    describe('Utility and Helpers', () => {
+        it('should format uptime correctly', () => {
+            const botAny = bot;
+            expect(botAny.formatUptime(1000)).toBe('1s');
+            expect(botAny.formatUptime(61000)).toBe('1m 1s');
+            expect(botAny.formatUptime(3661000)).toBe('1h 1m');
+            expect(botAny.formatUptime(90000000)).toBe('1d 1h 0m');
+        });
+        it('should handle errors in action queue', async () => {
+            const logSpy = jest.spyOn(console, 'log').mockImplementation();
+            mockSignalCli.sendMessage.mockRejectedValue(new Error('Send failed'));
+            await bot.sendMessage('+user', 'test');
+            await new Promise(resolve => setTimeout(resolve, 500));
+            expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to execute action'));
+            logSpy.mockRestore();
+        });
+        it('should send welcome message to admins', async () => {
+            const sendMessageSpy = jest.spyOn(bot, 'sendMessage').mockResolvedValue();
+            await bot.sendWelcomeMessage();
+            expect(sendMessageSpy).toHaveBeenCalled();
+        });
+    });
+    describe('handleMessage edge cases', () => {
+        it('should handle messages with groupInfo variants', async () => {
+            bot.botGroupId = 'target-id';
+            const msg = {
+                envelope: {
+                    sourceNumber: '+someone',
+                    dataMessage: {
+                        message: 'hello',
+                        groupInfo: { id: 'target-id' } // uses 'id' instead of 'groupId'
+                    },
+                    timestamp: Date.now()
+                }
+            };
+            await bot.handleMessage(msg);
+            expect(bot.getStats().messagesReceived).toBe(1);
+        });
+        it('should ignore messages with no text and no attachments', async () => {
+            const msg = {
+                envelope: {
+                    sourceNumber: '+someone',
+                    dataMessage: {
+                        message: '',
+                        attachments: undefined // Use undefined to hit the check
+                    },
+                    timestamp: Date.now()
+                }
+            };
+            await bot.handleMessage(msg);
+            expect(bot.getStats().messagesReceived).toBe(0);
+        });
+    });
+    describe('sendMessageWithImage', () => {
+        it('should download and send image', async () => {
+            const downloadSpy = jest.spyOn(bot, 'downloadImageFromUrl').mockResolvedValue('/tmp/downloaded.jpg');
+            const processQueueSpy = jest.spyOn(bot, 'processActionQueue').mockImplementation();
+            await bot.sendMessageWithImage('+recipient', 'caption', 'https://example.com/img.png');
+            expect(downloadSpy).toHaveBeenCalledWith('https://example.com/img.png', 'bot_image');
+            expect(bot.actionQueue).toContainEqual(expect.objectContaining({
+                type: 'sendMessageWithAttachment',
+                attachments: ['/tmp/downloaded.jpg']
+            }));
+        });
+    });
+    describe('Action Queue edge cases', () => {
+        it('should handle sendReaction action', async () => {
+            await bot.sendReaction('+rec', '+author', 123, '😀');
+            await new Promise(resolve => setTimeout(resolve, 500));
+            expect(mockSignalCli.sendReaction).toHaveBeenCalled();
+        });
+        it('should handle non-data messages', async () => {
+            const msg = { envelope: { receiptMessage: {} } };
+            await bot.handleMessage(msg);
+            expect(bot.getStats().messagesReceived).toBe(0);
+        });
+    });
+});

package/dist/__tests__/SignalBot.test.js

@@ -10,8 +10,8 @@ describe('SignalBot', () => {
             admins: ['+0987654321'],
             group: {
                 name: 'Test Bot Group',
-                createIfNotExists: false
-            }
+                createIfNotExists: false,
+            },
         };
     });
     afterEach(async () => {
@@ -26,7 +26,7 @@ describe('SignalBot', () => {
     });
     test('should create bot with minimal config', () => {
         bot = new SignalBot_1.SignalBot({
-            phoneNumber: '+1234567890'
+            phoneNumber: '+1234567890',
         });
         expect(bot).toBeDefined();
         expect(bot.isAdmin('+1234567890')).toBe(false);
@@ -42,7 +42,7 @@ describe('SignalBot', () => {
         const testCommand = {
             name: 'test',
             description: 'Test command',
-            handler: jest.fn()
+            handler: jest.fn(),
         };
         bot.addCommand(testCommand);
         const commands = bot.getCommands();
@@ -66,13 +66,13 @@ describe('SignalBot', () => {
             phoneNumber: '+1234567890',
             group: {
                 name: 'Test Group',
-                createIfNotExists: false
-            }
+                createIfNotExists: false,
+            },
         });
         // Mock SignalCli methods to avoid actual Signal operations
         const mockSignalCli = bot.getSignalCli();
         jest.spyOn(mockSignalCli, 'listDevices').mockResolvedValue([
-            { id: 1, name: 'Test Device', created: Date.now(), lastSeen: Date.now() }
+            { id: 1, name: 'Test Device', created: Date.now(), lastSeen: Date.now() },
         ]);
         jest.spyOn(mockSignalCli, 'startDaemon').mockImplementation(() => { });
         jest.spyOn(mockSignalCli, 'connect').mockResolvedValue(undefined);
@@ -98,7 +98,7 @@ describe('SignalBot', () => {
     test('should handle admin permissions', () => {
         bot = new SignalBot_1.SignalBot({
             phoneNumber: '+1234567890',
-            admins: ['+0987654321', '+1111111111']
+            admins: ['+0987654321', '+1111111111'],
         });
         expect(bot.isAdmin('+0987654321')).toBe(true);
         expect(bot.isAdmin('+1111111111')).toBe(true);