it(`includes the logLevelToken in the authorization payload`, () => {
const s = new Socket();
s.open(`ws://example.com`, {
forceCloseDelay: mockoptions.forceCloseDelay,
pingInterval: mockoptions.pingInterval,
pongTimeout: mockoptions.pongTimeout,
logger: console,
token: `mocktoken`,
trackingId: `mocktrackingid`,
logLevelToken: `mocklogleveltoken`
}).catch((reason) => console.error(reason));
mockWebSocket.readyState = 1;
mockWebSocket.emit(`open`);
const firstCallArgs = JSON.parse(mockWebSocket.send.firstCall.args[0]);
assert.property(firstCallArgs, `id`);
assert.equal(firstCallArgs.type, `authorization`);
assert.property(firstCallArgs, `data`);
assert.property(firstCallArgs.data, `token`);
assert.equal(firstCallArgs.data.token, `mocktoken`);
assert.equal(firstCallArgs.trackingId, `mocktrackingid`);
assert.equal(firstCallArgs.logLevelToken, `mocklogleveltoken`);
return s.close();
});
.then((res) => {
assert.property(res, `email`);
assert.property(res, `tokenData`);
assert.equal(res.email, email);
assert.isDefined(unauthSpark.credentials.supertoken.access_token);
return unauthSpark.internal.user.verify({email});
})
.then((presenceResponse) => {
assert.equal(presenceResponse.statusList.length, 2);
assert.property(presenceResponse.statusList[0], `subject`);
assert.equal(presenceResponse.statusList[0].subject, mccoy.id);
assert.property(presenceResponse.statusList[1], `subject`);
assert.equal(presenceResponse.statusList[1].subject, spock.id);
});
.then((user) => {
assert.equal(user.id, spark.internal.device.userId);
assert.property(user, `entitlements`);
assert.property(user, `email`);
assert.property(user, `name`);
assert.equal(user.name, `New Display Name`);
}));
it(`adds a tracking id`, () => {
const options = {headers: {}};
interceptor.onRequest(options);
assert.property(options, `headers`);
assert.property(options.headers, `trackingid`);
});
.then((message) => {
assert.property(message, 'files');
assert.isDefined(message.files);
assert.isArray(message.files);
assert.lengthOf(message.files, 1);
assert.property(message, 'text');
}));
.then((message) => {
assert.property(message, `files`);
assert.isDefined(message.files);
assert.isArray(message.files);
assert.lengthOf(message.files, 1);
assert.property(message, `text`);
});
.then(() => {
assert.property(call.from, 'isInitiator');
assert.property(call.from, 'personId');
assert.property(call.from, 'state');
assert.isHydraID(call.from.personId);
assert.isTrue(call.from.isInitiator);
assert.equal(base64.decode(call.from.personId).split('/').pop(), spock.id);
})
.then(() => {
assert.property(call.to, `isInitiator`);
assert.property(call.to, `personId`);
assert.property(call.to, `state`);
assert.isHydraID(call.to.personId);
assert.isFalse(call.to.isInitiator);
assert.equal(base64.decode(call.to.personId).split(`/`).pop(), mccoy.id);
})
it(`adds a requestStart time to options.$timings`, () => {
const options = {
$timings: {}
};
interceptor.onRequest(options);
assert.property(options, `$timings`);
assert.property(options.$timings, `requestStart`);
});
.then(([c]) => {
assert.equal(call.direction, `out`);
assert.property(c, `locus`);
assert.isDefined(c.locus);
assert.property(c, `direction`);
assert.isDefined(c.direction);
assert.equal(c.direction, `in`);
});
.then(() => {
assert.property(call.from, `isInitiator`);
assert.property(call.from, `personId`);
assert.property(call.from, `state`);
assert.isHydraID(call.from.personId);
assert.isTrue(call.from.isInitiator);
assert.equal(base64.decode(call.from.personId).split(`/`).pop(), spock.id);
})
.then((fileContent) => {
testContent = fileContent[0].items[0];
assert.equal(testContent.type, 'FILE', 'content type should be image');
assert.property(testContent, 'contentUrl', 'content should contain contentId property');
assert.property(testContent, 'channelUrl', 'content should contain contentUrl property');
assert.property(testContent, 'metadata', 'content should contain metadata property');
assert.property(testContent, 'file', 'content should contain file property');
assert.property(testContent.file, 'scr', 'content file should contain scr property');
}));
.then((res) => {
assert.property(res, `hasPassword`);
assert.property(res, `verificationEmailTriggered`);
assert.property(res, `sso`);
assert.isTrue(res.hasPassword);
assert.isFalse(res.verificationEmailTriggered);
assert.isFalse(res.sso);
assert.isTrue(spark.internal.user.hasPassword);
})
.then((res) => {
// verification email should not trigger if already have valid user token
assert.property(res, `hasPassword`);
assert.property(res, `verificationEmailTriggered`);
assert.property(res, `sso`);
assert.isFalse(res.hasPassword);
assert.isFalse(res.verificationEmailTriggered);
assert.isFalse(res.sso);
assert.isFalse(unauthSpark.internal.user.hasPassword);
});
.then((channel) => {
assert.property(channel, 'kmsResourceUrl');
assert.property(channel, 'aclUrl');
assert.equal(channel.channelUrl, board.channelUrl);
assert.equal(channel.aclUrlLink, conversation.aclUrl);
assert.notEqual(channel.kmsResourceUrl, conversation.kmsResourceObjectUrl);
assert.notEqual(channel.aclUrl, conversation.aclUrl);
assert.notEqual(channel.defaultEncryptionKeyUrl, conversation.defaultActivityEncryptionKeyUrl);
}));
it(`sends an auth message up the socket`, () => {
const firstCallArgs = JSON.parse(mockWebSocket.send.firstCall.args[0]);
assert.property(firstCallArgs, `id`);
assert.equal(firstCallArgs.type, `authorization`);
assert.property(firstCallArgs, `data`);
assert.property(firstCallArgs.data, `token`);
assert.equal(firstCallArgs.data.token, `mocktoken`);
assert.equal(firstCallArgs.trackingId, `mocktrackingid`);
assert.notProperty(firstCallArgs, `logLevelToken`);
});
.then((allContents) => {
const imageContent = find(allContents.items, {contentId: testContent.contentId});
assert.isDefined(imageContent);
assert.property(imageContent, 'file');
assert.property(imageContent.file, 'scr');
testScr = imageContent.file.scr;
return imageContent.file.scr;
})
.then((fileContent) => {
testContent = fileContent[0].items[0];
assert.equal(testContent.type, 'FILE', 'content type should be image');
assert.property(testContent, 'contentUrl', 'content should contain contentId property');
assert.property(testContent, 'channelUrl', 'content should contain contentUrl property');
assert.property(testContent, 'file', 'content should contain file property');
assert.property(testContent.file, 'scr', 'content file should contain scr property');
assert.deepEqual(testContent.metadata, {});
return participants[0].spark.internal.board.getContents(board);
})
.then(() => {
assert.calledOnce(spark.request);
const req = spark.request.args[0][0];
const metric = req.body.metrics[0];
assert.property(metric.eventPayload, `origin`);
assert.property(metric.eventPayload, `originTime`);
assert.property(metric.eventPayload.origin, `buildType`);
assert.property(metric.eventPayload.origin, `networkType`);
assert.property(metric.eventPayload.originTime, `sent`);
});
.then((allContents) => {
const imageContent = find(allContents.items, {contentId: testContent.contentId});
assert.isDefined(imageContent);
assert.property(imageContent, 'file');
assert.property(imageContent.file, 'scr');
assert.equal(imageContent.metadata.displayName, 'sample-image-small-one.png');
testScr = imageContent.file.scr;
return imageContent.file.scr;
}));
it('adds a basic spark-user-agent header', () => {
const interceptor = Reflect.apply(SparkUserAgentInterceptor.create, {
version: pkg.version
}, []);
const options = {headers: {}};
interceptor.onRequest(options);
assert.property(options, 'headers');
assert.property(options.headers, 'spark-user-agent');
assert.equal(options.headers['spark-user-agent'], `spark-js-sdk/${pkg.version} (${typeof window === 'undefined' ? 'node' : 'web'})`);
});
.then(() => {
assert.calledOnce(spark.request);
const req = spark.request.args[0][0];
const metric = req.body.metrics[0];
assert.property(metric, `metricName`);
assert.property(metric, `tags`);
assert.property(metric, `fields`);
assert.equal(metric.metricName, `test`);
assert.equal(metric.tags.success, true);
assert.equal(metric.fields.perceivedDurationInMillis, 314);
});
.then(() => {
assert.calledOnce(spark.request);
const req = spark.request.args[0][0];
const metric = req.body.metrics[0];
const headers = req.headers;
assert.property(headers, `x-prelogin-userid`);
assert.property(metric, `metricName`);
assert.property(metric, `tags`);
assert.property(metric, `fields`);
assert.equal(metric.metricName, eventName);
assert.equal(metric.tags.testTag, `tag value`);
assert.equal(metric.fields.testField, 123);
});
it('adds a complex spark-user-agent header', () => {
const interceptor = Reflect.apply(SparkUserAgentInterceptor.create, {
version: pkg.version,
config: {
appName: 'sample',
appVersion: '1.0.0'
}
}, []);
const options = {headers: {}};
interceptor.onRequest(options);
assert.property(options, 'headers');
assert.property(options.headers, 'spark-user-agent');
assert.equal(options.headers['spark-user-agent'], `sample/1.0.0 (${typeof window === 'undefined' ? 'node' : 'web'}) spark-js-sdk/${pkg.version}`);
});
.then((res) => {
assert.isTrue(res.verificationEmailTriggered);
assert.property(res, `verifyEmailURL`);
const query = url.parse(res.verifyEmailURL).query;
const token = querystring.parse(query).t;
return assert.isFulfilled(unauthSpark.internal.user.activate({verificationToken: token}));
})
it(`adds a requestEnd time to options.$timings`, () => {
const options = {
$timings: {}
};
interceptor.onResponse(options);
assert.property(options.$timings, `requestEnd`);
});
.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);
});
.then(() => {
assert.calledOnce(spark.request);
const req = spark.request.args[0][0];
const metric = req.body.metrics[0];
assert.property(metric, `key`);
assert.property(metric, `version`);
assert.property(metric, `appType`);
assert.property(metric, `env`);
assert.property(metric, `time`);
assert.property(metric, `version`);
assert.equal(metric.key, `testMetric`);
assert.equal(metric.version, spark.version);
assert.equal(metric.env, `TEST`);
});