.then(() => {
assert.notCalled(spark.internal.device.refresh);
clock.tick(config.device.ephemeralDeviceTTL / 2 * 1000);
assert.notCalled(spark.internal.device.refresh);
return promiseTick(80);
})
nodeOnly(it)(`logs at TRACE in test environments`, () => {
console.trace.restore();
sinon.stub(console, `trace`);
process.env.NODE_ENV = undefined;
assert.notCalled(console.trace);
spark.logger.trace(`test`);
assert.notCalled(console.trace);
process.env.NODE_ENV = `test`;
spark.logger.trace(`test`);
assert.called(console.trace);
});
.then(() => {
spark.internal.device.url = `http://example.com/device/id`;
assert.notCalled(spark.internal.device.refresh);
clock.tick(config.device.ephemeralDeviceTTL / 2 * 1000);
assert.notCalled(spark.internal.device.refresh);
clock.tick(60 * 1000);
assert.calledOnce(spark.internal.device.refresh);
spark.internal.device.unregister();
// Reminder: for this to be a valid test, the number of ticks on
// the next line must be at least as many ticks as are advanced in
// the refresh test.
return promiseTick(4);
})
it(`triggers a token refresh`, () => {
socketOpenStub.restore();
socketOpenStub = sinon.stub(Socket.prototype, `open`).returns(Promise.resolve());
socketOpenStub.onCall(0).returns(Promise.reject(new NotAuthorized({code: 4401})));
assert.notCalled(spark.credentials.refresh);
assert.notCalled(spark.internal.device.refresh);
const promise = mercury.connect();
return promiseTick(7)
.then(() => {
assert.called(spark.credentials.refresh);
assert.notCalled(spark.internal.device.refresh);
clock.tick(1000);
return assert.isFulfilled(promise);
});
});
nodeOnly(it)(`defaults to "error" for all other users`, () => {
spark.logger.error(`test`);
assert.called(console.error);
spark.logger.warn(`test`);
assert.notCalled(console.warn);
});
it(`emits pongs separately from other messages`, () => {
const pongSpy = sinon.spy();
socket.on(`pong`, pongSpy);
mockWebSocket.emit(`message`, {
data: JSON.stringify({
sequenceNumber: 5,
id: `mockid1`,
type: `pong`
})
});
assert.calledOnce(pongSpy);
assert.notCalled(spy);
mockWebSocket.emit(`message`, {
data: JSON.stringify({
sequenceNumber: 6,
id: `mockid2`
})
});
assert.calledOnce(pongSpy);
assert.calledOnce(spy);
});
it('should error out and return a promise', async () => {
meeting.join = sinon.stub().returns(Promise.reject());
meeting.getMediaStreams = sinon.stub().returns(true);
await meeting.joinWithMedia();
assert.calledOnce(meeting.join);
assert.notCalled(meeting.getMediaStreams);
});
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);
});
browserOnly(it)(`refreshes the access token and replays the request`, () => {
spark.config.credentials.refreshCallback = sinon.stub().returns(Promise.resolve({
access_token: `ST2`
}));
spark.credentials.supertoken = new Token({
access_token: `ST1`,
refresh_token: `RT1`
}, {parent: spark});
const err = new SparkHttpError.Unauthorized({
statusCode: 401,
options: {
headers: {
trackingid: `blarg`
},
uri: `${config.device.preDiscoveryServices.hydraServiceUrl}/ping`
},
body: {
error: `fake error`
}
});
assert.notCalled(spark.request);
return interceptor.onResponseError(err.options, err)
.then(() => {
// once for replay
assert.calledOnce(spark.request);
assert.equal(spark.credentials.supertoken.access_token, `ST2`);
assert.equal(spark.request.args[0][0].replayCount, 1);
});
});
.then(() => {
assert.isTrue(mercury.connected, `Mercury is connected`);
assert.isFalse(mercury.connecting, `Mercury is not connecting`);
assert.notCalled(spy);
mockWebSocket.emit(`message`, {data: statusStartTypingMessage});
})
it(`does not refresh if shouldRefreshAccessToken was false`, () => {
spark.config.credentials.refreshCallback = sinon.stub().returns(Promise.resolve({
access_token: `ST2`
}));
spark.credentials.supertoken = new Token({
access_token: `ST1`,
refresh_token: `RT1`
}, {parent: spark});
const err = new SparkHttpError.Unauthorized({
statusCode: 401,
options: {
headers: {
trackingid: `blarg`
},
uri: `${config.device.preDiscoveryServices.hydraServiceUrl}/ping`,
shouldRefreshAccessToken: false
},
body: {
error: `fake error`
}
});
assert.notCalled(spark.request);
return assert.isRejected(interceptor.onResponseError(err.options, err))
.then((err2) => {
assert.equal(err2, err);
});
});
skipInBrowser(it)(`fails after \`maxRetries\` attempts`, () => {
mercury.config.maxRetries = 2;
socketOpenStub.restore();
socketOpenStub = sinon.stub(Socket.prototype, `open`);
socketOpenStub.returns(Promise.reject(new ConnectionError()));
assert.notCalled(Socket.prototype.open);
const promise = mercury.connect();
return promiseTick(4)
.then(() => {
assert.calledOnce(Socket.prototype.open);
return promiseTick(4);
})
.then(() => {
clock.tick(mercury.config.backoffTimeReset);
return promiseTick(4);
})
.then(() => {
assert.calledTwice(Socket.prototype.open);
clock.tick(2 * mercury.config.backoffTimeReset);
return promiseTick(4);
})
.then(() => {
assert.calledThrice(Socket.prototype.open);
clock.tick(4 * mercury.config.backoffTimeReset);
return assert.isRejected(promise);
})
.then(() => {
assert.calledThrice(Socket.prototype.open);
});
});
.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();
});
it(`does not add a tracking id if one is already specified`, () => {
const spy = sinon.spy(interceptor, `_generateTrackingId`);
interceptor.onRequest({
headers: {
trackingid: `some id`
}
});
assert.notCalled(spy);
});
it(`lazily registers the device`, () => {
spark.internal.device.registered = false;
assert.notCalled(spark.internal.device.register);
const promise = mercury.connect();
mockWebSocket.open();
return promise
.then(() => {
assert.calledOnce(spark.internal.device.register);
});
});
it(`stops further ping checks`, () => {
socket._ping.reset();
assert.notCalled(socket._ping);
const spy = sinon.spy();
assert.notCalled(socket._ping);
socket.on(`close`, spy);
assert.notCalled(socket._ping);
socket._ping();
assert.calledOnce(socket._ping);
mockWebSocket.emit(`close`, {
code: 1000,
reason: `Done`
});
assert.calledOnce(socket._ping);
clock.tick(5 * mockoptions.pingInterval);
assert.neverCalledWith(spy, {
code: 1000,
reason: `Pong not received`
});
assert.calledOnce(socket._ping);
});
assert.doesNotThrow(() => {
assert.notCalled(console.info);
spark.logger.info(`test`);
assert.notCalled(console.info);
spark.internal.device = {
features: {
developer: {
get() {
return `not-a-log-method`;
}
},
entitlement: {
get() {
return false;
}
}
}
};
spark.logger.info(`test`);
assert.notCalled(console.info);
});
nodeOnly(it)(`checks the developer feature toggle "log-level" when available`, () => {
assert.notCalled(console.info);
spark.logger.info(`test`);
assert.notCalled(console.info);
spark.internal.device = {
features: {
developer: {
get() {
return `info`;
}
},
entitlement: {
get() {
return false;
}
}
}
};
spark.logger.info(`test`);
assert.called(console.info);
});
.then((realtimeChannel) => {
realtime2 = realtimeChannel;
realtime1._emit = sinon.stub();
realtime2._emit = sinon.stub();
spark.internal.board.realtime.handleBoardActivityMessages(boardEvent);
boardEvent.data.envelope.channelId = 3;
spark.internal.board.realtime.handleBoardActivityMessages(boardEvent);
assert.calledOnce(realtime1._emit);
assert.notCalled(realtime2._emit);
sinon.stub(spark.internal.board.realtime.realtimeChannels, 'get');
sinon.stub(spark.internal.board.realtime.realtimeChannels, 'add');
sinon.stub(spark.internal.board.realtime.realtimeChannels, 'remove');
});
process.nextTick(() => {
assert.isTrue(mercury.connecting, `Mercury is still connecting`);
assert.isFalse(mercury.connected, `Mercury has not yet connected`);
assert.notCalled(onlineSpy, `Mercury has not yet fired the online event`);
mockWebSocket.emit(`message`, {
data: JSON.stringify({
data: {
eventType: `mercury.buffer_state`
}
})
});
promiseTick(1)
.then(() => {
assert.calledOnce(bufferStateSpy);
done();
})
.catch(done);
});
it(`emits skipped sequence numbers`, () => {
const spy2 = sinon.spy();
socket.on(`sequence-mismatch`, spy2);
mockWebSocket.emit(`message`, {
data: JSON.stringify({
sequenceNumber: 2,
id: `mockid`
})
});
assert.notCalled(spy2);
mockWebSocket.emit(`message`, {
data: JSON.stringify({
sequenceNumber: 4,
id: `mockid`
})
});
assert.calledOnce(spy2);
assert.calledWith(spy2, 4, 3);
});
it('sends encrypted data on the socket', () => {
assert.notCalled(spark.internal.encryption.encryptText);
assert.calledWith(mockRealtimeChannel.socket.send, {
id: uuid.v4(),
type: 'publishRequest',
recipients: [{
alertType: 'none',
headers: {},
route: mockRealtimeChannel.binding
}],
data: {
contentType: 'STRING',
eventType: 'board.activity',
envelope: {
encryptionKeyUrl: 'fakeURL',
channelId: channel.channelId
},
payload: 'encryptedData'
}
});
});
it(`backs off exponentially`, () => {
socketOpenStub.restore();
socketOpenStub = sinon.stub(Socket.prototype, `open`);
socketOpenStub.returns(Promise.reject(new ConnectionError({code: 4001})));
// Note: onCall is zero-based
socketOpenStub.onCall(2).returns(Promise.resolve(new MockWebSocket()));
assert.notCalled(Socket.prototype.open);
const promise = mercury.connect();
return promiseTick(4)
.then(() => {
assert.calledOnce(Socket.prototype.open);
// I'm not sure why, but it's important the clock doesn't advance
// until a tick happens
return promiseTick(4);
})
.then(() => {
clock.tick(mercury.config.backoffTimeReset);
return promiseTick(4);
})
.then(() => {
assert.calledTwice(Socket.prototype.open);
clock.tick(2 * mercury.config.backoffTimeReset);
return promiseTick(4);
})
.then(() => {
assert.calledThrice(Socket.prototype.open);
clock.tick(4 * mercury.config.backoffTimeReset);
return assert.isFulfilled(promise);
})
.then(() => {
assert.calledThrice(Socket.prototype.open);
clock.tick(8 * mercury.config.backoffTimeReset);
return promiseTick(4);
})
.then(() => {
assert.calledThrice(Socket.prototype.open);
});
});
it(`responds with the original error`, () => {
spark.credentials.supertoken = new Token({
access_token: `ST1`
}, {parent: spark});
const err = new SparkHttpError.Unauthorized({
statusCode: 401,
options: {
headers: {
trackingid: `blarg`
},
uri: `${config.device.preDiscoveryServices.hydraServiceUrl}/ping`
},
body: {
error: `fake error`
}
});
assert.notCalled(spark.request);
return assert.isRejected(interceptor.onResponseError(err.options, err))
.then((err2) => {
assert.equal(err2, err);
});
});
.then((convo) => {
assert.called(spark.internal.feature.getFeature);
assert.notCalled(spark.internal.device.getServiceUrl);
assert.equal(convo.url, 'http://example.com');
});
.then((convo) => {
assert.notCalled(spark.internal.feature.getFeature);
assert.notCalled(spark.internal.device.getServiceUrl);
assert.equal(convo.test, 'convo');
}));
.then(() => {
assert.calledOnce(spark.internal.board.decryptSingleFileContent);
assert.notCalled(spark.internal.encryption.decryptText);
assert.calledWith(spark.internal.encryption.decryptScr, fakeURL, 'encryptedScr');
});
it(`proxies console.${level}`, () => {
spark.logger.config.level = level;
assert.notCalled(console[impl(level)]);
spark.logger[level](`a log statement`);
assert.called(console[impl(level)]);
});
.then(() => {
assert.calledWith(spark.internal.board.encryptSingleContent, fakeURL, curveContents[0]);
assert.notCalled(spark.internal.encryption.encryptScr);
});
.then(() => {
assert.calledWith(spark.internal.board.decryptSingleContent, fakeURL, encryptedData);
assert.notCalled(spark.internal.encryption.decryptScr);
assert.notCalled(spark.internal.encryption.decryptText);
});