it('should parse the locus object and set meeting properties and return null', () => {
meeting.type = 'CALL';
meeting.parseLocus({url: url1, participants: [{id: uuid1}], self: {id: uuid2}});
assert.calledOnce(meeting.setLocus);
assert.calledWith(meeting.setLocus, {url: url1, participants: [{id: uuid1}], self: {id: uuid2}});
assert.calledOnce(MeetingUtil.getLocusPartner);
assert.calledWith(MeetingUtil.getLocusPartner, [{id: uuid1}], {id: uuid2});
assert.deepEqual(meeting.partner, {person: {sipUrl: uuid3}});
assert.equal(meeting.sipUri, uuid3);
});
.then(() => {
assert.calledWith(spark.internal.board.realtime.realtimeChannels.add, {
channelId: channel.channelId,
socketUrl: registrationRes.webSocketUrl,
binding: registrationRes.bindings[0]
});
assert.calledWith(spark.internal.board.realtime.realtimeChannels.get, channel.channelId);
assert.called(mockRealtimeChannel.socket.open);
});
it('should trigger a media:ready event with local stream', () => {
const spy = sinon.spy(meeting, 'trigger');
meeting.mediaProperties.setLocalStream = sinon.stub().returns(true);
meeting.setLocalStream(test1);
assert.calledOnce(spy);
assert.calledWith(spy, 'media:ready', {type: 'local', stream: undefined});
assert.calledOnce(meeting.mediaProperties.setLocalStream);
assert.calledWith(meeting.mediaProperties.setLocalStream, test1);
assert.equal(meeting.mediaProperties.localStream, undefined);
});
.then(() => {
assert.called(offlineSpy);
assert.calledWith(offlineSpy, {code, reason});
switch (action) {
case `close`:
assert.called(permanentSpy);
assert.notCalled(transientSpy);
assert.notCalled(replacedSpy);
break;
case `reconnect`:
assert.notCalled(permanentSpy);
assert.called(transientSpy);
assert.notCalled(replacedSpy);
break;
case `replace`:
assert.notCalled(permanentSpy);
assert.notCalled(transientSpy);
assert.called(replacedSpy);
break;
default:
assert(false, `unreachable code reached`);
}
assert.isFalse(mercury.connected, `Mercury is not connected`);
if (action === `reconnect`) {
assert.called(mercury.connect);
assert.isTrue(mercury.connecting, `Mercury is connecting`);
// Block until reconnect completes so logs don't overlap
return mercury.connect();
}
assert.notCalled(mercury.connect);
assert.isFalse(mercury.connecting, `Mercury is not connecting`);
return Promise.resolve();
});
.then(() => {
assert.called(spy);
assert.calledWith(spy, {
code: 1000,
reason: `Done (forced)`
});
});
it(`requests POST data to registration service`, () => {
assert.calledWith(spark.request, sinon.match({
method: `POST`,
api: `board`,
resource: `/registrations`
}));
});
it('should read the locus object, set on the meeting and return null', () => {
meeting.parseLocus({
mediaConnections: [test1],
locusUrl: url1,
locusId: uuid1,
selfId: uuid2,
mediaId: uuid3,
host: {id: uuid4}
});
assert.calledOnce(meeting.locusInfo.initialSetup);
assert.calledWith(meeting.locusInfo.initialSetup, {
mediaConnections: [test1],
locusUrl: url1,
locusId: uuid1,
selfId: uuid2,
mediaId: uuid3,
host: {id: uuid4}
});
assert.equal(meeting.mediaConnections, test1);
assert.equal(meeting.locusUrl, url1);
assert.equal(meeting.locusId, uuid1);
assert.equal(meeting.selfId, uuid2);
assert.equal(meeting.mediaId, uuid3);
assert.equal(meeting.hostId, uuid4);
});
it('should stop the stream, and trigger a media:stopped event when the local stream stops', async () => {
const spy = sinon.spy(meeting, 'trigger');
Media.stopStream = sinon.stub().returns(Promise.resolve());
await meeting.closeLocalStream();
assert.calledOnce(spy);
assert.calledWith(spy, 'media:stopped', {type: 'local'});
});
it('should trigger a media:ready event with local share stream', () => {
const spy = sinon.spy(meeting, 'trigger');
const track = {};
const getVideoTracks = sinon.stub().returns([track]);
meeting.mediaProperties.setLocalShare = sinon.stub().returns(true);
meeting.mediaProperties.localShare = {getVideoTracks};
meeting.stopShare = sinon.stub().returns(true);
meeting.setLocalShare(test1);
assert.calledOnce(spy);
assert.calledWith(spy, 'media:ready', {type: 'localShare', stream: {getVideoTracks}});
assert.calledOnce(meeting.mediaProperties.setLocalShare);
assert.calledWith(meeting.mediaProperties.setLocalShare, test1);
assert.equal(meeting.mediaProperties.localStream, undefined);
track.onended();
assert.calledOnce(meeting.stopShare);
});
it('listens to the self addmitted guest event', (done) => {
const spy = sinon.spy(meeting, 'trigger');
meeting.locusInfo.emit('SELF_ADMITTED_GUEST', test1);
assert.calledOnce(spy);
assert.calledWith(spy, 'meeting:self:guestAdmitted', {payload: test1});
done();
});
it(`requests POST to channels service`, () => {
assert.calledWith(spark.request, sinon.match({
method: `POST`,
api: `board`,
resource: `/channels`,
body: channelRequestBody
}));
});
it('should proxy members #addMember and return a promise', async () => {
const invite = meeting.invite(uuid1, false);
assert.exists(invite.then);
await invite;
assert.calledOnce(meeting.members.addMember);
assert.calledWith(meeting.members.addMember, uuid1, false);
});
it('should proxy members #admitMembers and return a promise', async () => {
const admit = meeting.members.admitMembers([uuid1]);
assert.exists(admit.then);
await admit;
assert.calledOnce(meeting.members.admitMembers);
assert.calledWith(meeting.members.admitMembers, [uuid1]);
});
it('should stop the stream, and trigger a media:stopped event when the remote stream stops', async () => {
const spy = sinon.spy(meeting, 'trigger');
Media.stopStream = sinon.stub().returns(Promise.resolve());
await meeting.closeRemoteStream();
assert.calledOnce(spy);
assert.calledWith(spy, 'media:stopped', {type: 'remote'});
assert.notOk(meeting.mediaProperties.shareStream);
});
.then(() => assert.calledWith(spark.request, sinon.match({
method: `PUT`,
uri: `${lyraSpace.url}/occupants/@me`,
body: {
pass: {
type: `TEST`
},
deviceUrl: `deviceUrl`
}
}))));
it('should trigger a media:ready event when remote stream track ontrack is fired', () => {
const spy = sinon.spy(meeting, 'trigger');
const pc = {};
meeting.setRemoteStream(pc);
pc.ontrack({streams: [test1]});
assert.calledOnce(spy);
assert.calledWith(spy, 'media:ready', {type: 'remote', stream: test1});
assert.equal(meeting.mediaProperties.remoteStream, test1);
});
it('should set the peer connections', () => {
meeting.mediaProperties.setPeerConnections = sinon.stub().returns(true);
PeerConnectionManager.detectFailures = sinon.stub().returns(true);
meeting.reconnect = sinon.stub().returns(true);
meeting.spark.internal.mercury.on = sinon.stub().returns(true);
meeting.setPeerConnections(test1, test2);
assert.calledOnce(meeting.mediaProperties.setPeerConnections);
assert.calledWith(meeting.mediaProperties.setPeerConnections, test1, test2);
assert.instanceOf(meeting.reconnectionManager, ReconnectionManager);
});
.then(() => {
assert.calledWith(spark.request, sinon.match({
method: `POST`,
uri: `${channel.channelUrl}/register`,
body: {
mercuryConnectionServiceClusterUrl: spark.internal.mercury.localClusterServiceUrls.mercuryConnectionServiceClusterUrl,
webSocketUrl: spark.internal.device.webSocketUrl,
action: `REPLACE`
}
}));
});
it('should return a promise resolution', async () => {
const toggle = sinon.stub().returns(Promise.resolve(true));
meeting.video = {toggle};
const video = meeting.unmuteVideo();
assert.exists(video.then);
await video;
assert.calledOnce(toggle);
assert.calledWith(toggle, {mute: false, self: true});
});
it('should return a promise resolution', async () => {
const toggle = sinon.stub().returns(Promise.resolve(true));
meeting.audio = {toggle};
const audio = meeting.muteAudio();
assert.exists(audio.then);
await audio;
assert.calledOnce(toggle);
assert.calledWith(toggle, {mute: true, self: true});
});
it('places the user in the userstore', () => {
const spy = sinon.stub(userService.store, 'add').returns(Promise.resolve());
const user = {
id: uuid.v4(),
emailAddress: '*****@*****.**'
};
userService.recordUUID(user);
assert.calledWith(spy, user);
});
.then(() => {
assert.called(spark.authorization.initiateAuthorizationCodeGrant);
assert.include(spark.getWindow().location, `response_type=code`);
const query = url.parse(spark.getWindow().location, true).query;
let state = query.state;
state = JSON.parse(base64.decode(state));
assert.property(state, `csrf_token`);
assert.isDefined(state.csrf_token);
assert.match(state.csrf_token, patterns.uuid);
assert.called(spark.getWindow().sessionStorage.setItem);
assert.calledWith(spark.getWindow().sessionStorage.setItem, `oauth2-csrf-token`, state.csrf_token);
});
.then(() => {
assert.called(spark.authorization.initiateAuthorizationCodeGrant);
assert.include(spark.getWindow().location, 'response_type=code');
const {query} = url.parse(spark.getWindow().location, true);
let {state} = query;
state = JSON.parse(base64.decode(state));
assert.property(state, 'csrf_token');
assert.isDefined(state.csrf_token);
assert.match(state.csrf_token, patterns.uuid);
assert.called(spark.getWindow().sessionStorage.setItem);
assert.calledWith(spark.getWindow().sessionStorage.setItem, 'oauth2-csrf-token', state.csrf_token);
});
it(`considers the socket closed if no pong is received in an acceptable time period`, () => {
const spy = sinon.spy();
socket.on(`close`, spy);
mockWebSocket.send = sinon.stub();
socket._ping(id);
clock.tick(2 * mockoptions.pongTimeout);
assert.called(spy);
assert.calledWith(spy, {
code: 1000,
reason: `Pong not received`
});
});
.then(() => {
assert.calledWith(spark.upload, sinon.match({
phases: {
initialize: {
fileSize: 2222
},
finalize: {
body: {
fileSize: 2222
}
}
}
}));
});
it(`emits code ${code} for reason ${reason}`, () => {
const spy = sinon.spy();
socket.on(`close`, spy);
mockWebSocket.emit(`close`, {
code: 1005,
reason
});
assert.called(spy);
assert.calledWith(spy, {
code,
reason
});
});
it('should reconnect and trigger reconnection and return a promise', async () => {
const spy = sinon.spy(meeting, 'trigger');
meeting.reconnectionManager = new ReconnectionManager({config: {reconnection: {retry: {backOff: 1}}}});
meeting.reconnectionManager.reconnect = sinon.stub().returns(Promise.resolve(test1));
meeting.reconnectionManager.reset = sinon.stub().returns(true);
const reconnect = meeting.reconnect();
assert.exists(reconnect.then);
await reconnect;
assert.calledOnce(spy);
assert.calledWith(spy, 'meeting:reconnectionSuccess', {reconnect: test1});
assert.calledOnce(meeting.reconnectionManager.reset);
});
it(`removes authorization data`, () => {
spark.logger.config.level = level;
spark.logger[level]({
headers: {
authorization: `Bearer`,
trackingid: `123`
}
});
assert.calledWith(console[impl(level)], {
headers: {
trackingid: `123`
}
});
});
it(`parses received messages`, () => {
mockWebSocket.emit(`message`, {
data: JSON.stringify({
sequenceNumber: 3,
id: `mockid`
})
});
assert.calledWith(spy, {
data: {
sequenceNumber: 3,
id: `mockid`
}
});
});
it(`acknowledges received messages`, () => {
sinon.spy(socket, `_acknowledge`);
mockWebSocket.emit(`message`, {
data: JSON.stringify({
sequenceNumber: 5,
id: `mockid`
})
});
assert.called(socket._acknowledge);
assert.calledWith(socket._acknowledge, {
data: {
sequenceNumber: 5,
id: `mockid`
}
});
});