session-desktop/test/session/unit/utils/Messages_test.js

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
var import_chai = __toESM(require("chai"));
var sinon = __toESM(require("sinon"));
var import_test_utils = require("../../../test-utils");
var import_utils = require("../../../../session/utils");
var import_types = require("../../../../session/types");
var import_ClosedGroupVisibleMessage = require("../../../../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage");
var import_ConfigurationMessage = require("../../../../session/messages/outgoing/controlMessage/ConfigurationMessage");
var import_chai_as_promised = __toESM(require("chai-as-promised"));
var import_ClosedGroupEncryptionPairReplyMessage = require("../../../../session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairReplyMessage");
var import_protobuf = require("../../../../protobuf");
var import_ClosedGroupAddedMembersMessage = require("../../../../session/messages/outgoing/controlMessage/group/ClosedGroupAddedMembersMessage");
var import_ClosedGroupEncryptionPairMessage = require("../../../../session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairMessage");
var import_ClosedGroupNameChangeMessage = require("../../../../session/messages/outgoing/controlMessage/group/ClosedGroupNameChangeMessage");
var import_ClosedGroupNewMessage = require("../../../../session/messages/outgoing/controlMessage/group/ClosedGroupNewMessage");
var import_ClosedGroupRemovedMembersMessage = require("../../../../session/messages/outgoing/controlMessage/group/ClosedGroupRemovedMembersMessage");
import_chai.default.use(import_chai_as_promised.default);
const { expect } = import_chai.default;
describe("Message Utils", () => {
  const sandbox = sinon.createSandbox();
  afterEach(() => {
    sandbox.restore();
  });
  describe("toRawMessage", () => {
    it("can convert to raw message", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const message = import_test_utils.TestUtils.generateVisibleMessage();
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, message);
      expect(Object.keys(rawMessage)).to.have.length(5);
      expect(rawMessage.identifier).to.exist;
      expect(rawMessage.device).to.exist;
      expect(rawMessage.encryption).to.exist;
      expect(rawMessage.plainTextBuffer).to.exist;
      expect(rawMessage.ttl).to.exist;
      expect(rawMessage.identifier).to.equal(message.identifier);
      expect(rawMessage.device).to.equal(device.key);
      expect(rawMessage.plainTextBuffer).to.deep.equal(message.plainTextBuffer());
      expect(rawMessage.ttl).to.equal(message.ttl());
    });
    it("should generate valid plainTextBuffer", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const message = import_test_utils.TestUtils.generateVisibleMessage();
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, message);
      const rawBuffer = rawMessage.plainTextBuffer;
      const rawBufferJSON = JSON.stringify(rawBuffer);
      const messageBufferJSON = JSON.stringify(message.plainTextBuffer());
      expect(rawBuffer instanceof Uint8Array).to.equal(true, "raw message did not contain a plainTextBuffer");
      expect(rawBufferJSON).to.equal(messageBufferJSON, "plainTextBuffer was not converted correctly");
    });
    it("should maintain pubkey", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const message = import_test_utils.TestUtils.generateVisibleMessage();
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, message);
      const derivedPubKey = import_types.PubKey.from(rawMessage.device);
      expect(derivedPubKey).to.exist;
      expect(derivedPubKey == null ? void 0 : derivedPubKey.isEqual(device)).to.equal(true, "pubkey of message was not converted correctly");
    });
    it("should set encryption to ClosedGroup if a ClosedGroupVisibleMessage is passed in", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const groupId = import_test_utils.TestUtils.generateFakePubKey();
      const chatMessage = import_test_utils.TestUtils.generateVisibleMessage();
      const message = new import_ClosedGroupVisibleMessage.ClosedGroupVisibleMessage({ chatMessage, groupId });
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, message);
      expect(rawMessage.encryption).to.equal(import_types.EncryptionType.ClosedGroup);
    });
    it("should set encryption to Fallback on other messages", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const message = import_test_utils.TestUtils.generateVisibleMessage();
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, message);
      expect(rawMessage.encryption).to.equal(import_types.EncryptionType.Fallback);
    });
    it("passing ClosedGroupNewMessage returns Fallback", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const member = import_test_utils.TestUtils.generateFakePubKey().key;
      const msg = new import_ClosedGroupNewMessage.ClosedGroupNewMessage({
        timestamp: Date.now(),
        name: "df",
        members: [member],
        admins: [member],
        groupId: import_test_utils.TestUtils.generateFakePubKey().key,
        keypair: import_test_utils.TestUtils.generateFakeECKeyPair(),
        expireTimer: 0
      });
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, msg);
      expect(rawMessage.encryption).to.equal(import_types.EncryptionType.Fallback);
    });
    it("passing ClosedGroupNameChangeMessage returns ClosedGroup", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const msg = new import_ClosedGroupNameChangeMessage.ClosedGroupNameChangeMessage({
        timestamp: Date.now(),
        name: "df",
        groupId: import_test_utils.TestUtils.generateFakePubKey().key
      });
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, msg);
      expect(rawMessage.encryption).to.equal(import_types.EncryptionType.ClosedGroup);
    });
    it("passing ClosedGroupAddedMembersMessage returns ClosedGroup", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const msg = new import_ClosedGroupAddedMembersMessage.ClosedGroupAddedMembersMessage({
        timestamp: Date.now(),
        addedMembers: [import_test_utils.TestUtils.generateFakePubKey().key],
        groupId: import_test_utils.TestUtils.generateFakePubKey().key
      });
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, msg);
      expect(rawMessage.encryption).to.equal(import_types.EncryptionType.ClosedGroup);
    });
    it("passing ClosedGroupRemovedMembersMessage returns ClosedGroup", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const msg = new import_ClosedGroupRemovedMembersMessage.ClosedGroupRemovedMembersMessage({
        timestamp: Date.now(),
        removedMembers: [import_test_utils.TestUtils.generateFakePubKey().key],
        groupId: import_test_utils.TestUtils.generateFakePubKey().key
      });
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, msg);
      expect(rawMessage.encryption).to.equal(import_types.EncryptionType.ClosedGroup);
    });
    it("passing ClosedGroupEncryptionPairMessage returns ClosedGroup", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const fakeWrappers = new Array();
      fakeWrappers.push(new import_protobuf.SignalService.DataMessage.ClosedGroupControlMessage.KeyPairWrapper({
        publicKey: new Uint8Array(8),
        encryptedKeyPair: new Uint8Array(8)
      }));
      const msg = new import_ClosedGroupEncryptionPairMessage.ClosedGroupEncryptionPairMessage({
        timestamp: Date.now(),
        groupId: import_test_utils.TestUtils.generateFakePubKey().key,
        encryptedKeyPairs: fakeWrappers
      });
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, msg);
      expect(rawMessage.encryption).to.equal(import_types.EncryptionType.ClosedGroup);
    });
    it("passing ClosedGroupEncryptionKeyPairReply returns Fallback", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const fakeWrappers = new Array();
      fakeWrappers.push(new import_protobuf.SignalService.DataMessage.ClosedGroupControlMessage.KeyPairWrapper({
        publicKey: new Uint8Array(8),
        encryptedKeyPair: new Uint8Array(8)
      }));
      const msg = new import_ClosedGroupEncryptionPairReplyMessage.ClosedGroupEncryptionPairReplyMessage({
        timestamp: Date.now(),
        groupId: import_test_utils.TestUtils.generateFakePubKey().key,
        encryptedKeyPairs: fakeWrappers
      });
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, msg);
      expect(rawMessage.encryption).to.equal(import_types.EncryptionType.Fallback);
    });
    it("passing a ConfigurationMessage returns Fallback", async () => {
      const device = import_test_utils.TestUtils.generateFakePubKey();
      const msg = new import_ConfigurationMessage.ConfigurationMessage({
        timestamp: Date.now(),
        activeOpenGroups: [],
        activeClosedGroups: [],
        displayName: "displayName",
        contacts: []
      });
      const rawMessage = await import_utils.MessageUtils.toRawMessage(device, msg);
      expect(rawMessage.encryption).to.equal(import_types.EncryptionType.Fallback);
    });
  });
  describe("getCurrentConfigurationMessage", () => {
    const ourNumber = import_test_utils.TestUtils.generateFakePubKey().key;
    beforeEach(() => {
      sandbox.stub(import_utils.UserUtils, "getOurPubKeyStrFromCache").resolves(ourNumber);
      sandbox.stub(import_utils.UserUtils, "getOurPubKeyFromCache").resolves(import_types.PubKey.cast(ourNumber));
    });
    beforeEach(() => {
      sandbox.restore();
    });
  });
});
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../ts/test/session/unit/utils/Messages_test.ts"],
  "sourcesContent": ["// tslint:disable: no-implicit-dependencies\n\nimport chai from 'chai';\nimport * as sinon from 'sinon';\nimport { TestUtils } from '../../../test-utils';\nimport { MessageUtils, UserUtils } from '../../../../session/utils';\nimport { EncryptionType, PubKey } from '../../../../session/types';\nimport { ClosedGroupVisibleMessage } from '../../../../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';\nimport { ConfigurationMessage } from '../../../../session/messages/outgoing/controlMessage/ConfigurationMessage';\n\nimport chaiAsPromised from 'chai-as-promised';\nchai.use(chaiAsPromised as any);\nimport { ClosedGroupEncryptionPairReplyMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairReplyMessage';\nimport { SignalService } from '../../../../protobuf';\nimport { ClosedGroupAddedMembersMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupAddedMembersMessage';\nimport { ClosedGroupEncryptionPairMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairMessage';\nimport { ClosedGroupNameChangeMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupNameChangeMessage';\nimport { ClosedGroupNewMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupNewMessage';\nimport { ClosedGroupRemovedMembersMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupRemovedMembersMessage';\n\nconst { expect } = chai;\n\ndescribe('Message Utils', () => {\n  const sandbox = sinon.createSandbox();\n\n  afterEach(() => {\n    sandbox.restore();\n  });\n\n  // tslint:disable-next-line: max-func-body-length\n  describe('toRawMessage', () => {\n    it('can convert to raw message', async () => {\n      const device = TestUtils.generateFakePubKey();\n      const message = TestUtils.generateVisibleMessage();\n\n      const rawMessage = await MessageUtils.toRawMessage(device, message);\n\n      expect(Object.keys(rawMessage)).to.have.length(5);\n      expect(rawMessage.identifier).to.exist;\n      expect(rawMessage.device).to.exist;\n      expect(rawMessage.encryption).to.exist;\n      expect(rawMessage.plainTextBuffer).to.exist;\n      expect(rawMessage.ttl).to.exist;\n\n      expect(rawMessage.identifier).to.equal(message.identifier);\n      expect(rawMessage.device).to.equal(device.key);\n      expect(rawMessage.plainTextBuffer).to.deep.equal(message.plainTextBuffer());\n      expect(rawMessage.ttl).to.equal(message.ttl());\n    });\n\n    it('should generate valid plainTextBuffer', async () => {\n      const device = TestUtils.generateFakePubKey();\n      const message = TestUtils.generateVisibleMessage();\n\n      const rawMessage = await MessageUtils.toRawMessage(device, message);\n\n      const rawBuffer = rawMessage.plainTextBuffer;\n      const rawBufferJSON = JSON.stringify(rawBuffer);\n      const messageBufferJSON = JSON.stringify(message.plainTextBuffer());\n\n      expect(rawBuffer instanceof Uint8Array).to.equal(\n        true,\n        'raw message did not contain a plainTextBuffer'\n      );\n      expect(rawBufferJSON).to.equal(\n        messageBufferJSON,\n        'plainTextBuffer was not converted correctly'\n      );\n    });\n\n    it('should maintain pubkey', async () => {\n      const device = TestUtils.generateFakePubKey();\n      const message = TestUtils.generateVisibleMessage();\n\n      const rawMessage = await MessageUtils.toRawMessage(device, message);\n      const derivedPubKey = PubKey.from(rawMessage.device);\n\n      expect(derivedPubKey).to.exist;\n      expect(derivedPubKey?.isEqual(device)).to.equal(\n        true,\n        'pubkey of message was not converted correctly'\n      );\n    });\n\n    it('should set encryption to ClosedGroup if a ClosedGroupVisibleMessage is passed in', async () => {\n      const device = TestUtils.generateFakePubKey();\n      const groupId = TestUtils.generateFakePubKey();\n      const chatMessage = TestUtils.generateVisibleMessage();\n      const message = new ClosedGroupVisibleMessage({ chatMessage, groupId });\n\n      const rawMessage = await MessageUtils.toRawMessage(device, message);\n      expect(rawMessage.encryption).to.equal(EncryptionType.ClosedGroup);\n    });\n\n    it('should set encryption to Fallback on other messages', async () => {\n      const device = TestUtils.generateFakePubKey();\n      const message = TestUtils.generateVisibleMessage();\n      const rawMessage = await MessageUtils.toRawMessage(device, message);\n\n      expect(rawMessage.encryption).to.equal(EncryptionType.Fallback);\n    });\n\n    it('passing ClosedGroupNewMessage returns Fallback', async () => {\n      const device = TestUtils.generateFakePubKey();\n      const member = TestUtils.generateFakePubKey().key;\n\n      const msg = new ClosedGroupNewMessage({\n        timestamp: Date.now(),\n        name: 'df',\n        members: [member],\n        admins: [member],\n        groupId: TestUtils.generateFakePubKey().key,\n        keypair: TestUtils.generateFakeECKeyPair(),\n        expireTimer: 0,\n      });\n      const rawMessage = await MessageUtils.toRawMessage(device, msg);\n      expect(rawMessage.encryption).to.equal(EncryptionType.Fallback);\n    });\n\n    it('passing ClosedGroupNameChangeMessage returns ClosedGroup', async () => {\n      const device = TestUtils.generateFakePubKey();\n\n      const msg = new ClosedGroupNameChangeMessage({\n        timestamp: Date.now(),\n        name: 'df',\n        groupId: TestUtils.generateFakePubKey().key,\n      });\n      const rawMessage = await MessageUtils.toRawMessage(device, msg);\n      expect(rawMessage.encryption).to.equal(EncryptionType.ClosedGroup);\n    });\n\n    it('passing ClosedGroupAddedMembersMessage returns ClosedGroup', async () => {\n      const device = TestUtils.generateFakePubKey();\n\n      const msg = new ClosedGroupAddedMembersMessage({\n        timestamp: Date.now(),\n        addedMembers: [TestUtils.generateFakePubKey().key],\n        groupId: TestUtils.generateFakePubKey().key,\n      });\n      const rawMessage = await MessageUtils.toRawMessage(device, msg);\n      expect(rawMessage.encryption).to.equal(EncryptionType.ClosedGroup);\n    });\n\n    it('passing ClosedGroupRemovedMembersMessage returns ClosedGroup', async () => {\n      const device = TestUtils.generateFakePubKey();\n\n      const msg = new ClosedGroupRemovedMembersMessage({\n        timestamp: Date.now(),\n        removedMembers: [TestUtils.generateFakePubKey().key],\n        groupId: TestUtils.generateFakePubKey().key,\n      });\n      const rawMessage = await MessageUtils.toRawMessage(device, msg);\n      expect(rawMessage.encryption).to.equal(EncryptionType.ClosedGroup);\n    });\n\n    it('passing ClosedGroupEncryptionPairMessage returns ClosedGroup', async () => {\n      const device = TestUtils.generateFakePubKey();\n\n      const fakeWrappers = new Array<\n        SignalService.DataMessage.ClosedGroupControlMessage.KeyPairWrapper\n      >();\n      fakeWrappers.push(\n        new SignalService.DataMessage.ClosedGroupControlMessage.KeyPairWrapper({\n          publicKey: new Uint8Array(8),\n          encryptedKeyPair: new Uint8Array(8),\n        })\n      );\n      const msg = new ClosedGroupEncryptionPairMessage({\n        timestamp: Date.now(),\n        groupId: TestUtils.generateFakePubKey().key,\n        encryptedKeyPairs: fakeWrappers,\n      });\n      const rawMessage = await MessageUtils.toRawMessage(device, msg);\n      expect(rawMessage.encryption).to.equal(EncryptionType.ClosedGroup);\n    });\n\n    it('passing ClosedGroupEncryptionKeyPairReply returns Fallback', async () => {\n      const device = TestUtils.generateFakePubKey();\n\n      const fakeWrappers = new Array<\n        SignalService.DataMessage.ClosedGroupControlMessage.KeyPairWrapper\n      >();\n      fakeWrappers.push(\n        new SignalService.DataMessage.ClosedGroupControlMessage.KeyPairWrapper({\n          publicKey: new Uint8Array(8),\n          encryptedKeyPair: new Uint8Array(8),\n        })\n      );\n      const msg = new ClosedGroupEncryptionPairReplyMessage({\n        timestamp: Date.now(),\n        groupId: TestUtils.generateFakePubKey().key,\n        encryptedKeyPairs: fakeWrappers,\n      });\n      const rawMessage = await MessageUtils.toRawMessage(device, msg);\n      expect(rawMessage.encryption).to.equal(EncryptionType.Fallback);\n    });\n\n    it('passing a ConfigurationMessage returns Fallback', async () => {\n      const device = TestUtils.generateFakePubKey();\n\n      const msg = new ConfigurationMessage({\n        timestamp: Date.now(),\n        activeOpenGroups: [],\n        activeClosedGroups: [],\n        displayName: 'displayName',\n        contacts: [],\n      });\n      const rawMessage = await MessageUtils.toRawMessage(device, msg);\n      expect(rawMessage.encryption).to.equal(EncryptionType.Fallback);\n    });\n  });\n\n  describe('getCurrentConfigurationMessage', () => {\n    const ourNumber = TestUtils.generateFakePubKey().key;\n\n    // let convos: Array<ConversationModel>;\n    // const mockValidOpenGroup = new MockConversation({\n    //   type: ConversationTypeEnum.GROUP,\n    //   id: `${openGroupPrefix}1@chat-dev.lokinet.org`,\n    // });\n\n    // const mockValidOpenGroup2 = new MockConversation({\n    //   type: ConversationTypeEnum.GROUP,\n    //   id: `${openGroupPrefix}1@chat-dev2.lokinet.org`,\n    // });\n\n    // const mockValidClosedGroup = new MockConversation({\n    //   type: ConversationTypeEnum.GROUP,\n    // });\n\n    // const mockValidPrivate = {\n    //   id: TestUtils.generateFakePubKey(),\n    //   isMediumGroup: () => false,\n    //   isPublic: () => false,\n    // };\n\n    beforeEach(() => {\n      // convos = [];\n      sandbox.stub(UserUtils, 'getOurPubKeyStrFromCache').resolves(ourNumber);\n      sandbox.stub(UserUtils, 'getOurPubKeyFromCache').resolves(PubKey.cast(ourNumber));\n    });\n\n    beforeEach(() => {\n      // convos = [];\n      sandbox.restore();\n    });\n\n    // it('filter out non active open groups', async () => {\n    //   // override the first open group and make it inactive\n    //   (mockValidOpenGroup as any).attributes.active_at = undefined;\n\n    //   convos.push(\n    //     mockValidOpenGroup as any,\n    //     mockValidOpenGroup as any,\n    //     mockValidPrivate as any,\n    //     mockValidClosedGroup as any,\n    //     mockValidOpenGroup2 as any\n    //   );\n\n    //   const configMessage = await getCurrentConfigurationMessage(convos);\n    //   expect(configMessage.activeOpenGroups.length).to.equal(1);\n    //   expect(configMessage.activeOpenGroups[0]).to.equal('chat-dev2.lokinet.org');\n    // });\n  });\n});\n"],
  "mappings": "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",
  "names": []
}
