From 73d44d60cf404c64750d4dabdb744cb273ca7905 Mon Sep 17 00:00:00 2001 From: Vincent Date: Tue, 16 Jun 2020 07:44:37 +1000 Subject: [PATCH] mostly-tests --- ts/session/sending/MessageQueue.ts | 16 +- ts/session/types/PubKey.ts | 1 + ts/test/session/sending/MessageQueue_test.ts | 150 +++++++++++-------- ts/test/test-utils/testUtils.ts | 12 +- ts/util/user.ts | 2 - 5 files changed, 105 insertions(+), 76 deletions(-) diff --git a/ts/session/sending/MessageQueue.ts b/ts/session/sending/MessageQueue.ts index f4741ab93..0b2f8fffa 100644 --- a/ts/session/sending/MessageQueue.ts +++ b/ts/session/sending/MessageQueue.ts @@ -19,7 +19,7 @@ import { TypedEventEmitter, } from '../utils'; import { PubKey } from '../types'; -import { MessageSender } from '.'; +import { MessageSender } from './'; import { SessionProtocol } from '../protocols'; import { UserUtil } from '../../util'; @@ -85,8 +85,7 @@ export class MessageQueue implements MessageQueueInterface { !(message instanceof OpenGroupMessage) && !(message instanceof ClosedGroupMessage) ) { - console.log('[vince] NOT INSTANCEOF'); - console.log('instance of message:', message.constructor.name); + console.log(`[vince] failed; wrong type`); return false; } @@ -100,9 +99,13 @@ export class MessageQueue implements MessageQueueInterface { } const recipients = await GroupUtils.getGroupMembers(groupPubKey); - await this.sendMessageToDevices(recipients, message); + console.log('[vince] recipients:', recipients.length); - return true; + if (recipients.length) { + await this.sendMessageToDevices(recipients, message); + + return true; + } } // Open groups @@ -115,15 +118,12 @@ export class MessageQueue implements MessageQueueInterface { } catch (e) { this.events.emit('fail', message, e); - console.log('[vince] EVENT FAILED', message); - return false; } return true; } - console.log('[vince] OTHERWISE FAIELD'); return false; } diff --git a/ts/session/types/PubKey.ts b/ts/session/types/PubKey.ts index f183cb363..e31cb0d41 100644 --- a/ts/session/types/PubKey.ts +++ b/ts/session/types/PubKey.ts @@ -31,3 +31,4 @@ export class PubKey { return key.key === comparator.key; } } + diff --git a/ts/test/session/sending/MessageQueue_test.ts b/ts/test/session/sending/MessageQueue_test.ts index 7c6d4bfa6..f38d9bea8 100644 --- a/ts/test/session/sending/MessageQueue_test.ts +++ b/ts/test/session/sending/MessageQueue_test.ts @@ -9,53 +9,45 @@ import { generateFakePubkey, generateMemberList, generateOpenGroupMessage, + generateClosedGroupMessage, } from '../../test-utils/testUtils'; -import { getGroupMembers } from '../../../session/utils/Groups'; +import { getGroupMembers, isMediumGroup } from '../../../session/utils/Groups'; import { OpenGroupMessage } from '../../../session/messages/outgoing'; -import { RawMessage } from '../../../session/types'; +import { RawMessage, PubKey } from '../../../session/types'; import { UserUtil } from '../../../util'; import { MessageSender } from '../../../session/sending'; -import { sendToOpenGroup } from '../../../session/sending/MessageSender'; +import { toRawMessage } from '../../../session/utils/Messages'; +import { SessionProtocol } from '../../../session/protocols'; +import { PendingMessageCache } from '../../../session/sending/PendingMessageCache'; -// Equivalent to Data.StorageItem -interface StorageItem { - id: string; - value: any; -} describe('MessageQueue', () => { const sandbox = sinon.createSandbox(); const ourNumber = generateFakePubkey().key; + let PendingMessageCacheStub: any; + + // Keep track of Session Requests in each test + let sessionRequestSent: boolean; + // Initialize new stubbed cache - let data: StorageItem; let messageQueueStub: MessageQueue; - + // Message Sender Stubs let sendStub: sinon.SinonStub<[RawMessage, (number | undefined)?]>; let sendToOpenGroupStub: sinon.SinonStub<[OpenGroupMessage]>; + // Group Utils Stubs + let isMediumGroupStub: sinon.SinonStub; + let groupMembersStub: sinon.SinonStub; + // Session Protocol Stubs + let hasSessionStub: sinon.SinonStub; + let sendSessionRequestIfNeededStub: sinon.SinonStub; + // Pending Mesage Cache Stubs + let getForDeviceStub: sinon.SinonStub; + beforeEach(async () => { sandbox.stub(UserUtil, 'getCurrentDevicePubKey').resolves(ourNumber); - // PendingMessageCache stubs - const storageID = 'pendingMessages'; - data = { - id: storageID, - value: '[]', - }; - - TestUtils.stubData('getItemById') - .withArgs('pendingMessages') - .callsFake(async () => { - return data; - }); - - TestUtils.stubData('createOrUpdateItem').callsFake((item: StorageItem) => { - if (item.id === storageID) { - data = item; - } - }); - TestUtils.stubData('getPairedDevicesFor').callsFake(async () => { return generateMemberList(2); }); @@ -65,41 +57,75 @@ describe('MessageQueue', () => { SessionCipher: Stubs.SessionCipherStub, } as any); - // Other stubs - sendStub = sandbox.stub(MessageSender, 'send').resolves(undefined); + + // Message Sender Stubs + sendStub = sandbox.stub(MessageSender, 'send').resolves(); sendToOpenGroupStub = sandbox.stub(MessageSender, 'sendToOpenGroup').resolves(true); - sandbox.stub(GroupUtils, 'getGroupMembers').callsFake( - async () => - new Promise(r => { - r(generateMemberList(10)); - }) + // Group Utils Stubs + isMediumGroupStub = sandbox.stub(GroupUtils, 'isMediumGroup').resolves(false); + groupMembersStub = sandbox.stub(GroupUtils, 'getGroupMembers' as any).callsFake( + async () => generateMemberList(10) ); + // Session Protocol Stubs + hasSessionStub = sandbox.stub(SessionProtocol, 'hasSession').resolves(true); + sendSessionRequestIfNeededStub = sandbox.stub(SessionProtocol, 'sendSessionRequestIfNeeded').callsFake( + async (pubkey: PubKey) => { + pubkey; + sessionRequestSent = true; + } + ); + + // Pending Mesage Cache Stubs + PendingMessageCacheStub = sinon.createStubInstance(PendingMessageCache); + const chatMessages = Array.from({ length: 10 }, generateChatMessage); + getForDeviceStub = sandbox.stub(PendingMessageCacheStub, 'getForDevice').resolves( + chatMessages.map(m => toRawMessage(generateFakePubkey(), m)) + ); + + const rawMessage = toRawMessage(generateFakePubkey(), generateChatMessage()); + sandbox.stub(PendingMessageCacheStub, 'add').resolves(rawMessage); + sandbox.stub(PendingMessageCacheStub, 'remove').resolves(); + sandbox.stub(PendingMessageCacheStub, 'getDevices').resolves(generateMemberList(10)); + + PendingMessageCacheStub.add = sandbox.stub().resolves(rawMessage); + messageQueueStub = new MessageQueue(); }); afterEach(() => { TestUtils.restoreStubs(); sandbox.restore(); + + PendingMessageCacheStub.add.restore(); + PendingMessageCacheStub.remove.restore(); + PendingMessageCacheStub.getDevices.restore(); + PendingMessageCacheStub.getForDevice.restore(); + }); + + it('can send to a single device', async () => { + const device = generateFakePubkey(); + const message = generateChatMessage(); + + const promise = messageQueueStub.send(device, message); + await expect(promise).to.be.fulfilled; }); it('can send to many devices', async () => { const devices = generateMemberList(10); const message = generateChatMessage(); - await messageQueueStub.sendMessageToDevices(devices, message); - - // Failure will make an error; check messageQueueStub.events + const promise = messageQueueStub.sendMessageToDevices(devices, message); + await expect(promise).to.be.fulfilled; }); it('can send using multidevice', async () => { const device = generateFakePubkey(); const message = generateChatMessage(); - await messageQueueStub.sendUsingMultiDevice(device, message); - - // Failure will make an error; check messageQueueStub.events + const promise = messageQueueStub.sendUsingMultiDevice(device, message); + await expect(promise).to.be.fulfilled; }); it('can send to open group', async () => { @@ -107,52 +133,48 @@ describe('MessageQueue', () => { const success = await messageQueueStub.sendToGroup(message); expect(success).to.equal(true, 'sending to group failed'); - - // Failure will make an error; check messageQueueStub.events }); it('can send to closed group', async () => { - const message = generateOpenGroupMessage(); + const message = generateClosedGroupMessage(); const success = await messageQueueStub.sendToGroup(message); expect(success).to.equal(true, 'sending to group failed'); - - // Failure will make an error; check messageQueueStub.events }); - it('can send to open group', async () => { - const message = generateOpenGroupMessage(); + it('wont send message to empty group', async () => { + groupMembersStub.callsFake( + async () => generateMemberList(0) + ); - await messageQueueStub.sendToGroup(message); + const message = generateClosedGroupMessage(); + const response = await messageQueueStub.sendToGroup(message); - // Failure will make an error; check messageQueueStub.events + expect(response).to.equal( + false, + 'sendToGroup send a message to an empty group' + ); }); - it('wont send wrong message type to group', async () => { + it('wont send invalid message type to group', async () => { // Regular chat message should return false const message = generateChatMessage(); - const response = await messageQueueStub.sendToGroup(message); expect(response).to.equal( false, 'sendToGroup considered an invalid message type as valid' ); - - // Failure will make an error; check messageQueueStub.events }); - it("won't process invalid message", async () => { - // SHOULD make an error; expect error + it('will send sync message if no session', async () => { + hasSessionStub.resolves(false); - // EXAMPLE FROM MESSAGESENDER_TEST - // it('should not retry if an error occurred during encryption', async () => { - // encryptStub.throws(new Error('Failed to encrypt.')); - // const promise = MessageSender.send(rawMessage); - // await expect(promise).is.rejectedWith('Failed to encrypt.'); - // expect(lokiMessageAPIStub.sendMessage.callCount).to.equal(0); - // }); + const device = generateFakePubkey(); + const message = generateChatMessage(); + const promise = messageQueueStub.processPending(device); + expect(promise).to.be.fulfilled; }); it('can send sync message', async () => { diff --git a/ts/test/test-utils/testUtils.ts b/ts/test/test-utils/testUtils.ts index 456c8c3ae..0d0f13a23 100644 --- a/ts/test/test-utils/testUtils.ts +++ b/ts/test/test-utils/testUtils.ts @@ -5,8 +5,8 @@ import * as DataShape from '../../../js/modules/data'; import { v4 as uuid } from 'uuid'; import { ImportMock } from 'ts-mock-imports'; -import { PubKey, PubKey } from '../../../ts/session/types'; -import { ChatMessage, OpenGroupMessage } from '../../session/messages/outgoing'; +import { PubKey } from '../../../ts/session/types'; +import { ChatMessage, OpenGroupMessage, ClosedGroupChatMessage } from '../../session/messages/outgoing'; import { OpenGroup } from '../../session/types/OpenGroup'; const sandbox = sinon.createSandbox(); @@ -86,6 +86,14 @@ export function generateOpenGroupMessage(): OpenGroupMessage { }); } +export function generateClosedGroupMessage(): ClosedGroupChatMessage { + return new ClosedGroupChatMessage({ + identifier: uuid(), + groupId: generateFakePubkey().key, + chatMessage: generateChatMessage(), + }); +} + export function generateMemberList(size: number): Array { const numMembers = Math.floor(size); diff --git a/ts/util/user.ts b/ts/util/user.ts index 3808aebea..cea991b17 100644 --- a/ts/util/user.ts +++ b/ts/util/user.ts @@ -15,5 +15,3 @@ export async function getIdentityKeyPair(): Promise { return item?.value; } - -export async function getOurDevices() \ No newline at end of file