.then((reason) => {
assert.instanceOf(reason, AuthorizationError);
assert.match(reason.code, 1008);
assert.match(reason.reason, /Authentication Failed/);
assert.match(reason.message, /Authentication Failed/);
return s.close();
});
.then((reason) => {
assert.instanceOf(reason, ConnectionError);
assert.match(reason.code, 4001);
assert.match(reason.reason, /No/);
assert.match(reason.message, /No/);
return s.close();
});
.then((reason) => {
assert.instanceOf(reason, Forbidden);
assert.match(reason.code, 4403);
assert.match(reason.reason, /Not entitled/);
assert.match(reason.message, /Not entitled/);
return s.close();
});
.then((reason) => {
assert.instanceOf(reason, NotAuthorized);
assert.match(reason.code, 4401);
assert.match(reason.reason, /Authorization Failed/);
assert.match(reason.message, /Authorization Failed/);
return s.close();
});
.then((reason) => {
assert.instanceOf(reason, BadRequest);
assert.match(reason.code, 4400);
assert.match(reason.reason, /Service accounts can't use this endpoint/);
assert.match(reason.message, /Service accounts can't use this endpoint/);
return s.close();
});
it('should create stats if not exists and return WebRTCStats', () => {
assert.notOk(meeting.stats);
meeting.createStats = sinon.stub().returns(new WebRTCStats({}, {parent: spark}));
const stats = meeting.getStats();
assert.calledOnce(meeting.createStats);
assert.instanceOf(stats, WebRTCStats);
});
call.on(`connected`, () => {
try {
assert.instanceOf(call.remoteMediaStream, MediaStream);
resolve();
}
catch (err) {
reject(err);
}
});
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((err) => {
assert.statusCode(err, 400);
assert.throws(() => {
base64.decode(err.body.message.split(`.`)[0]);
});
assert.match(err.toString(), /POST .+\s/);
assert.match(err.toString(), /WEBEX_TRACKING_ID: .+\s/);
assert.match(err.toString(), /KMS_RESPONSE_STATUS: .+\s/);
assert.match(err.toString(), /KMS_REQUEST_ID: .+/);
assert.instanceOf(err, DryError);
}));
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('works', () => {
const key1 = {};
const key2 = 'blarg';
const value = 42;
const M = Map;
const S = Set;
const Container = make(M, M, S);
const c = new Container();
assert.isFalse(c.has(key1, key2, value));
c.set(key1, key2, value);
assert.instanceOf(c.get(key1, key2), Set);
assert.isTrue(c.has(key1, key2, value));
assert.isTrue(c.delete(key1, key2, value));
assert.isFalse(c.has(key1, key2, value));
});
it('should create stats for the meeting object', () => {
const stats = meeting.createStats();
assert.instanceOf(stats, WebRTCStats);
assert.instanceOf(meeting.getStats(), WebRTCStats);
});
await meeting.unmuteVideo().catch((err) => {
assert.instanceOf(err, Error);
});
await meeting.muteAudio().catch((err) => {
assert.instanceOf(err, Error);
});
.then((reason) => assert.instanceOf(reason, SparkHttpError.Conflict)));
.then((reason) => {
assert.instanceOf(reason, SparkHttpError.NotFound);
});
.then((err) => {
assert.instanceOf(err, SparkHttpError);
assert.instanceOf(err, SparkHttpError.BadRequest);
});
it('should get the members object as an instance and return Members', async () => {
const members = meeting.getMembers();
assert.instanceOf(members, Members);
});
.then((stream) => {
assert.instanceOf(stream, MediaStream);
});
.then((reason) => assert.instanceOf(reason, InvalidUserCreation)));