signal-sdk 0.1.2 → 0.1.3

package/dist/__tests__/SignalCli.events.test.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+// Mock dependencies
+jest.mock('child_process');
+jest.mock('../config', () => ({
+    Logger: jest.fn().mockImplementation(() => ({
+        debug: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+    })),
+    validateConfig: jest.fn().mockReturnValue({
+        verbose: false,
+    }),
+}));
+describe('SignalCli - Advanced Events', () => {
+    let signalCli;
+    const mockAccount = '+1234567890';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        signalCli = new SignalCli_1.SignalCli(mockAccount);
+    });
+    it('should emit "reaction" event when receiving a reaction', (done) => {
+        const reactionPayload = {
+            jsonrpc: '2.0',
+            method: 'receive',
+            params: {
+                envelope: {
+                    source: '+1111111111',
+                    timestamp: 1600000000000,
+                    dataMessage: {
+                        reaction: {
+                            emoji: '👍',
+                            targetAuthor: '+1234567890',
+                            targetSentTimestamp: 1599999999999,
+                            isRemove: false,
+                        },
+                    },
+                },
+            },
+        };
+        signalCli.on('reaction', (event) => {
+            try {
+                expect(event.emoji).toBe('👍');
+                expect(event.sender).toBe('+1111111111');
+                expect(event.targetTimestamp).toBe(1599999999999);
+                done();
+            }
+            catch (error) {
+                done(error);
+            }
+        });
+        // Simulate incoming data
+        signalCli.handleRpcResponse(JSON.stringify(reactionPayload));
+    });
+    it('should emit "receipt" event when receiving a receipt', (done) => {
+        const receiptPayload = {
+            jsonrpc: '2.0',
+            method: 'receive',
+            params: {
+                envelope: {
+                    source: '+2222222222',
+                    timestamp: 1600000000000,
+                    receiptMessage: {
+                        type: 'READ',
+                        timestamps: [1599999999999],
+                        when: 1600000000000,
+                    },
+                },
+            },
+        };
+        signalCli.on('receipt', (event) => {
+            try {
+                expect(event.type).toBe('READ');
+                expect(event.sender).toBe('+2222222222');
+                expect(event.timestamps).toContain(1599999999999);
+                done();
+            }
+            catch (error) {
+                done(error);
+            }
+        });
+        signalCli.handleRpcResponse(JSON.stringify(receiptPayload));
+    });
+    it('should emit "typing" event when receiving typing indicator', (done) => {
+        const typingPayload = {
+            jsonrpc: '2.0',
+            method: 'receive',
+            params: {
+                envelope: {
+                    source: '+3333333333',
+                    timestamp: 1600000000000,
+                    typingMessage: {
+                        action: 'STARTED',
+                        groupId: null,
+                    },
+                },
+            },
+        };
+        signalCli.on('typing', (event) => {
+            try {
+                expect(event.action).toBe('STARTED');
+                expect(event.sender).toBe('+3333333333');
+                done();
+            }
+            catch (error) {
+                done(error);
+            }
+        });
+        signalCli.handleRpcResponse(JSON.stringify(typingPayload));
+    });
+});

package/dist/__tests__/SignalCli.integration.test.js

@@ -121,7 +121,7 @@ describe('SignalCli Integration Tests', () => {
             signalCli.on('error', errorHandler);
             handleRpcResponse('not valid json');
             expect(errorHandler).toHaveBeenCalledWith(expect.objectContaining({
-                message: expect.stringContaining('Failed to parse JSON-RPC response')
+                message: expect.stringContaining('Failed to parse JSON-RPC response'),
             }));
         });
         it('should emit notifications correctly', () => {
@@ -191,15 +191,16 @@ describe('SignalCli Integration Tests', () => {
             jest.spyOn(signalCli, 'sendJsonRpcRequest').mockResolvedValue({});
         });
         it('should handle group message with options', async () => {
-            const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
+            const sendJsonRpcRequestSpy = jest
+                .spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue({ results: [{ type: 'SUCCESS' }], timestamp: 123456 });
             await signalCli.sendMessage('groupId==', 'Group message', {
-                mentions: [{ start: 0, length: 4, number: '+1111111111' }]
+                mentions: [{ start: 0, length: 4, number: '+1111111111' }],
             });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalled();
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
                 message: 'Group message',
-                groupId: 'groupId=='
+                groupId: 'groupId==',
             }));
         });
     });
@@ -218,7 +219,7 @@ describe('SignalCli Integration Tests', () => {
             const errorResponse = '{"jsonrpc":"2.0","id":"error-id","error":{"code":-32600,"message":"Invalid Request"}}';
             handleRpcResponse(errorResponse);
             expect(mockPromise.reject).toHaveBeenCalledWith(expect.objectContaining({
-                message: expect.stringContaining('Invalid Request')
+                message: expect.stringContaining('Invalid Request'),
             }));
         });
     });