keejef
/
session-desktop
mirror of https://github.com/oxen-io/session-desktop
2
0
Fork 0
Code Issues 8 Projects Releases Wiki Activity

mostly-tests

Browse Source
pull/1177/head
Vincent 5 years ago
parent 14ca56581c
commit 73d44d60cf
5 changed files with 105 additions and 76 deletions
Show Stats Download Patch File Download Diff File

16
ts/session/sending/MessageQueue.ts
Unescape Escape View File

@ -19,7 +19,7 @@ import {
TypedEventEmitter,
} from '../utils';
import { PubKey } from '../types';
import { MessageSender } from '.';
import { MessageSender } from './';
import { SessionProtocol } from '../protocols';
import { UserUtil } from '../../util';
@ -85,8 +85,7 @@ export class MessageQueue implements MessageQueueInterface {
!(message instanceof OpenGroupMessage) &&
!(message instanceof ClosedGroupMessage)
) {
console.log('[vince] NOT INSTANCEOF');
console.log('instance of message:', message.constructor.name);
console.log(`[vince] failed; wrong type`);
return false;
}
@ -100,9 +99,13 @@ export class MessageQueue implements MessageQueueInterface {
}
const recipients = await GroupUtils.getGroupMembers(groupPubKey);
await this.sendMessageToDevices(recipients, message);
console.log('[vince] recipients:', recipients.length);
return true;
if (recipients.length) {
await this.sendMessageToDevices(recipients, message);
return true;
}
}
// Open groups
@ -115,15 +118,12 @@ export class MessageQueue implements MessageQueueInterface {
} catch (e) {
this.events.emit('fail', message, e);
console.log('[vince] EVENT FAILED', message);
return false;
}
return true;
}
console.log('[vince] OTHERWISE FAIELD');
return false;
}

1
ts/session/types/PubKey.ts
Unescape Escape View File

@ -31,3 +31,4 @@ export class PubKey {
return key.key === comparator.key;
}
}

150
ts/test/session/sending/MessageQueue_test.ts
Unescape Escape View File

@ -9,53 +9,45 @@ import {
generateFakePubkey,
generateMemberList,
generateOpenGroupMessage,
generateClosedGroupMessage,
} from '../../test-utils/testUtils';
import { getGroupMembers } from '../../../session/utils/Groups';
import { getGroupMembers, isMediumGroup } from '../../../session/utils/Groups';
import { OpenGroupMessage } from '../../../session/messages/outgoing';
import { RawMessage } from '../../../session/types';
import { RawMessage, PubKey } from '../../../session/types';
import { UserUtil } from '../../../util';
import { MessageSender } from '../../../session/sending';
import { sendToOpenGroup } from '../../../session/sending/MessageSender';
import { toRawMessage } from '../../../session/utils/Messages';
import { SessionProtocol } from '../../../session/protocols';
import { PendingMessageCache } from '../../../session/sending/PendingMessageCache';
// Equivalent to Data.StorageItem
interface StorageItem {
id: string;
value: any;
}
describe('MessageQueue', () => {
const sandbox = sinon.createSandbox();
const ourNumber = generateFakePubkey().key;
let PendingMessageCacheStub: any;
// Keep track of Session Requests in each test
let sessionRequestSent: boolean;
// Initialize new stubbed cache
let data: StorageItem;
let messageQueueStub: MessageQueue;
// Message Sender Stubs
let sendStub: sinon.SinonStub<[RawMessage, (number | undefined)?]>;
let sendToOpenGroupStub: sinon.SinonStub<[OpenGroupMessage]>;
// Group Utils Stubs
let isMediumGroupStub: sinon.SinonStub;
let groupMembersStub: sinon.SinonStub;
// Session Protocol Stubs
let hasSessionStub: sinon.SinonStub;
let sendSessionRequestIfNeededStub: sinon.SinonStub;
// Pending Mesage Cache Stubs
let getForDeviceStub: sinon.SinonStub;
beforeEach(async () => {
sandbox.stub(UserUtil, 'getCurrentDevicePubKey').resolves(ourNumber);
// PendingMessageCache stubs
const storageID = 'pendingMessages';
data = {
id: storageID,
value: '[]',
};
TestUtils.stubData('getItemById')
.withArgs('pendingMessages')
.callsFake(async () => {
return data;
});
TestUtils.stubData('createOrUpdateItem').callsFake((item: StorageItem) => {
if (item.id === storageID) {
data = item;
}
});
TestUtils.stubData('getPairedDevicesFor').callsFake(async () => {
return generateMemberList(2);
});
@ -65,41 +57,75 @@ describe('MessageQueue', () => {
SessionCipher: Stubs.SessionCipherStub,
} as any);
// Other stubs
sendStub = sandbox.stub(MessageSender, 'send').resolves(undefined);
// Message Sender Stubs
sendStub = sandbox.stub(MessageSender, 'send').resolves();
sendToOpenGroupStub = sandbox.stub(MessageSender, 'sendToOpenGroup').resolves(true);
sandbox.stub(GroupUtils, 'getGroupMembers').callsFake(
async () =>
new Promise(r => {
r(generateMemberList(10));
})
// Group Utils Stubs
isMediumGroupStub = sandbox.stub(GroupUtils, 'isMediumGroup').resolves(false);
groupMembersStub = sandbox.stub(GroupUtils, 'getGroupMembers' as any).callsFake(
async () => generateMemberList(10)
);
// Session Protocol Stubs
hasSessionStub = sandbox.stub(SessionProtocol, 'hasSession').resolves(true);
sendSessionRequestIfNeededStub = sandbox.stub(SessionProtocol, 'sendSessionRequestIfNeeded').callsFake(
async (pubkey: PubKey) => {
pubkey;
sessionRequestSent = true;
}
);
// Pending Mesage Cache Stubs
PendingMessageCacheStub = sinon.createStubInstance(PendingMessageCache);
const chatMessages = Array.from({ length: 10 }, generateChatMessage);
getForDeviceStub = sandbox.stub(PendingMessageCacheStub, 'getForDevice').resolves(
chatMessages.map(m => toRawMessage(generateFakePubkey(), m))
);
const rawMessage = toRawMessage(generateFakePubkey(), generateChatMessage());
sandbox.stub(PendingMessageCacheStub, 'add').resolves(rawMessage);
sandbox.stub(PendingMessageCacheStub, 'remove').resolves();
sandbox.stub(PendingMessageCacheStub, 'getDevices').resolves(generateMemberList(10));
PendingMessageCacheStub.add = sandbox.stub().resolves(rawMessage);
messageQueueStub = new MessageQueue();
});
afterEach(() => {
TestUtils.restoreStubs();
sandbox.restore();
PendingMessageCacheStub.add.restore();
PendingMessageCacheStub.remove.restore();
PendingMessageCacheStub.getDevices.restore();
PendingMessageCacheStub.getForDevice.restore();
});
it('can send to a single device', async () => {
const device = generateFakePubkey();
const message = generateChatMessage();
const promise = messageQueueStub.send(device, message);
await expect(promise).to.be.fulfilled;
});
it('can send to many devices', async () => {
const devices = generateMemberList(10);
const message = generateChatMessage();
await messageQueueStub.sendMessageToDevices(devices, message);
// Failure will make an error; check messageQueueStub.events
const promise = messageQueueStub.sendMessageToDevices(devices, message);
await expect(promise).to.be.fulfilled;
});
it('can send using multidevice', async () => {
const device = generateFakePubkey();
const message = generateChatMessage();
await messageQueueStub.sendUsingMultiDevice(device, message);
// Failure will make an error; check messageQueueStub.events
const promise = messageQueueStub.sendUsingMultiDevice(device, message);
await expect(promise).to.be.fulfilled;
});
it('can send to open group', async () => {
@ -107,52 +133,48 @@ describe('MessageQueue', () => {
const success = await messageQueueStub.sendToGroup(message);
expect(success).to.equal(true, 'sending to group failed');
// Failure will make an error; check messageQueueStub.events
});
it('can send to closed group', async () => {
const message = generateOpenGroupMessage();
const message = generateClosedGroupMessage();
const success = await messageQueueStub.sendToGroup(message);
expect(success).to.equal(true, 'sending to group failed');
// Failure will make an error; check messageQueueStub.events
});
it('can send to open group', async () => {
const message = generateOpenGroupMessage();
it('wont send message to empty group', async () => {
groupMembersStub.callsFake(
async () => generateMemberList(0)
);
await messageQueueStub.sendToGroup(message);
const message = generateClosedGroupMessage();
const response = await messageQueueStub.sendToGroup(message);
// Failure will make an error; check messageQueueStub.events
expect(response).to.equal(
false,
'sendToGroup send a message to an empty group'
);
});
it('wont send wrong message type to group', async () => {
it('wont send invalid message type to group', async () => {
// Regular chat message should return false
const message = generateChatMessage();
const response = await messageQueueStub.sendToGroup(message);
expect(response).to.equal(
false,
'sendToGroup considered an invalid message type as valid'
);
// Failure will make an error; check messageQueueStub.events
});
it("won't process invalid message", async () => {
// SHOULD make an error; expect error
it('will send sync message if no session', async () => {
hasSessionStub.resolves(false);
// EXAMPLE FROM MESSAGESENDER_TEST
// 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);
// });
const device = generateFakePubkey();
const message = generateChatMessage();
const promise = messageQueueStub.processPending(device);
expect(promise).to.be.fulfilled;
});
it('can send sync message', async () => {

12
ts/test/test-utils/testUtils.ts
Unescape Escape View File

@ -5,8 +5,8 @@ import * as DataShape from '../../../js/modules/data';
import { v4 as uuid } from 'uuid';
import { ImportMock } from 'ts-mock-imports';
import { PubKey, PubKey } from '../../../ts/session/types';
import { ChatMessage, OpenGroupMessage } from '../../session/messages/outgoing';
import { PubKey } from '../../../ts/session/types';
import { ChatMessage, OpenGroupMessage, ClosedGroupChatMessage } from '../../session/messages/outgoing';
import { OpenGroup } from '../../session/types/OpenGroup';
const sandbox = sinon.createSandbox();
@ -86,6 +86,14 @@ export function generateOpenGroupMessage(): OpenGroupMessage {
});
}
export function generateClosedGroupMessage(): ClosedGroupChatMessage {
return new ClosedGroupChatMessage({
identifier: uuid(),
groupId: generateFakePubkey().key,
chatMessage: generateChatMessage(),
});
}
export function generateMemberList(size: number): Array<PubKey> {
const numMembers = Math.floor(size);

2
ts/util/user.ts
Unescape Escape View File

@ -15,5 +15,3 @@ export async function getIdentityKeyPair(): Promise<KeyPair | undefined> {
return item?.value;
}
export async function getOurDevices()
Write Preview
Loading…
Cancel
Save