Add more tests

ts/session/crypto/MessageEncrypter.ts

@@ -25,7 +25,7 @@ function getPaddedMessageLength(originalLength: number): number {
   return messagePartCount * 160;
 }
 
-export type Base64String = String;
+export type Base64String = string;
 
 /**
  * Encrypt `plainTextBuffer` with given `encryptionType` for `device`.

ts/test/session/crypto/MessageEncrypter_test.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { ImportMock, MockManager } from 'ts-mock-imports';
+import { ImportMock } from 'ts-mock-imports';
 import * as crypto from 'crypto';
 import * as sinon from 'sinon';
 import * as window from '../../../window';
@@ -7,16 +7,16 @@ import { MessageEncrypter } from '../../../session/crypto';
 import { EncryptionType } from '../../../session/types/EncryptionType';
 import { Stubs } from '../../test-utils';
 import { UserUtil } from '../../../util';
+import { SignalService } from '../../../protobuf';
 
 describe('MessageEncrypter', () => {
   const sandbox = sinon.createSandbox();
+  const ourNumber = 'ourNumber';
 
-  let sessionCipherStub: MockManager<Stubs.SessionCipherBasicStub>;
   beforeEach(() => {
-    sessionCipherStub = ImportMock.mockClass(Stubs, 'SessionCipherBasicStub');
     ImportMock.mockOther(window, 'libsignal', {
       SignalProtocolAddress: sandbox.stub(),
-      SessionCipher: Stubs.SessionCipherBasicStub,
+      SessionCipher: Stubs.SessionCipherStub,
     } as any);
 
     ImportMock.mockOther(window, 'textsecure', {
@@ -25,7 +25,19 @@ describe('MessageEncrypter', () => {
       },
     });
 
-    ImportMock.mockFunction(UserUtil, 'getCurrentDevicePubKey', '1');
+    ImportMock.mockOther(window, 'Signal', {
+      Metadata: {
+        SecretSessionCipher: Stubs.SecretSessionCipherStub,
+      },
+    });
+
+    ImportMock.mockOther(window, 'libloki', {
+      crypto: {
+        FallBackSessionCipher: Stubs.FallBackSessionCipherStub,
+      },
+    });
+
+    ImportMock.mockFunction(UserUtil, 'getCurrentDevicePubKey', ourNumber);
   });
 
   afterEach(() => {
@@ -48,30 +60,106 @@ describe('MessageEncrypter', () => {
       });
     });
 
-    /*
     describe('SessionReset', () => {
-      it('should call FallbackSessionCipher', async () => {
+      it('should call FallbackSessionCipher encrypt', async () => {
+        const data = crypto.randomBytes(10);
+        const spy = sandbox.spy(
+          Stubs.FallBackSessionCipherStub.prototype,
+          'encrypt'
+        );
+        await MessageEncrypter.encrypt('1', data, EncryptionType.SessionReset);
+        expect(spy.called).to.equal(
+          true,
+          'FallbackSessionCipher.encrypt should be called.'
+        );
       });
 
       it('should pass the padded message body to encrypt', async () => {
+        const data = crypto.randomBytes(10);
+        const spy = sandbox.spy(
+          Stubs.FallBackSessionCipherStub.prototype,
+          'encrypt'
+        );
+        await MessageEncrypter.encrypt('1', data, EncryptionType.SessionReset);
+
+        const paddedData = MessageEncrypter.padPlainTextBuffer(data);
+        const firstArgument = new Uint8Array(spy.args[0][0]);
+        expect(firstArgument).to.deep.equal(paddedData);
+      });
+
+      it('should return an UNIDENTIFIED SENDER envelope type', async () => {
+        const data = crypto.randomBytes(10);
+        const result = await MessageEncrypter.encrypt(
+          '1',
+          data,
+          EncryptionType.SessionReset
+        );
+        expect(result.envelopeType).to.deep.equal(
+          SignalService.Envelope.Type.UNIDENTIFIED_SENDER
+        );
       });
     });
-    */
+
     describe('Signal', () => {
       it('should call SessionCipher encrypt', async () => {
         const data = crypto.randomBytes(10);
-        const stub = sessionCipherStub.mock('encrypt').resolves({
-          type: 1,
-          body: 'body',
-        });
+        const spy = sandbox.spy(Stubs.SessionCipherStub.prototype, 'encrypt');
         await MessageEncrypter.encrypt('1', data, EncryptionType.Signal);
-        expect(stub.called).to.equal(
+        expect(spy.called).to.equal(
           true,
           'SessionCipher.encrypt should be called.'
         );
       });
 
-      it('should pass the padded message body to encrypt', async () => {});
+      it('should pass the padded message body to encrypt', async () => {
+        const data = crypto.randomBytes(10);
+        const spy = sandbox.spy(Stubs.SessionCipherStub.prototype, 'encrypt');
+        await MessageEncrypter.encrypt('1', data, EncryptionType.Signal);
+
+        const paddedData = MessageEncrypter.padPlainTextBuffer(data);
+        const firstArgument = new Uint8Array(spy.args[0][0]);
+        expect(firstArgument).to.deep.equal(paddedData);
+      });
+
+      it('should return an UNIDENTIFIED SENDER envelope type', async () => {
+        const data = crypto.randomBytes(10);
+        const result = await MessageEncrypter.encrypt(
+          '1',
+          data,
+          EncryptionType.Signal
+        );
+        expect(result.envelopeType).to.deep.equal(
+          SignalService.Envelope.Type.UNIDENTIFIED_SENDER
+        );
+      });
+    });
+  });
+
+  describe('Sealed Sender', () => {
+    it('should pass the correct values to SecretSessionCipher encrypt', async () => {
+      const types = [EncryptionType.SessionReset, EncryptionType.Signal];
+      for (const type of types) {
+        const spy = sandbox.spy(
+          Stubs.SecretSessionCipherStub.prototype,
+          'encrypt'
+        );
+        await MessageEncrypter.encrypt('user', crypto.randomBytes(10), type);
+
+        const args = spy.args[0];
+        const [device, certificate] = args;
+
+        const expectedCertificate = SignalService.SenderCertificate.create({
+          sender: ourNumber,
+          senderDevice: 1,
+        });
+
+        expect(device).to.equal('user');
+        expect(certificate.toJSON()).to.deep.equal(
+          expectedCertificate.toJSON()
+        );
+
+        spy.restore();
+      }
     });
   });
 });

ts/test/test-utils/stubs/SessionCipherBasicStub.ts

@@ -1,16 +0,0 @@
-import { CipherTextObject } from '../../../window/types/libsignal-protocol';
-
-export class SessionCipherBasicStub {
-  public storage: any;
-  public address: any;
-  constructor(storage: any, address: any) {
-    this.storage = storage;
-    this.address = address;
-  }
-
-  public async encrypt(
-    buffer: ArrayBuffer | Uint8Array
-  ): Promise<CipherTextObject> {
-    throw new Error('Should stub this out');
-  }
-}

ts/test/test-utils/stubs/ciphers/FallBackSessionCipherStub.ts

@@ -0,0 +1,11 @@
+import { CipherTextObject } from '../../../../window/types/libsignal-protocol';
+import { SignalService } from '../../../../protobuf';
+
+export class FallBackSessionCipherStub {
+  public async encrypt(buffer: ArrayBuffer): Promise<CipherTextObject> {
+    return {
+      type: SignalService.Envelope.Type.FRIEND_REQUEST,
+      body: Buffer.from(buffer).toString('binary'),
+    };
+  }
+}

ts/test/test-utils/stubs/ciphers/SecretSessionCipherStub.ts

@@ -0,0 +1,26 @@
+import { SignalService } from '../../../../protobuf';
+import { CipherTextObject } from '../../../../window/types/libsignal-protocol';
+
+export class SecretSessionCipherStub {
+  public async encrypt(
+    _destinationPubkey: string,
+    _senderCertificate: SignalService.SenderCertificate,
+    innerEncryptedMessage: CipherTextObject
+  ): Promise<ArrayBuffer> {
+    const { body } = innerEncryptedMessage;
+
+    return Buffer.from(body, 'binary').buffer;
+  }
+
+  public async decrypt(
+    _cipherText: ArrayBuffer,
+    _me: { number: string; deviceId: number }
+  ): Promise<{
+    isMe?: boolean;
+    sender: string;
+    content: ArrayBuffer;
+    type: SignalService.Envelope.Type;
+  }> {
+    throw new Error('Not implemented');
+  }
+}

ts/test/test-utils/stubs/ciphers/SessionCipherStub.ts

@@ -0,0 +1,20 @@
+import { CipherTextObject } from '../../../../window/types/libsignal-protocol';
+import { SignalService } from '../../../../protobuf';
+
+export class SessionCipherStub {
+  public storage: any;
+  public address: any;
+  constructor(storage: any, address: any) {
+    this.storage = storage;
+    this.address = address;
+  }
+
+  public async encrypt(
+    buffer: ArrayBuffer | Uint8Array
+  ): Promise<CipherTextObject> {
+    return {
+      type: SignalService.Envelope.Type.CIPHERTEXT,
+      body: Buffer.from(buffer).toString('binary'),
+    };
+  }
+}

ts/test/test-utils/stubs/ciphers/index.ts

@@ -0,0 +1,3 @@
+export * from './SessionCipherStub';
+export * from './SecretSessionCipherStub';
+export * from './FallBackSessionCipherStub';

ts/test/test-utils/stubs/index.ts

@@ -1 +1 @@
-export * from './SessionCipherBasicStub';
+export * from './ciphers';

ts/window/types/libsignal-protocol.ts

@@ -1,6 +1,6 @@
 import { SignalService } from '../../protobuf';
 
-export type BinaryString = String;
+export type BinaryString = string;
 
 export type CipherTextObject = {
   type: SignalService.Envelope.Type;