Send support for Sender Key

ts/test-electron/SignalProtocolStore_test.ts

@@ -175,6 +175,14 @@ describe('SignalProtocolStore', () => {
       assert.isTrue(
         constantTimeEqual(expected.serialize(), actual.serialize())
       );
+
+      await store.removeSenderKey(encodedAddress, distributionId);
+
+      const postDeleteGet = await store.getSenderKey(
+        encodedAddress,
+        distributionId
+      );
+      assert.isUndefined(postDeleteGet);
     });
 
     it('roundtrips through database', async () => {
@@ -197,6 +205,17 @@ describe('SignalProtocolStore', () => {
       assert.isTrue(
         constantTimeEqual(expected.serialize(), actual.serialize())
       );
+
+      await store.removeSenderKey(encodedAddress, distributionId);
+
+      // Re-fetch from the database to ensure we get the latest database value
+      await store.hydrateCaches();
+
+      const postDeleteGet = await store.getSenderKey(
+        encodedAddress,
+        distributionId
+      );
+      assert.isUndefined(postDeleteGet);
     });
   });
 
@@ -1280,6 +1299,54 @@ describe('SignalProtocolStore', () => {
     });
   });
 
+  describe('getOpenDevices', () => {
+    it('returns all open devices for a number', async () => {
+      const openRecord = getSessionRecord(true);
+      const openDevices = [1, 2, 3, 10].map(deviceId => {
+        return [number, deviceId].join('.');
+      });
+      await Promise.all(
+        openDevices.map(async encodedNumber => {
+          await store.storeSession(encodedNumber, openRecord);
+        })
+      );
+
+      const closedRecord = getSessionRecord(false);
+      await store.storeSession([number, 11].join('.'), closedRecord);
+
+      const result = await store.getOpenDevices([number, 'blah', 'blah2']);
+      assert.deepEqual(result, {
+        devices: [
+          {
+            id: 1,
+            identifier: number,
+          },
+          {
+            id: 2,
+            identifier: number,
+          },
+          {
+            id: 3,
+            identifier: number,
+          },
+          {
+            id: 10,
+            identifier: number,
+          },
+        ],
+        emptyIdentifiers: ['blah', 'blah2'],
+      });
+    });
+
+    it('returns empty array for a number with no device ids', async () => {
+      const result = await store.getOpenDevices(['foo']);
+      assert.deepEqual(result, {
+        devices: [],
+        emptyIdentifiers: ['foo'],
+      });
+    });
+  });
+
   describe('zones', () => {
     const zone = new Zone('zone', {
       pendingSessions: true,

ts/test-electron/util/sendToGroup_test.ts

@@ -0,0 +1,144 @@
+// Copyright 2021 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { assert } from 'chai';
+
+import { _analyzeSenderKeyDevices, _waitForAll } from '../../util/sendToGroup';
+
+import { DeviceType } from '../../textsecure/Types.d';
+
+describe('sendToGroup', () => {
+  describe('#_analyzeSenderKeyDevices', () => {
+    function getDefaultDeviceList(): Array<DeviceType> {
+      return [
+        {
+          identifier: 'ident-guid-one',
+          id: 1,
+        },
+        {
+          identifier: 'ident-guid-one',
+          id: 2,
+        },
+        {
+          identifier: 'ident-guid-two',
+          id: 2,
+        },
+      ];
+    }
+
+    it('returns nothing if new and previous lists are the same', () => {
+      const memberDevices = getDefaultDeviceList();
+      const devicesForSend = getDefaultDeviceList();
+
+      const {
+        newToMemberDevices,
+        newToMemberUuids,
+        removedFromMemberDevices,
+        removedFromMemberUuids,
+      } = _analyzeSenderKeyDevices(memberDevices, devicesForSend);
+
+      assert.isEmpty(newToMemberDevices);
+      assert.isEmpty(newToMemberUuids);
+      assert.isEmpty(removedFromMemberDevices);
+      assert.isEmpty(removedFromMemberUuids);
+    });
+    it('returns set of new devices', () => {
+      const memberDevices = getDefaultDeviceList();
+      const devicesForSend = getDefaultDeviceList();
+
+      memberDevices.pop();
+      memberDevices.pop();
+
+      const {
+        newToMemberDevices,
+        newToMemberUuids,
+        removedFromMemberDevices,
+        removedFromMemberUuids,
+      } = _analyzeSenderKeyDevices(memberDevices, devicesForSend);
+
+      assert.deepEqual(newToMemberDevices, [
+        {
+          identifier: 'ident-guid-one',
+          id: 2,
+        },
+        {
+          identifier: 'ident-guid-two',
+          id: 2,
+        },
+      ]);
+      assert.deepEqual(newToMemberUuids, ['ident-guid-one', 'ident-guid-two']);
+      assert.isEmpty(removedFromMemberDevices);
+      assert.isEmpty(removedFromMemberUuids);
+    });
+    it('returns set of removed devices', () => {
+      const memberDevices = getDefaultDeviceList();
+      const devicesForSend = getDefaultDeviceList();
+
+      devicesForSend.pop();
+      devicesForSend.pop();
+
+      const {
+        newToMemberDevices,
+        newToMemberUuids,
+        removedFromMemberDevices,
+        removedFromMemberUuids,
+      } = _analyzeSenderKeyDevices(memberDevices, devicesForSend);
+
+      assert.isEmpty(newToMemberDevices);
+      assert.isEmpty(newToMemberUuids);
+      assert.deepEqual(removedFromMemberDevices, [
+        {
+          identifier: 'ident-guid-one',
+          id: 2,
+        },
+        {
+          identifier: 'ident-guid-two',
+          id: 2,
+        },
+      ]);
+      assert.deepEqual(removedFromMemberUuids, [
+        'ident-guid-one',
+        'ident-guid-two',
+      ]);
+    });
+    it('returns empty removals if partial send', () => {
+      const memberDevices = getDefaultDeviceList();
+      const devicesForSend = getDefaultDeviceList();
+
+      devicesForSend.pop();
+      devicesForSend.pop();
+
+      const isPartialSend = true;
+      const {
+        newToMemberDevices,
+        newToMemberUuids,
+        removedFromMemberDevices,
+        removedFromMemberUuids,
+      } = _analyzeSenderKeyDevices(
+        memberDevices,
+        devicesForSend,
+        isPartialSend
+      );
+
+      assert.isEmpty(newToMemberDevices);
+      assert.isEmpty(newToMemberUuids);
+      assert.isEmpty(removedFromMemberDevices);
+      assert.isEmpty(removedFromMemberUuids);
+    });
+  });
+
+  describe('#_waitForAll', () => {
+    it('returns nothing if new and previous lists are the same', async () => {
+      const task1 = () => Promise.resolve(1);
+      const task2 = () => Promise.resolve(2);
+      const task3 = () => Promise.resolve(3);
+
+      const result = await _waitForAll({
+        tasks: [task1, task2, task3],
+        maxConcurrency: 1,
+      });
+
+      assert.deepEqual(result, [1, 2, 3]);
+    });
+  });
+});