it('should have created a meeting object with public properties', () => {
assert.exists(meeting);
assert.exists(meeting.spark);
assert.exists(meeting.options);
assert.exists(meeting.attrs);
assert.exists(meeting.id);
assert.equal(meeting.userId, uuid1);
assert.equal(meeting.resource, uuid2);
assert.equal(meeting.deviceUrl, uuid3);
assert.equal(meeting.roapSeq, -1);
assert.deepEqual(meeting.meetingInfo, {});
assert.instanceOf(meeting.members, Members);
assert.instanceOf(meeting.roap, Roap);
assert.isNull(meeting.reconnectionManager);
assert.isNull(meeting.audio);
assert.isNull(meeting.video);
assert.instanceOf(meeting.meetingFSM, StateMachine);
assert.isNull(meeting.stats);
assert.isNull(meeting.convoId);
assert.equal(meeting.locusUrl, url1);
assert.isNull(meeting.sipUri);
assert.isNull(meeting.partner);
assert.isNull(meeting.type);
assert.isNull(meeting.owner);
assert.isNull(meeting.hostId);
assert.isNull(meeting.policy);
assert.instanceOf(meeting.meetingRequest, MeetingRequest);
assert.instanceOf(meeting.locusInfo, LocusInfo);
assert.instanceOf(meeting.mediaProperties, MediaProperties);
});
it('should acknowledge a non incoming and return a promise', async () => {
const ack = meeting.acknowledge(test1, false);
assert.exists(ack.then);
await ack;
assert.notCalled(meeting.meetingRequest.acknowledgeMeeting);
});
it('should send the share', async () => {
const share = meeting.share();
assert.exists(share.then);
await share;
assert.calledOnce(meeting.meetingRequest.changeMeetingFloor);
});
it('should acknowledge incoming and return a promise', async () => {
const ack = meeting.acknowledge('INCOMING', false);
assert.exists(ack.then);
await ack;
assert.calledOnce(meeting.meetingRequest.acknowledgeMeeting);
});
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 close the peer connections, and return a promise', async () => {
PeerConnectionManager.close = sinon.stub().returns(true);
const pcs = meeting.closePeerConnections();
assert.exists(pcs.then);
await pcs;
assert.calledTwice(PeerConnectionManager.close);
});
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 join the meeting and return promise', async () => {
const join = meeting.join();
assert.exists(join.then);
await join;
assert.calledOnce(meeting.setCorrelationId);
assert.calledOnce(MeetingUtil.cleanOptions);
assert.calledOnce(MeetingUtil.joinMeeting);
assert.calledOnce(meeting.setLocus);
});
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('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('should leave the meeting and return promise', async () => {
const leave = meeting.leave();
assert.exists(leave.then);
await leave;
assert.calledOnce(meeting.meetingRequest.leaveMeeting);
assert.calledOnce(meeting.closeLocalStream);
assert.calledOnce(meeting.closeLocalShare);
assert.calledOnce(meeting.closePeerConnections);
assert.calledOnce(meeting.unsetLocalStream);
assert.calledOnce(meeting.unsetLocalShare);
assert.calledOnce(meeting.unsetRemoteStream);
assert.calledOnce(meeting.unsetPeerConnections);
assert.calledOnce(meeting.roap.stop);
});
it('should attach the media and return promise', async () => {
const media = meeting.addMedia();
assert.exists(media);
await media;
assert.calledOnce(meeting.mediaProperties.setMediaDirection);
assert.calledOnce(meeting.setLocalStream);
assert.calledOnce(meeting.setLocalShare);
assert.calledOnce(Media.attachMedia);
assert.calledOnce(PeerConnectionManager.setContentSlides);
assert.calledOnce(meeting.setPeerConnections);
assert.calledOnce(meeting.setRemoteStream);
assert.calledOnce(meeting.setShareStream);
assert.calledOnce(MeetingUtil.getSdps);
assert.calledOnce(meeting.roap.sendRoapMediaRequest);
});
it('should have #unmuteAudio', () => {
assert.exists(meeting.unmuteAudio);
});
it('should have #isVideoMuted', () => {
assert.exists(meeting.isVideoMuted);
});
it('should have #getMembers', () => {
assert.exists(meeting.getMembers);
});
it('should have #reconnect', () => {
assert.exists(meeting.reconnect);
});
it('should have #unmuteVideo', () => {
assert.exists(meeting.unmuteVideo);
});
it('should have #stopShare', () => {
assert.exists(meeting.stopShare);
});
it('should have #decline', () => {
assert.exists(meeting.decline);
});
it('should have #leave', () => {
assert.exists(meeting.leave);
});
it('should have #isAudioMuted', () => {
assert.exists(meeting.invite);
});
it('should have #getStats', () => {
assert.exists(meeting.getStats);
});
it('should have #acknowledge', () => {
assert.exists(meeting.acknowledge);
});
it('should have #isVideoSelf', () => {
assert.exists(meeting.invite);
});
it('should have #joinWithMedia', () => {
assert.exists(meeting.joinWithMedia);
});
it('should have #getMediaStreams', () => {
assert.exists(meeting.getMediaStreams);
});
it('should have #join', () => {
assert.exists(meeting.join);
});
it('should have #invite', () => {
assert.exists(meeting.invite);
});
it('should have #addMedia', () => {
assert.exists(meeting.addMedia);
});