signal-sdk 0.1.0 → 0.1.1

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

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * End-to-end integration tests for complete workflows (Phase 6)
+ * Tests realistic scenarios combining multiple operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+describe('SignalCli - E2E Workflow Tests (Phase 6)', () => {
+    let signal;
+    const mockSendResponse = {
+        timestamp: Date.now(),
+        results: [{ type: 'SUCCESS' }],
+    };
+    beforeEach(() => {
+        signal = new SignalCli_1.SignalCli('+33123456789');
+    });
+    describe('Complete Messaging Workflow', () => {
+        it('should send message with full options and handle response', async () => {
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValue(mockSendResponse);
+            const result = await signal.sendMessage('+33987654321', 'Hello!', {
+                attachments: ['/path/to/image.jpg'],
+                textStyles: [
+                    { start: 0, length: 5, style: 'BOLD' },
+                ],
+                mentions: [
+                    { start: 0, length: 5, number: '+33987654321' },
+                ],
+            });
+            expect(result.timestamp).toBeDefined();
+            expect(result.results).toBeDefined();
+        });
+        it('should send quoted message with attachments', async () => {
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValue(mockSendResponse);
+            const result = await signal.sendMessage('+33987654321', 'Reply', {
+                quote: {
+                    timestamp: 1234567890,
+                    author: '+33111111111',
+                    text: 'Original message',
+                },
+                attachments: ['/path/to/doc.pdf'],
+            });
+            expect(result.timestamp).toBeDefined();
+        });
+    });
+    describe('Contact Management Workflow', () => {
+        it('should manage contacts through complete lifecycle', async () => {
+            const mockContacts = [
+                {
+                    number: '+33111111111',
+                    name: 'Alice',
+                    blocked: false,
+                    givenName: 'Alice',
+                    familyName: 'Smith',
+                },
+                {
+                    number: '+33222222222',
+                    name: 'Bob',
+                    blocked: false,
+                },
+            ];
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce(mockContacts)
+                .mockResolvedValueOnce(undefined)
+                .mockResolvedValueOnce([mockContacts[0]]);
+            const contacts = await signal.getContactsWithProfiles();
+            expect(contacts).toHaveLength(2);
+            expect(contacts[0].profileName).toBe('Alice Smith');
+            await signal.updateContact('+33222222222', 'Bob Johnson');
+            const updated = await signal.listContacts();
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalledTimes(3);
+        });
+    });
+    describe('Group Management Workflow', () => {
+        it('should manage group through complete lifecycle', async () => {
+            const mockGroup = {
+                groupId: 'group123==',
+                name: 'Test Group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 0,
+                members: [
+                    { number: '+33111111111' },
+                    { number: '+33222222222' },
+                ],
+                pendingMembers: [],
+                requestingMembers: [],
+                admins: [{ number: '+33111111111' }],
+                banned: [],
+                permissionAddMember: 'EVERY_MEMBER',
+                permissionEditDetails: 'EVERY_MEMBER',
+                permissionSendMessage: 'EVERY_MEMBER',
+                groupInviteLink: 'https://signal.group/test',
+            };
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce([mockGroup])
+                .mockResolvedValueOnce(undefined)
+                .mockResolvedValueOnce(mockSendResponse)
+                .mockResolvedValueOnce([
+                {
+                    ...mockGroup,
+                    members: [
+                        ...mockGroup.members,
+                        { number: '+33333333333' },
+                    ],
+                },
+            ]);
+            const groups = await signal.getGroupsWithDetails();
+            expect(groups).toHaveLength(1);
+            expect(groups[0].members).toHaveLength(2);
+            await signal.updateGroup('group123==', {
+                addMembers: ['+33333333333'],
+            });
+            await signal.sendMessage('group123==', 'Welcome new member!');
+            const updatedGroups = await signal.listGroups();
+            expect(updatedGroups[0].members).toHaveLength(3);
+        });
+    });
+    describe('Identity Management Workflow', () => {
+        it('should verify safety number before sending', async () => {
+            const mockSafetyNumber = '12345 67890 12345 67890 12345 67890';
+            const mockIdentities = [{
+                    safetyNumber: mockSafetyNumber,
+                    number: '+33987654321',
+                }];
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce(mockIdentities) // listIdentities
+                .mockResolvedValueOnce(mockIdentities) // listIdentities again for verify
+                .mockResolvedValueOnce(undefined) // trust
+                .mockResolvedValueOnce(mockSendResponse); // send
+            const safetyNumberResult = await signal.getSafetyNumber('+33987654321');
+            expect(safetyNumberResult).toBe(mockSafetyNumber);
+            await signal.verifySafetyNumber('+33987654321', mockSafetyNumber);
+            await signal.sendMessage('+33987654321', 'Secure message');
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalledTimes(4);
+        });
+    });
+    describe('Username Management Workflow', () => {
+        it('should manage username lifecycle', async () => {
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce({ username: 'alice.01' })
+                .mockResolvedValueOnce(mockSendResponse)
+                .mockResolvedValueOnce(undefined);
+            const result = await signal.setUsername('alice.01');
+            expect(result.username).toBe('alice.01');
+            await signal.sendMessage('+33987654321', 'You can find me at @alice.01');
+            await signal.deleteUsername();
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalledTimes(3);
+        });
+    });
+    describe('Receive and Process Messages Workflow', () => {
+        it('should receive and process incoming messages', async () => {
+            const mockMessages = [
+                {
+                    envelope: {
+                        source: '+33987654321',
+                        timestamp: Date.now(),
+                        dataMessage: {
+                            message: 'Hello!',
+                            timestamp: Date.now(),
+                        },
+                    },
+                },
+                {
+                    envelope: {
+                        source: '+33111111111',
+                        timestamp: Date.now(),
+                        dataMessage: {
+                            message: 'Hi there!',
+                            timestamp: Date.now(),
+                            groupInfo: {
+                                groupId: 'group123==',
+                            },
+                        },
+                    },
+                },
+            ];
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce(mockMessages)
+                .mockResolvedValueOnce(mockSendResponse)
+                .mockResolvedValueOnce(mockSendResponse);
+            const messages = await signal.receive();
+            expect(messages).toHaveLength(2);
+            // Only send messages if the source/groupId fields exist
+            const msg0 = messages[0];
+            const msg1 = messages[1];
+            if (msg0.envelope && msg0.envelope.source) {
+                await signal.sendMessage(msg0.envelope.source, 'Hello back!');
+            }
+            if (msg1.envelope && msg1.envelope.dataMessage &&
+                msg1.envelope.dataMessage.groupInfo &&
+                msg1.envelope.dataMessage.groupInfo.groupId) {
+                await signal.sendMessage(msg1.envelope.dataMessage.groupInfo.groupId, 'Hi everyone!');
+            }
+            // Verify at least receive was called (message sending depends on data structure)
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalled();
+        });
+    });
+    describe('Multi-Step Group Operations', () => {
+        it('should create group, add members, and send announcement', async () => {
+            const mockGroupId = 'newgroup123==';
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValueOnce({ groupId: mockGroupId })
+                .mockResolvedValueOnce(undefined)
+                .mockResolvedValueOnce(undefined)
+                .mockResolvedValueOnce(mockSendResponse);
+            const createResult = await signal.updateGroup(mockGroupId, {
+                name: 'New Team',
+            });
+            await signal.updateGroup(mockGroupId, {
+                addMembers: ['+33222222222', '+33333333333'],
+            });
+            await signal.updateGroup(mockGroupId, {
+                description: 'Our awesome team workspace',
+            });
+            await signal.sendMessage(mockGroupId, 'Welcome to the team! 🎉');
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalledTimes(4);
+        });
+    });
+    describe('Error Handling in Workflows', () => {
+        it('should handle errors gracefully in message sending workflow', async () => {
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockRejectedValueOnce(new Error('Network error'))
+                .mockResolvedValueOnce(mockSendResponse);
+            await expect(signal.sendMessage('+33987654321', 'Test')).rejects.toThrow('Network error');
+            const result = await signal.sendMessage('+33987654321', 'Test');
+            expect(result.timestamp).toBeDefined();
+        });
+        it('should handle non-existent group in workflow', async () => {
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockResolvedValue([]);
+            const groups = await signal.getGroupsWithDetails();
+            expect(groups).toHaveLength(0);
+            signal.sendJsonRpcRequest = jest.fn()
+                .mockRejectedValue(new Error('Group not found'));
+            await expect(signal.sendMessage('nonexistent==', 'Test')).rejects.toThrow('Group not found');
+        });
+    });
+});

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

@@ -34,7 +34,12 @@ describe('SignalCli Integration Tests', () => {
     afterEach(() => {
         if (signalCli) {
             signalCli.disconnect();
+            // Clean up all listeners
+            signalCli.removeAllListeners();
         }
+        // Clear all timers and mocks
+        jest.clearAllTimers();
+        jest.clearAllMocks();
     });
     describe('Connection Lifecycle', () => {
         it('should handle multiple connect/disconnect cycles', async () => {
@@ -62,11 +67,13 @@ describe('SignalCli Integration Tests', () => {
                 }
             });
             const shutdownPromise = signalCli.gracefulShutdown();
-            // Simulate timeout and force kill
-            setTimeout(() => {
+            // Simulate timeout and force kill with unref to prevent hanging
+            const timer = setTimeout(() => {
                 if (closeCallback)
                     closeCallback(0);
             }, 100);
+            if (timer.unref)
+                timer.unref();
             await expect(shutdownPromise).resolves.toBeUndefined();
         }, 10000); // Increase timeout to 10 seconds
         it('should handle stderr data with different log levels', async () => {

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

@@ -71,7 +71,7 @@ describe('SignalCli Methods Tests', () => {
         it('should send view-once message', async () => {
             await signalCli.sendMessage('+1234567890', 'View once', { isViewOnce: true });
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('send', expect.objectContaining({
-                isViewOnce: true
+                viewOnce: true
             }));
         });
         it('should send reaction', async () => {
@@ -467,4 +467,90 @@ describe('SignalCli Methods Tests', () => {
             }));
         });
     });
+    describe('Phone Number Change Methods', () => {
+        it('should start change number with SMS', async () => {
+            await signalCli.startChangeNumber('+33612345678');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
+                account: '+1234567890',
+                number: '+33612345678',
+                voice: false
+            });
+        });
+        it('should start change number with voice verification', async () => {
+            await signalCli.startChangeNumber('+33612345678', true);
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
+                account: '+1234567890',
+                number: '+33612345678',
+                voice: true
+            });
+        });
+        it('should start change number with captcha', async () => {
+            const captcha = 'captcha_token_12345';
+            await signalCli.startChangeNumber('+33612345678', false, captcha);
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
+                account: '+1234567890',
+                number: '+33612345678',
+                voice: false,
+                captcha
+            });
+        });
+        it('should validate phone number in startChangeNumber', async () => {
+            await expect(signalCli.startChangeNumber('invalid')).rejects.toThrow();
+        });
+        it('should finish change number without PIN', async () => {
+            await signalCli.finishChangeNumber('+33612345678', '123456');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('finishChangeNumber', {
+                account: '+1234567890',
+                number: '+33612345678',
+                verificationCode: '123456'
+            });
+        });
+        it('should finish change number with PIN', async () => {
+            await signalCli.finishChangeNumber('+33612345678', '123456', '1234');
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('finishChangeNumber', {
+                account: '+1234567890',
+                number: '+33612345678',
+                verificationCode: '123456',
+                pin: '1234'
+            });
+        });
+        it('should validate phone number in finishChangeNumber', async () => {
+            await expect(signalCli.finishChangeNumber('invalid', '123456')).rejects.toThrow();
+        });
+        it('should require verification code in finishChangeNumber', async () => {
+            await expect(signalCli.finishChangeNumber('+33612345678', '')).rejects.toThrow('Verification code is required');
+        });
+    });
+    describe('Payment Notification Methods', () => {
+        it('should send payment notification', async () => {
+            const receipt = 'base64EncodedReceipt';
+            const note = 'Thanks for dinner!';
+            const recipient = '+1111111111';
+            sendJsonRpcRequestSpy.mockResolvedValue({ timestamp: 1234567890 });
+            const result = await signalCli.sendPaymentNotification(recipient, { receipt, note });
+            expect(result.timestamp).toBe(1234567890);
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPaymentNotification', {
+                account: '+1234567890',
+                recipient,
+                receipt,
+                note
+            });
+        });
+        it('should send payment notification without note', async () => {
+            const receipt = 'base64EncodedReceipt';
+            const recipient = '+1111111111';
+            await signalCli.sendPaymentNotification(recipient, { receipt });
+            expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('sendPaymentNotification', {
+                account: '+1234567890',
+                recipient,
+                receipt
+            });
+        });
+        it('should validate recipient in sendPaymentNotification', async () => {
+            await expect(signalCli.sendPaymentNotification('invalid', { receipt: 'test' })).rejects.toThrow();
+        });
+        it('should require receipt in sendPaymentNotification', async () => {
+            await expect(signalCli.sendPaymentNotification('+1111111111', { receipt: '' })).rejects.toThrow('Payment receipt is required');
+        });
+    });
 });

package/dist/__tests__/SignalCli.parsing.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for enhanced parsing functionality (Phase 5)
+ * Tests profile and group data parsing methods
+ */
+export {};

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

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Tests for enhanced parsing functionality (Phase 5)
+ * Tests profile and group data parsing methods
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SignalCli_1 = require("../SignalCli");
+describe('SignalCli - Enhanced Parsing (Phase 5)', () => {
+    let signal;
+    beforeEach(() => {
+        signal = new SignalCli_1.SignalCli('+33123456789');
+        // Mock sendJsonRpcRequest to avoid actual signal-cli calls
+        signal.sendJsonRpcRequest = jest.fn();
+    });
+    describe('parseContactProfile', () => {
+        it('should parse contact with full profile data', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John Doe',
+                uuid: 'test-uuid',
+                blocked: false,
+                givenName: 'John',
+                familyName: 'Doe',
+                mobileCoinAddress: 'mc1_test_address_123',
+                profileName: 'John Doe',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.givenName).toBe('John');
+            expect(parsed.familyName).toBe('Doe');
+            expect(parsed.mobileCoinAddress).toBe('mc1_test_address_123');
+            expect(parsed.profileName).toBe('John Doe');
+        });
+        it('should build profileName from givenName and familyName if missing', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John Doe',
+                uuid: 'test-uuid',
+                blocked: false,
+                givenName: 'John',
+                familyName: 'Doe',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.profileName).toBe('John Doe');
+        });
+        it('should use givenName as profileName if no familyName', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John',
+                uuid: 'test-uuid',
+                blocked: false,
+                givenName: 'John',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.profileName).toBe('John');
+        });
+        it('should handle contact with minimal data', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'Unknown',
+                blocked: false,
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.givenName).toBeUndefined();
+            expect(parsed.familyName).toBeUndefined();
+            expect(parsed.mobileCoinAddress).toBeUndefined();
+        });
+        it('should preserve additional contact fields', () => {
+            const contact = {
+                number: '+33123456789',
+                name: 'John Doe',
+                uuid: 'test-uuid',
+                blocked: true,
+                profileAvatar: 'avatar.jpg',
+                color: 'blue',
+                archived: true,
+                mutedUntil: 123456789,
+                hideStory: true,
+                givenName: 'John',
+            };
+            const parsed = signal.parseContactProfile(contact);
+            expect(parsed.blocked).toBe(true);
+            expect(parsed.profileAvatar).toBe('avatar.jpg');
+            expect(parsed.color).toBe('blue');
+            expect(parsed.archived).toBe(true);
+            expect(parsed.mutedUntil).toBe(123456789);
+            expect(parsed.hideStory).toBe(true);
+        });
+    });
+    describe('parseGroupDetails', () => {
+        it('should parse group with full membership data', () => {
+            const group = {
+                groupId: 'group123==',
+                name: 'Test Group',
+                description: 'A test group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 0,
+                members: [
+                    { number: '+33111111111' },
+                    { number: '+33222222222' },
+                ],
+                pendingMembers: [
+                    { number: '+33333333333' },
+                ],
+                requestingMembers: [],
+                admins: [
+                    { number: '+33111111111' },
+                ],
+                banned: [
+                    { number: '+33444444444' },
+                ],
+                permissionAddMember: 'ONLY_ADMINS',
+                permissionEditDetails: 'ONLY_ADMINS',
+                permissionSendMessage: 'EVERY_MEMBER',
+                groupInviteLink: 'https://signal.group/test',
+            };
+            const parsed = signal.parseGroupDetails(group);
+            expect(parsed.pendingMembers).toHaveLength(1);
+            expect(parsed.pendingMembers[0].number).toBe('+33333333333');
+            expect(parsed.banned).toHaveLength(1);
+            expect(parsed.banned[0].number).toBe('+33444444444');
+            expect(parsed.inviteLink).toBe('https://signal.group/test');
+            expect(parsed.groupInviteLink).toBe('https://signal.group/test');
+        });
+        it('should normalize inviteLink field', () => {
+            const group1 = {
+                groupId: 'group123==',
+                name: 'Test Group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 0,
+                members: [],
+                pendingMembers: [],
+                requestingMembers: [],
+                admins: [],
+                banned: [],
+                permissionAddMember: 'EVERY_MEMBER',
+                permissionEditDetails: 'EVERY_MEMBER',
+                permissionSendMessage: 'EVERY_MEMBER',
+                groupInviteLink: 'https://signal.group/test1',
+            };
+            const parsed1 = signal.parseGroupDetails(group1);
+            expect(parsed1.inviteLink).toBe('https://signal.group/test1');
+            expect(parsed1.groupInviteLink).toBe('https://signal.group/test1');
+            const group2 = {
+                ...group1,
+                groupInviteLink: undefined,
+                inviteLink: 'https://signal.group/test2',
+            };
+            const parsed2 = signal.parseGroupDetails(group2);
+            expect(parsed2.inviteLink).toBe('https://signal.group/test2');
+            expect(parsed2.groupInviteLink).toBe('https://signal.group/test2');
+        });
+        it('should ensure membership arrays exist', () => {
+            const group = {
+                groupId: 'group123==',
+                name: 'Minimal Group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 0,
+                members: [],
+                pendingMembers: [],
+                requestingMembers: [],
+                admins: [],
+                banned: [],
+                permissionAddMember: 'EVERY_MEMBER',
+                permissionEditDetails: 'EVERY_MEMBER',
+                permissionSendMessage: 'EVERY_MEMBER',
+            };
+            const parsed = signal.parseGroupDetails(group);
+            expect(Array.isArray(parsed.members)).toBe(true);
+            expect(Array.isArray(parsed.pendingMembers)).toBe(true);
+            expect(Array.isArray(parsed.requestingMembers)).toBe(true);
+            expect(Array.isArray(parsed.admins)).toBe(true);
+            expect(Array.isArray(parsed.banned)).toBe(true);
+        });
+        it('should preserve group permissions', () => {
+            const group = {
+                groupId: 'group123==',
+                name: 'Restricted Group',
+                isMember: true,
+                isBlocked: false,
+                messageExpirationTime: 3600,
+                members: [],
+                pendingMembers: [],
+                requestingMembers: [],
+                admins: [],
+                banned: [],
+                permissionAddMember: 'ONLY_ADMINS',
+                permissionEditDetails: 'ONLY_ADMINS',
+                permissionSendMessage: 'ONLY_ADMINS',
+            };
+            const parsed = signal.parseGroupDetails(group);
+            expect(parsed.permissionAddMember).toBe('ONLY_ADMINS');
+            expect(parsed.permissionEditDetails).toBe('ONLY_ADMINS');
+            expect(parsed.permissionSendMessage).toBe('ONLY_ADMINS');
+            expect(parsed.messageExpirationTime).toBe(3600);
+        });
+    });
+    describe('getContactsWithProfiles', () => {
+        it('should return enriched contacts list', async () => {
+            const mockContacts = [
+                {
+                    number: '+33111111111',
+                    name: 'Alice',
+                    blocked: false,
+                    givenName: 'Alice',
+                    familyName: 'Smith',
+                },
+                {
+                    number: '+33222222222',
+                    name: 'Bob',
+                    blocked: false,
+                    givenName: 'Bob',
+                    mobileCoinAddress: 'mc1_bob',
+                },
+            ];
+            signal.sendJsonRpcRequest = jest.fn().mockResolvedValue(mockContacts);
+            const enriched = await signal.getContactsWithProfiles();
+            expect(enriched).toHaveLength(2);
+            expect(enriched[0].profileName).toBe('Alice Smith');
+            expect(enriched[1].profileName).toBe('Bob');
+            expect(enriched[1].mobileCoinAddress).toBe('mc1_bob');
+        });
+    });
+    describe('getGroupsWithDetails', () => {
+        it('should return enriched groups list', async () => {
+            const mockGroups = [
+                {
+                    groupId: 'group1==',
+                    name: 'Group 1',
+                    isMember: true,
+                    isBlocked: false,
+                    messageExpirationTime: 0,
+                    members: [{ number: '+33111111111' }],
+                    pendingMembers: [{ number: '+33222222222' }],
+                    requestingMembers: [],
+                    admins: [{ number: '+33111111111' }],
+                    banned: [],
+                    permissionAddMember: 'EVERY_MEMBER',
+                    permissionEditDetails: 'EVERY_MEMBER',
+                    permissionSendMessage: 'EVERY_MEMBER',
+                    groupInviteLink: 'https://signal.group/group1',
+                },
+            ];
+            signal.sendJsonRpcRequest = jest.fn().mockResolvedValue(mockGroups);
+            const enriched = await signal.getGroupsWithDetails();
+            expect(enriched).toHaveLength(1);
+            expect(enriched[0].inviteLink).toBe('https://signal.group/group1');
+            expect(enriched[0].pendingMembers).toHaveLength(1);
+        });
+        it('should support list options', async () => {
+            signal.sendJsonRpcRequest = jest.fn().mockResolvedValue([]);
+            await signal.getGroupsWithDetails({ detailed: true });
+            expect(signal.sendJsonRpcRequest).toHaveBeenCalledWith('listGroups', expect.objectContaining({ detailed: true }));
+        });
+    });
+});

package/dist/__tests__/SignalCli.test.js

@@ -155,31 +155,23 @@ describe('SignalCli', () => {
             expect(result).toEqual(mockResponse);
         });
         it('should start change number', async () => {
-            const mockResponse = {
-                session: 'change-session-id',
-                challenge: 'challenge-token'
-            };
             const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
-                .mockResolvedValue(mockResponse);
-            const result = await signalCli.startChangeNumber('+1987654321');
+                .mockResolvedValue({});
+            await signalCli.startChangeNumber('+1987654321');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('startChangeNumber', {
                 account: '+1234567890',
                 number: '+1987654321',
                 voice: false
             });
-            expect(result).toEqual({
-                session: 'change-session-id',
-                newNumber: '+1987654321',
-                challenge: 'challenge-token'
-            });
         });
         it('should finish change number', async () => {
             const sendJsonRpcRequestSpy = jest.spyOn(signalCli, 'sendJsonRpcRequest')
                 .mockResolvedValue({});
-            await signalCli.finishChangeNumber('123456', 'pin-code');
+            await signalCli.finishChangeNumber('+1987654321', '123456', 'pin-code');
             expect(sendJsonRpcRequestSpy).toHaveBeenCalledWith('finishChangeNumber', {
                 account: '+1234567890',
-                code: '123456',
+                number: '+1987654321',
+                verificationCode: '123456',
                 pin: 'pin-code'
             });
         });