mostly-tests

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(`[vince] failed; wrong type`);
-      console.log('instance of message:', message.constructor.name);
 
       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;
   }
 

ts/session/types/PubKey.ts

@@ -31,3 +31,4 @@ export class PubKey {
     return key.key === comparator.key;
   }
 }
+

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(
+    // Group Utils Stubs
-      async () =>
+    isMediumGroupStub = sandbox.stub(GroupUtils, 'isMediumGroup').resolves(false);
-        new Promise(r => {
+    groupMembersStub = sandbox.stub(GroupUtils, 'getGroupMembers' as any).callsFake(
-          r(generateMemberList(10));
+      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);
+    const promise = messageQueueStub.sendMessageToDevices(devices, message);
-
+    await expect(promise).to.be.fulfilled;
-    // Failure will make an error; check messageQueueStub.events
   });
 
   it('can send using multidevice', async () => {
     const device = generateFakePubkey();
     const message = generateChatMessage();
 
-    await messageQueueStub.sendUsingMultiDevice(device, message);
+    const promise = messageQueueStub.sendUsingMultiDevice(device, message);
-
+    await expect(promise).to.be.fulfilled;
-    // Failure will make an error; check messageQueueStub.events
   });
 
   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 () => {
+  it('wont send message to empty group', async () => {
-    const message = generateOpenGroupMessage();
+    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 () => {
+  it('will send sync message if no session', async () => {
-    // SHOULD make an error; expect error
+    hasSessionStub.resolves(false);
 
-    // EXAMPLE FROM MESSAGESENDER_TEST
+    const device = generateFakePubkey();
-    // it('should not retry if an error occurred during encryption', async () => {
+    const message = generateChatMessage();
-    //   encryptStub.throws(new Error('Failed to encrypt.'));
+    const promise = messageQueueStub.processPending(device);
-    //   const promise = MessageSender.send(rawMessage);
-    //   await expect(promise).is.rejectedWith('Failed to encrypt.');
-    //   expect(lokiMessageAPIStub.sendMessage.callCount).to.equal(0);
-    // });
 
+    expect(promise).to.be.fulfilled;
   });
 
   it('can send sync message', async () => {

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 { PubKey } from '../../../ts/session/types';
-import { ChatMessage, OpenGroupMessage } from '../../session/messages/outgoing';
+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<PubKey> {
   const numMembers = Math.floor(size);
 

ts/util/user.ts

@@ -15,5 +15,3 @@ export async function getIdentityKeyPair(): Promise<KeyPair | undefined> {
 
   return item?.value;
 }
-
-export async function getOurDevices()