resolves-on-ression-reset

ts/test/session/sending/MessageQueue_test.ts

@@ -32,11 +32,11 @@ describe('MessageQueue', () => {
   let groupMembersStub: sinon.SinonStub;
   // Session Protocol Stubs
   let hasSessionStub: sinon.SinonStub<[PubKey]>;
-  let sendSessionRequestIfNeededStub: sinon.SinonStub<[PubKey]>;
 
   let sessionRequestCalled: boolean;
 
   beforeEach(async () => {
+
     // Stub out methods which touch the database
     const storageID = 'pendingMessages';
     data = {
@@ -73,24 +73,22 @@ describe('MessageQueue', () => {
       .resolves(true);
 
     // Group Utils Stubs
-    sandbox
+    sandbox.stub(GroupUtils, 'isMediumGroup').returns(false);
-      .stub(GroupUtils, 'isMediumGroup')
-      .returns(false);
     groupMembersStub = sandbox
       .stub(GroupUtils, 'getGroupMembers' as any)
       .callsFake(async () => TestUtils.generateMemberList(10));
 
     // Session Protocol Stubs
-    // sessionRequestCalled used instead of sendSessionRequestIfNeededStub.callCount because the call couunt was not registered from methods inside the stubbed MessageQueue.
-    sendSessionRequestIfNeededStub = sandbox.stub(SessionProtocol, 'sendSessionRequestIfNeeded').callsFake(async (pubkey: PubKey) => {
-      pubkey;
-      sessionRequestCalled = true;
-    });
     sandbox.stub(SessionProtocol, 'sendSessionRequest').resolves();
     hasSessionStub = sandbox.stub(SessionProtocol, 'hasSession').resolves(true);
+    sandbox
+      .stub(SessionProtocol, 'sendSessionRequestIfNeeded').resolves();
 
     // Pending Mesage Cache Stubs
-    const chatMessages = Array.from({ length: 10 }, TestUtils.generateChatMessage);
+    const chatMessages = Array.from(
+      { length: 10 },
+      TestUtils.generateChatMessage
+    );
     const rawMessage = toRawMessage(
       TestUtils.generateFakePubkey(),
       TestUtils.generateChatMessage()
@@ -103,23 +101,21 @@ describe('MessageQueue', () => {
       .returns(TestUtils.generateMemberList(10));
     sandbox
       .stub(PendingMessageCache.prototype, 'getForDevice')
-      .returns(chatMessages.map(m => toRawMessage(TestUtils.generateFakePubkey(), m)));
+      .returns(
+        chatMessages.map(m => toRawMessage(TestUtils.generateFakePubkey(), m))
+      );
 
     messageQueueStub = new MessageQueue();
   });
 
   afterEach(() => {
-    sessionRequestCalled = false;
+    console.log('[vince] sessionRequestCalled:', sessionRequestCalled);
 
     TestUtils.restoreStubs();
     sandbox.restore();
-
   });
 
   describe('send', () => {
-    
-  })
-
     it('can send to a single device', async () => {
       const device = TestUtils.generateFakePubkey();
       const message = TestUtils.generateChatMessage();
@@ -128,14 +124,32 @@ describe('MessageQueue', () => {
       await expect(promise).to.be.fulfilled;
     });
 
-  it('can send to many devices', async () => {
+    it('can send sync message', async () => {
-    const devices = TestUtils.generateMemberList(10);
+      const devices = TestUtils.generateMemberList(3);
       const message = TestUtils.generateChatMessage();
 
-    const promise = messageQueueStub.sendMessageToDevices(devices, message);
+      const promise = messageQueueStub.sendSyncMessage(message, devices);
-    await expect(promise).to.be.fulfilled;
+      expect(promise).to.be.fulfilled;
     });
 
+    it('will send sync message if no session', async () => {
+      hasSessionStub.resolves(false);
+
+      const device = TestUtils.generateFakePubkey();
+      const promise = messageQueueStub.processPending(device);
+
+      expect(promise).to.be.fulfilled;
+
+      console.log('[vince] calledd::::', sessionRequestCalled);
+
+      expect(sessionRequestCalled).to.equal(
+        true,
+        'Session request not sent for !isMediumGroup && !hasSession'
+      );
+    });
+  });
+
+  describe('sendUsingMultiDevice', () => {
     it('can send using multidevice', async () => {
       const device = TestUtils.generateFakePubkey();
       const message = TestUtils.generateChatMessage();
@@ -143,6 +157,16 @@ describe('MessageQueue', () => {
       const promise = messageQueueStub.sendUsingMultiDevice(device, message);
       await expect(promise).to.be.fulfilled;
     });
+  });
+
+  describe('sendMessageToDevices', () => {
+    it('can send to many devices', async () => {
+      const devices = TestUtils.generateMemberList(10);
+      const message = TestUtils.generateChatMessage();
+
+      const promise = messageQueueStub.sendMessageToDevices(devices, message);
+      await expect(promise).to.be.fulfilled;
+    });
 
     it('can send to open group', async () => {
       const message = TestUtils.generateOpenGroupMessage();
@@ -180,22 +204,5 @@ describe('MessageQueue', () => {
         'sendToGroup considered an invalid message type as valid'
       );
     });
-
-  it('will send sync message if no session', async () => {
-    hasSessionStub.resolves(false);
-
-    const device = TestUtils.generateFakePubkey();
-    const promise = messageQueueStub.processPending(device);
-
-    expect(promise).to.be.fulfilled;
-    expect(sessionRequestCalled).to.equal(true, 'Session request not sent for !isMediumGroup && !hasSession');
-  });
-
-  it('can send sync message', async () => {
-    const devices = TestUtils.generateMemberList(3);
-    const message = TestUtils.generateChatMessage();
-
-    const promise = messageQueueStub.sendSyncMessage(message, devices);
-    expect(promise).to.be.fulfilled;
   });
 });