gpii-universal
Version:
Cross platform, core components of the GPII personalization infrastructure.
438 lines (394 loc) • 17.7 kB
JavaScript
/*!
GPII Untrusted Settings Data Source Tests
Copyright 2017 OCAD University
Licensed under the New BSD license. You may not use this file except in
compliance with this License.
You may obtain a copy of the License at
https://github.com/GPII/universal/blob/master/LICENSE.txt
*/
"use strict";
var fluid = require("infusion"),
gpii = fluid.registerNamespace("gpii"),
kettle = require("kettle"),
jqUnit = fluid.registerNamespace("jqUnit"),
nock = require("nock");
require("flowManager");
fluid.require("%gpii-universal/gpii/node_modules/testing/src/NockUtils.js");
kettle.loadTestingSupport();
fluid.registerNamespace("gpii.tests.settingsDataSource");
gpii.tests.settingsDataSource.hostname = "http://gpii.net";
gpii.tests.settingsDataSource.accessTokenUrl = "/access_token";
gpii.tests.settingsDataSource.settingsGetUrl = "/%gpiiKey/settings/%device";
gpii.tests.settingsDataSource.settingsPutUrl = "/%gpiiKey/settings";
gpii.tests.settingsDataSource.gpiiKey = "gpii-key-test";
gpii.tests.settingsDataSource.device = {
"OS": "windows 10"
};
gpii.tests.settingsDataSource.preferencesToUpdate = {
"http://registry.gpii.net/common/fontSize": 24
};
gpii.tests.settingsDataSource.nockConfig = {
accessToken: {
url: gpii.tests.settingsDataSource.accessTokenUrl,
data: {
"grant_type": "password",
"password": "dummy",
"client_id": "pilot-computer",
"client_secret": "pilot-computer-secret",
"username": gpii.tests.settingsDataSource.gpiiKey
},
status: 200,
response: {
access_token: "access-token-test-in-settingsDataSource",
expiresIn: 3600,
token_type: "Bearer"
}
},
settingsGet: {
url: fluid.stringTemplate(gpii.tests.settingsDataSource.settingsGetUrl, {
gpiiKey: gpii.tests.settingsDataSource.gpiiKey,
device: encodeURIComponent(JSON.stringify(gpii.tests.settingsDataSource.device))
}),
authHeader: {
header: "Authorization",
value: /Bearer .*/
},
status: 200,
response: {
settings: "user settings in success"
}
},
settingsPut: {
url: fluid.stringTemplate(gpii.tests.settingsDataSource.settingsPutUrl, {
gpiiKey: gpii.tests.settingsDataSource.gpiiKey
}),
authHeader: {
header: "Authorization",
value: /Bearer .*/
},
status: 200,
response: {
gpiiKey: gpii.tests.settingsDataSource.gpiiKey,
message: "Successfully updated."
}
}
};
// Set up mock ajax responses
gpii.tests.settingsDataSource.setUpNock = function (config) {
var cloudMock = nock(gpii.tests.settingsDataSource.hostname);
// log nock matches
cloudMock.log(console.log);
// mock POST requests to "/access_token"
cloudMock.post(config.accessToken.url, config.accessToken.data)
.reply(config.accessToken.status, config.accessToken.response);
// mock GET requests to "/settings"
cloudMock.get(config.settingsGet.url)
.matchHeader(config.settingsGet.authHeader.header, config.settingsGet.authHeader.value)
.reply(config.settingsGet.status, config.settingsGet.response);
// mock PUT requests to "/settings"
cloudMock.put(config.settingsPut.url, gpii.tests.settingsDataSource.preferencesToUpdate)
.matchHeader(config.settingsPut.authHeader.header, config.settingsPut.authHeader.value)
.reply(config.settingsPut.status, config.settingsPut.response);
};
// The customized settingsDataSource component for tests
fluid.defaults("gpii.tests.settingsDataSource", {
gradeNames: ["gpii.flowManager.settingsDataSource"],
cloudURL: gpii.tests.settingsDataSource.hostname,
clientCredentialFilePath: "%gpii-universal/gpii/node_modules/flowManager/test/data/clientCredential-correct.json"
});
// The base testEnvironment grade to be inherited by all tests
fluid.defaults("gpii.tests.settingsDataSourceTests", {
gradeNames: ["fluid.test.testEnvironment", "fluid.test.testCaseHolder", "gpii.test.testWithNock"],
settingsDataSourceGrade: "gpii.tests.settingsDataSource", // supplied by individual tests
testCaseHolderGrade: null, // supplied by individual tests
invokers: {
setUpNock: {
funcName: "gpii.tests.settingsDataSource.setUpNock",
args: gpii.tests.settingsDataSource.nockConfig
}
},
distributeOptions: {
settingsDataSourceGrade: {
source: "{that}.options.settingsDataSourceGrade",
target: "{that > settingsDataSource}.type"
}
},
components: {
settingsDataSource: {
type: "gpii.tests.settingsDataSource"
}
},
events: {
onResponse: null,
onError: null
}
});
// Common test sequence elements
fluid.defaults("fluid.tests.settingsDataSource.sequenceElement.get", {
gradeNames: "fluid.test.sequenceElement",
sequence: [{
task: "{settingsDataSource}.get",
args: [gpii.tests.settingsDataSource.gpiiKey, gpii.tests.settingsDataSource.device],
resolve: "jqUnit.assertValue",
resolveArgs: ["The user settings are received", "{arguments}.0.settings"]
}]
});
fluid.defaults("fluid.tests.settingsDataSource.sequenceElement.set", {
gradeNames: "fluid.test.sequenceElement",
sequence: [{
task: "{settingsDataSource}.set",
args: [gpii.tests.settingsDataSource.gpiiKey, gpii.tests.settingsDataSource.preferencesToUpdate],
resolve: "jqUnit.assertValue",
resolveArgs: ["The preferences are updated successfully", gpii.tests.settingsDataSource.gpiiKey, "{arguments}.0.gpiiKey"]
}]
});
// 1. No saved access token: retrieve and save an access token that then is used to retrieve user settings
// 1.1 Define test sequence elements only used in this test
fluid.defaults("fluid.tests.settingsDataSource.sequenceElement.noInitialAccessToken", {
gradeNames: "fluid.test.sequenceElement",
sequence: [{
func: "jqUnit.assertDeepEq",
args: ["No saved access token", {}, "{settingsDataSource}.accessTokens"]
}]
});
fluid.defaults("fluid.tests.settingsDataSource.sequenceElement.verifyReceivedInitialAccessToken", {
gradeNames: "fluid.test.sequenceElement",
sequence: [{
func: "jqUnit.assertValue",
args: ["The access token is received and saved", "{settingsDataSource}.accessTokens.gpii-key-test.accessToken"]
}, {
func: "jqUnit.assertValue",
args: ["The expiresIn is received and saved", "{settingsDataSource}.accessTokens.gpii-key-test.timestampExpires"]
}]
});
// 1.2 define test sequences
fluid.defaults("gpii.tests.settingsDataSource.sequence.get.noSavedAccessToken", {
gradeNames: "fluid.test.sequence",
sequenceElements: {
noInitialAccessToken: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.noInitialAccessToken",
priority: "first"
},
interactWithCloud: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.get",
priority: "after:noInitialAccessToken"
},
verifyReceivedInitialAccessToken: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.verifyReceivedInitialAccessToken",
priority: "after:interactWithCloud"
}
}
});
fluid.defaults("gpii.tests.settingsDataSource.sequence.set.noSavedAccessToken", {
gradeNames: "gpii.tests.settingsDataSource.sequence.get.noSavedAccessToken",
sequenceElements: {
interactWithCloud: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.set"
}
}
});
// 1.3 define tests
fluid.defaults("gpii.tests.settingsDataSourceTests.get.noSavedAccessToken", {
gradeNames: ["gpii.tests.settingsDataSourceTests"],
modules: [{
name: "A workflow with undefined initial access token: an access token is requested, saved and used to retrieve user settings",
tests: {
name: "Test get()",
expect: 4,
sequenceGrade: "gpii.tests.settingsDataSource.sequence.get.noSavedAccessToken"
}
}]
});
fluid.defaults("gpii.tests.settingsDataSourceTests.set.noSavedAccessToken", {
gradeNames: ["gpii.tests.settingsDataSourceTests", "fluid.test.testCaseHolder"],
modules: [{
name: "A workflow with undefined initial access token: an access token is requested, saved and used to retrieve user settings",
tests: {
name: "Test set()",
expect: 4,
sequenceGrade: "gpii.tests.settingsDataSource.sequence.set.noSavedAccessToken"
}
}]
});
// 2. Has unexpired access token: use saved access token to retrieve user settings
// 2.1 Custom "settingsDataSource" test component with an unexpired initial access token
fluid.defaults("gpii.tests.settingsDataSource.validInitialAccessToken", {
gradeNames: ["gpii.tests.settingsDataSource"],
members: {
accessTokens: {
"gpii-key-test": {
accessToken: "a-valid-initial-access-token",
timestampExpires: new Date(new Date().getTime() + 3600 * 1000).toISOString() // expires in 1 hour
}
}
}
});
// 2.2 Define test sequence elements only used in this test
fluid.defaults("fluid.tests.settingsDataSource.sequenceElement.verifyValidInitialAccessToken", {
gradeNames: "fluid.test.sequenceElement",
sequence: [{
func: "gpii.tests.settingsDataSource.assertInitialAccessToken",
args: ["{settingsDataSourceTests}", "{settingsDataSource}", false]
}]
});
fluid.defaults("fluid.tests.settingsDataSource.sequenceElement.verifySameAccessToken", {
gradeNames: "fluid.test.sequenceElement",
sequence: [{
func: "jqUnit.assertEquals",
args: ["The saved access token is same as the initial saved value", "{settingsDataSourceTests}.initialSavedAccessToken", "{settingsDataSource}.accessTokens.gpii-key-test.accessToken"]
}, {
func: "jqUnit.assertEquals",
args: ["The saved timestampExpires is same as the initial saved value", "{settingsDataSourceTests}.initialSavedTimestampExpires", "{settingsDataSource}.accessTokens.gpii-key-test.timestampExpires"]
}]
});
// 2.3 define test sequences
fluid.defaults("gpii.tests.settingsDataSource.sequence.get.validInitialAccessToken", {
gradeNames: "fluid.test.sequence",
sequenceElements: {
verifyValidInitialAccessToken: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.verifyValidInitialAccessToken",
priority: "first"
},
interactWithCloud: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.get",
priority: "after:verifyValidInitialAccessToken"
},
verifySameAccessToken: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.verifySameAccessToken",
priority: "after:interactWithCloud"
}
}
});
fluid.defaults("gpii.tests.settingsDataSource.sequence.set.validInitialAccessToken", {
gradeNames: "gpii.tests.settingsDataSource.sequence.get.validInitialAccessToken",
sequenceElements: {
interactWithCloud: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.set"
}
}
});
// 2.4 define tests
fluid.defaults("gpii.tests.settingsDataSourceTests.get.validInitialAccessToken", {
gradeNames: ["gpii.tests.settingsDataSourceTests"],
settingsDataSourceGrade: "gpii.tests.settingsDataSource.validInitialAccessToken",
modules: [{
name: "A workflow with a valid initial access token: the saved access token is used to retrieve user settings",
tests: {
name: "Test get()",
expect: 5,
sequenceGrade: "gpii.tests.settingsDataSource.sequence.get.validInitialAccessToken"
}
}]
});
fluid.defaults("gpii.tests.settingsDataSourceTests.set.validInitialAccessToken", {
gradeNames: ["gpii.tests.settingsDataSourceTests"],
settingsDataSourceGrade: "gpii.tests.settingsDataSource.validInitialAccessToken",
modules: [{
name: "A workflow with a valid initial access token: the saved access token is used to retrieve user settings",
tests: {
name: "Test set()",
expect: 5,
sequenceGrade: "gpii.tests.settingsDataSource.sequence.set.validInitialAccessToken"
}
}]
});
// 3. Has expired initial access token: retrieve a new access token before using /settings
// 3.1 Custom "settingsDataSource" test component with an expired initial access token
fluid.defaults("gpii.tests.settingsDataSource.expiredInitialAccessToken", {
gradeNames: ["gpii.tests.settingsDataSource"],
members: {
accessTokens: {
"gpii-key-test": {
accessToken: "a-valid-initial-access-token",
timestampExpires: new Date(new Date().getTime() - 10 * 1000).toISOString() // already expired 10 secs ago
}
}
}
});
// 3.2 Define test sequence elements only used in this test
fluid.defaults("fluid.tests.settingsDataSource.sequenceElement.verifyExpiredInitialAccessToken", {
gradeNames: "fluid.test.sequenceElement",
sequence: [{
func: "gpii.tests.settingsDataSource.assertInitialAccessToken",
args: ["{settingsDataSourceTests}", "{settingsDataSource}", true]
}]
});
fluid.defaults("fluid.tests.settingsDataSource.sequenceElement.verifyReceivedValidAccessToken", {
gradeNames: "fluid.test.sequenceElement",
sequence: [{
func: "jqUnit.assertNotEquals",
args: ["The saved access token is different from the initial saved value", "{settingsDataSourceTests}.initialSavedAccessToken", "{settingsDataSource}.accessTokens.gpii-key-test.accessToken"]
}, {
func: "jqUnit.assertNotEquals",
args: ["The saved timestampExpires is different from the initial saved value", "{settingsDataSourceTests}.initialSavedTimestampExpires", "{settingsDataSource}.accessTokens.gpii-key-test.timestampExpires"]
}]
});
// 3.3 define test sequences
fluid.defaults("gpii.tests.settingsDataSource.sequence.get.expiredInitialAccessToken", {
gradeNames: "fluid.test.sequence",
sequenceElements: {
verifyExpiredInitialAccessToken: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.verifyExpiredInitialAccessToken",
priority: "first"
},
interactWithCloud: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.get",
priority: "after:verifyExpiredInitialAccessToken"
},
verifyReceivedValidAccessToken: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.verifyReceivedValidAccessToken",
priority: "after:interactWithCloud"
}
}
});
fluid.defaults("gpii.tests.settingsDataSource.sequence.set.expiredInitialAccessToken", {
gradeNames: "gpii.tests.settingsDataSource.sequence.get.expiredInitialAccessToken",
sequenceElements: {
interactWithCloud: {
gradeNames: "fluid.tests.settingsDataSource.sequenceElement.set"
}
}
});
// 3.4 define tests
fluid.defaults("gpii.tests.settingsDataSourceTests.get.expiredInitialAccessToken", {
gradeNames: ["gpii.tests.settingsDataSourceTests"],
settingsDataSourceGrade: "gpii.tests.settingsDataSource.expiredInitialAccessToken",
modules: [{
name: "A workflow with a valid initial access token: the saved access token is used to retrieve user settings",
tests: {
name: "Test get()",
expect: 5,
sequenceGrade: "gpii.tests.settingsDataSource.sequence.get.expiredInitialAccessToken"
}
}]
});
fluid.defaults("gpii.tests.settingsDataSourceTests.set.expiredInitialAccessToken", {
gradeNames: ["gpii.tests.settingsDataSourceTests"],
settingsDataSourceGrade: "gpii.tests.settingsDataSource.expiredInitialAccessToken",
modules: [{
name: "A workflow with a valid initial access token: the saved access token is used to update preferences",
tests: {
name: "Test set()",
expect: 5,
sequenceGrade: "gpii.tests.settingsDataSource.sequence.set.expiredInitialAccessToken"
}
}]
});
// Shared utility functions
gpii.tests.settingsDataSource.assertInitialAccessToken = function (that, settingsDataSource, isExpired) {
var initialAccessToken = fluid.get(settingsDataSource, ["accessTokens", gpii.tests.settingsDataSource.gpiiKey, "accessToken"]);
var initialTimestampExpires = fluid.get(settingsDataSource, ["accessTokens", gpii.tests.settingsDataSource.gpiiKey, "timestampExpires"]);
jqUnit.assertValue("A saved access token is in place", initialAccessToken);
jqUnit[isExpired ? "assertTrue" : "assertFalse"]("A saved access token is not expired", gpii.oauth2.getExpiresIn(new Date(), initialTimestampExpires) === 0);
that.initialSavedAccessToken = initialAccessToken;
that.initialSavedTimestampExpires = initialTimestampExpires;
};
// Run all tests
fluid.test.runTests([
"gpii.tests.settingsDataSourceTests.get.noSavedAccessToken",
"gpii.tests.settingsDataSourceTests.set.noSavedAccessToken",
"gpii.tests.settingsDataSourceTests.get.validInitialAccessToken",
"gpii.tests.settingsDataSourceTests.set.validInitialAccessToken",
"gpii.tests.settingsDataSourceTests.get.expiredInitialAccessToken",
"gpii.tests.settingsDataSourceTests.set.expiredInitialAccessToken"
]);