Add retrying and tests

ts/session/sending/MessageSender.ts

@@ -6,6 +6,7 @@ import { SignalService } from '../../protobuf';
 import { UserUtil } from '../../util';
 import { MessageEncrypter } from '../crypto';
 import { lokiMessageAPI, lokiPublicChatAPI } from '../../window';
+import pRetry from 'p-retry';
 
 // ================ Regular ================
 
@@ -14,13 +15,10 @@ export function canSendToSnode(): boolean {
   return Boolean(lokiMessageAPI);
 }
 
-export async function send({
+export async function send(
-  device,
+  { device, plainTextBuffer, encryption, timestamp, ttl }: RawMessage,
-  plainTextBuffer,
+  retries: number = 3
-  encryption,
+): Promise<void> {
-  timestamp,
-  ttl,
-}: RawMessage): Promise<void> {
   if (!canSendToSnode()) {
     throw new Error('lokiMessageAPI is not initialized.');
   }
@@ -33,8 +31,14 @@ export async function send({
   const envelope = await buildEnvelope(envelopeType, timestamp, cipherText);
   const data = wrapEnvelope(envelope);
 
-  // TODO: Somehow differentiate between Retryable and Regular erros
+  // pRetry doesn't count the first call as a retry
-  return lokiMessageAPI.sendMessage(device, data, timestamp, ttl);
+  return pRetry(
+    async () => lokiMessageAPI.sendMessage(device, data, timestamp, ttl),
+    {
+      retries: retries - 1,
+      factor: 1,
+    }
+  );
 }
 
 async function buildEnvelope(

ts/test/session/sending/MessageSender_test.ts

@@ -21,11 +21,25 @@ describe('MessageSender', () => {
     TestUtils.restoreStubs();
   });
 
+  describe('canSendToSnode', () => {
+    it('should return the correct value', () => {
+      const stub = TestUtils.stubWindow('lokiMessageAPI', undefined);
+      expect(MessageSender.canSendToSnode()).to.equal(
+        false,
+        'We cannot send if lokiMessageAPI is not set'
+      );
+      stub.set(sandbox.createStubInstance(LokiMessageAPI));
+      expect(MessageSender.canSendToSnode()).to.equal(
+        true,
+        'We can send if lokiMessageAPI is set'
+      );
+    });
+  });
+
   describe('send', () => {
     const ourNumber = 'ourNumber';
     let lokiMessageAPIStub: sinon.SinonStubbedInstance<LokiMessageAPI>;
-    let messageEncyrptReturnEnvelopeType =
+    let encryptStub: sinon.SinonStub<[string, Uint8Array, EncryptionType]>;
-      SignalService.Envelope.Type.CIPHERTEXT;
 
     beforeEach(() => {
       // We can do this because LokiMessageAPI has a module export in it
@@ -34,10 +48,59 @@ describe('MessageSender', () => {
       });
       TestUtils.stubWindow('lokiMessageAPI', lokiMessageAPIStub);
 
+      encryptStub = sandbox.stub(MessageEncrypter, 'encrypt').resolves({
+        envelopeType: SignalService.Envelope.Type.CIPHERTEXT,
+        cipherText: crypto.randomBytes(10),
+      });
+
       sandbox.stub(UserUtil, 'getCurrentDevicePubKey').resolves(ourNumber);
-      sandbox
+    });
-        .stub(MessageEncrypter, 'encrypt')
+
-        .callsFake(async (_device, plainTextBuffer, _type) => ({
+    describe('retry', () => {
+      const rawMessage = {
+        identifier: '1',
+        device: '0',
+        plainTextBuffer: crypto.randomBytes(10),
+        encryption: EncryptionType.Signal,
+        timestamp: Date.now(),
+        ttl: 100,
+      };
+
+      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);
+      });
+
+      it('should only call lokiMessageAPI once if no errors occured', async () => {
+        await MessageSender.send(rawMessage);
+        expect(lokiMessageAPIStub.sendMessage.callCount).to.equal(1);
+      });
+
+      it('should only retry the specified amount of times before throwing', async () => {
+        lokiMessageAPIStub.sendMessage.throws(new Error('API error'));
+        const retries = 2;
+        const promise = MessageSender.send(rawMessage, retries);
+        await expect(promise).is.rejectedWith('API error');
+        expect(lokiMessageAPIStub.sendMessage.callCount).to.equal(retries);
+      });
+
+      it('should not throw error if successful send occurs within the retry limit', async () => {
+        lokiMessageAPIStub.sendMessage
+          .onFirstCall()
+          .throws(new Error('API error'));
+        await MessageSender.send(rawMessage, 3);
+        expect(lokiMessageAPIStub.sendMessage.callCount).to.equal(2);
+      });
+    });
+
+    describe('logic', () => {
+      let messageEncyrptReturnEnvelopeType =
+        SignalService.Envelope.Type.CIPHERTEXT;
+
+      beforeEach(() => {
+        encryptStub.callsFake(async (_device, plainTextBuffer, _type) => ({
           envelopeType: messageEncyrptReturnEnvelopeType,
           cipherText: plainTextBuffer,
         }));
@@ -64,7 +127,8 @@ describe('MessageSender', () => {
       });
 
       it('should correctly build the envelope', async () => {
-      messageEncyrptReturnEnvelopeType = SignalService.Envelope.Type.CIPHERTEXT;
+        messageEncyrptReturnEnvelopeType =
+          SignalService.Envelope.Type.CIPHERTEXT;
 
         // This test assumes the encryption stub returns the plainText passed into it.
         const plainTextBuffer = crypto.randomBytes(10);
@@ -142,6 +206,7 @@ describe('MessageSender', () => {
         });
       });
     });
+  });
 
   describe('sendToOpenGroup', () => {
     it('should send the message to the correct server and channel', async () => {