Source code
Revision control
Copy as Markdown
Other Tools
/* globals Promise, window, done, assert_true, on_event, promise_test */
/**
* Creates an ATTAcomm object. If the parameters are supplied
* it sets up event listeners to send the test data to an ATTA if one
* is available. If the ATTA does not respond, it will assume the test
* is being done manually and the results are being entered in the
* parent test window.
*
* @constructor
* @param {object} params
* @param {string} [params.test] - object containing JSON test definition
* @param {string} [params.testFile] - URI of a file with JSON test definition
* @param {string} params.ATTAuri - URI to use to exercise the window
* @event DOMContentLoaded Calls go once DOM is fully loaded
* @returns {object} Reference to the new object
*
*/
function ATTAcomm(params) {
'use strict';
this.Params = null; // parameters passed in
this.Promise = null; // master Promise that resolves when intialization is complete
this.Properties = null; // testharness_properties from the opening window
this.Tests = null; // test object being processed
this.testName = ""; // name of test being run
this.log = ""; // a buffer to capture log information for debugging
this.startReponse = {}; // startTest response will go in here for debugging
this.loading = true;
this.timeout = 5000;
var pending = [] ;
// set up in case DOM finishes loading early
pending.push(new Promise(function(resolve) {
on_event(document, "DOMContentLoaded", function() {
resolve(true);
}.bind(this));
}.bind(this)));
// if we are under runner, then there are props in the parent window
//
// if "output" is set in that, then pause at the end of running so the output
// can be analyzed. @@@TODO@@@
if (window && window.opener && window.opener.testharness_properties) {
this.Properties = window.opener.testharness_properties;
}
this.Params = params;
if (this.Params.hasOwnProperty("ATTAuri")) {
this.ATTAuri = this.Params.ATTAuri;
} else {
}
if (this.Params.hasOwnProperty("title")) {
this.testName = this.Params.title;
}
// start by loading the test (it might be inline, but
// loadTest deals with that
pending.push(this.loadTest(params)
.then(function(tests) {
// if the test is NOT an object, turn it into one
if (typeof tests === 'string') {
tests = JSON.parse(tests) ;
}
this.Tests = tests;
}.bind(this)));
this.Promise = new Promise(function(resolve, reject) {
// once the DOM and the test is loaded... set us up
Promise.all(pending)
.then(function() {
// Everything is loaded
this.loading = false ;
// run the automated tests (or setup for manual testing)
this.go();
resolve(this);
}.bind(this))
.catch(function(err) {
// loading the components failed somehow - report the errors and mark the test failed
test( function() {
assert_true(false, "Loading of test components failed: " +JSON.stringify(err)) ;
}, "Loading test components");
this.dumpLog();
done() ;
reject("Loading of test components failed: "+JSON.stringify(err));
return ;
}.bind(this));
}.bind(this));
return this;
}
ATTAcomm.prototype = {
/**
* go sets up the connection to the ATTA
*
* If that succeeds and the tests in this test file have methods for
* the API supported by the ATTA, then it automatically runs those tests.
*
* Otherwise it sets up for manualt testing.
*/
go: function() {
'use strict';
// everything is ready. Let's talk to the ATTA
this.startTest().then(function(res) {
// start was successful - iterate over steps
var API = res.body.API;
var subtestsForAPI = false;
// check main and potentially nested lists of tests for
// tests with this API. If any step is missing this API
// mapping, then we need to be manual
this.Tests.forEach(function(subtest) {
if (subtest.hasOwnProperty("test") &&
subtest.test.hasOwnProperty(API)) {
// there is at least one subtest for this API so
// this is a test that needs to be looked at by an atta
subtestsForAPI = true;
} else if (Array.isArray(subtest)) {
subtest.forEach(function(st) {
if (st.hasOwnProperty("test") &&
st.test.hasOwnProperty(API)) {
subtestsForAPI = true;
}
});
}
});
if (subtestsForAPI) {
this.runTests(API, this.Tests)
.then(function() {
// the tests all ran; close it out
this.endTest().then(function() {
this.dumpLog();
done();
}.bind(this));
}.bind(this))
.catch(function(err) {
this.endTest().then(function() {
this.dumpLog();
done();
}.bind(this));
}.bind(this));
} else {
// we don't know this API for this test
// but we ARE talking to an ATTA; skip this test
this.dumpLog();
if (window.opener && window.opener.completion_callback) {
window.opener.completion_callback([], { status: 3, message: "No steps for AT API " + API } );
} else {
done();
}
// this.setupManualTest("Unknown AT API: " + API);
}
}.bind(this))
.catch(function(res) {
// startTest failed so just sit and wait for a manual test to occur
if (res.timeout || res.status === 102) {
this.setupManualTest("No response from ATTA at " + this.ATTAuri);
} else if (res.status === 200 ) {
this.setupManualTest(res.message);
} else if (res.statusText === "No response from ATTA") {
this.setupManualTest("");
} else {
this.setupManualTest("Error from ATTA: " + res.status + ": " + res.statusText);
}
}.bind(this));
},
runTests: function(API, collection) {
// this method returns a promise
return new Promise(function(resolve, reject) {
// accumulate promises; complete when done
var pending = [];
var testCount = 0;
this.sendEvents(API, collection)
.then(function(eventStatus) {
/* Loop strategy...
*
* If the the step is a 'test' then push it into the pending queue as a promise
*
* If the step is anything else, then if there is anything in pending, wait on it
* Once it resolves, clear the queue and then execute the other step.
*
*/
collection.forEach(function(subtest) {
// what "type" of step in the sequence is this?
var theType = "test" ;
if (Array.isArray(subtest)) {
// it is a group
Promise.all(pending).then(function() {
pending = [];
// recursively run the tests
pending.push(this.runTests(API, subtest));
}.bind(this));
} else if (subtest.hasOwnProperty("type")) {
theType = subtest.type;
}
testCount++;
if (theType === "test") {
// this is a set of assertions that should be evaluated
pending.push(this.runTest(testCount, API, subtest));
} else if (theType === "script") {
Promise.all(pending).then(function() {
pending = [];
// execute the script
this.runScript(testCount, subtest);
}.bind(this));
} else if (theType === "attribute") {
Promise.all(pending).then(function() {
pending = [];
// raise the event
this.handleAttribute(testCount, subtest);
}.bind(this));
// } else {
} else if (theType === "event") {
Promise.all(pending).then(function() {
pending = [];
// raise the event
this.raiseEvent(testCount, subtest);
}.bind(this));
// } else {
}
}.bind(this));
Promise.all(pending)
.then(function() {
// this collection all ran
if (eventStatus !== "NOEVENTS") {
// there were some events at the beginning
this.sendStopListen().then(function() {
resolve(true);
});
} else {
resolve(true);
}
}.bind(this));
}.bind(this));
}.bind(this));
},
setupManualTest: function(message) {
// if we determine the test should run manually, then expose all of the conditions that are
// in the TEST data structure so that a human can to the inspection and calculate the result
//
'use strict';
var ref = document.getElementById("manualMode");
if (ref) {
// we have a manualMode block. Populate it
var content = "<h2>Manual Mode Enabled</h2><p>"+message+"</p>";
if (this.Tests.hasOwnProperty("description")) {
content += "<p>" + this.Tests.description + "</p>";
}
var theTable = "<table id='steps'><tr><th>Step</th><th>Type</th><th>Element ID</th><th>Assertions</th></tr>";
this.Tests.forEach(function(subtest) {
var type = "test";
if (subtest.hasOwnProperty("type")) {
type = subtest.type;
}
var id = "" ;
if (subtest.hasOwnProperty("element")) {
id = subtest.element;
}
theTable += "<tr><td class='step'>" + subtest.title +"</td>";
theTable += "<td class='type'>" + type + "</td>";
theTable += "<td class='element'>" + id +"</td>";
// now what do we put over here? depends on the type
if (type === "test") {
// it is a test; dump the assertions
theTable += "<td>" + this.buildAssertionTable(subtest.test) + "</td>";
} else if (type === "attribute" ) {
if (subtest.hasOwnProperty("attribute") && subtest.hasOwnProperty("value") && subtest.hasOwnProperty("element")) {
if (subtest.value === "none") {
theTable += "<td>Remove attribute <code>" + subtest.attribute + "</code> from the element with ID <code>" + subtest.element + "</code></td>";
} else {
theTable += "<td>Set attribute <code>" + subtest.attribute + "</code> on the element with ID <code>" + subtest.element + "</code> to the value <code>" + subtest.value + "</code></td>";
}
}
} else if (type === "event" ) {
// it is some events
if (subtest.hasOwnProperty("event") && subtest.hasOwnProperty("element")) {
theTable += "<td>Send event <code>" + subtest.event + "</code> to the element with ID <code>" + subtest.element + "</code></td>";
}
} else if (type === "script" ) {
// it is a script fragment
theTable += "<td>Script: " + subtest.script + "</td>";
} else {
theTable += "<td>Unknown type: " + type + "</td>";
}
theTable += "</tr>";
}.bind(this));
theTable += "</table>";
ref.innerHTML = content + theTable ;
}
},
buildAssertionTable: function(asserts) {
"use strict";
var output = "<table class='api'><tr><th>API Name</th><th colspan='4'>Assertions</th></tr>";
var APIs = [] ;
for (var k in asserts) {
if (asserts.hasOwnProperty(k)) {
APIs.push(k);
}
}
APIs.sort().forEach(function(theAPI) {
var rows = asserts[theAPI] ;
var height = rows.length;
output += "<tr><td rowspan='" + height + "' class='apiName'>"+theAPI+"</td>";
var lastRow = rows.length - 1;
rows.forEach(function(theRow, index) {
var span = 4 - theRow.length;
var colspan = span ? " colspan='"+span+"'" : "";
theRow.forEach(function(item) {
output += "<td" + colspan + ">" + item + "</td>";
});
output += "</tr>";
if (index < lastRow) {
output += "<tr>";
}
});
});
output += "</table>";
return output;
},
// eventList - find the events for an API
//
// @param {string} API
// @param {array} collection - a collection of tests
// @returns {array} list of event names
eventList: function(API, collection) {
var eventHash = {};
if (!API || API === "") {
return [];
}
collection.forEach(function(subtest) {
if (subtest.hasOwnProperty("test") &&
subtest.test.hasOwnProperty(API)) {
// this is a subtest for this API; look at the events
subtest.test[API].forEach(function(assert) {
// look for event names
if (assert[0] === "event" && assert[1] === "type" && assert[2] === "is") {
eventHash[assert[3]] = 1;
}
});
}
});
return Object.keys(eventHash);
},
// handleAttribute - set or clear an attribute
/**
* @param {integer} testNum - The subtest number
* @param {object} subtest - attribute information to set
*/
handleAttribute: function(testNum, subtest) {
"use strict";
if (subtest) {
if (subtest.hasOwnProperty("attribute") && subtest.hasOwnProperty("element") && subtest.hasOwnProperty("value")) {
// update an attribute
try {
var node = document.getElementById(subtest.element);
if (node) {
if (subtest.value === "none") {
// remove this attribute
node.removeAttribute(subtest.attribute);
} else if (subtest.value === '""') {
node.setAttribute(subtest.attribute, "");
} else if (subtest.value.match(/^"/) ) {
var v = subtest.value;
v = v.replace(/^"/, '');
v = v.replace(/"$/, '');
node.setAttribute(subtest.attribute, v);
} else {
node.setAttribute(subtest.attribute, subtest.value);
}
}
}
catch (e) {
test(function() {
assert_true(false, "Subtest attribute failed to update: " +e);
}, "Attribute subtest " + testNum);
}
} else {
test(function() {
var err = "";
if (!subtest.hasOwnProperty("attribute")) {
err += "Attribute subtest has no attribute property; ";
} else if (!subtest.hasOwnProperty("value")) {
err += "Attribute subtest has no value property; ";
} else if (!subtest.hasOwnProperty("element")) {
err += "Attribute subtest has no element property; ";
}
assert_true(false, err);
}, "Attribute subtest " + testNum );
}
}
return;
},
// raiseEvent - throw an event at an item
/**
* @param {integer} testNum - The subtest number
* @param {object} subtest - event information to throw
*/
raiseEvent: function(testNum, subtest) {
"use strict";
var evt;
if (subtest) {
var kp = function(target, key) {
evt = document.createEvent("KeyboardEvent");
evt.initKeyEvent ("keypress", true, true, window,
0, 0, 0, 0, 0, "e".charCodeAt(0));
target.dispatchEvent(evt);
};
if (subtest.hasOwnProperty("event") && subtest.hasOwnProperty("element")) {
// throw an event
try {
var node = document.getElementById(subtest.element);
if (node) {
if (subtest.event === "focus") {
node.focus();
} else if (subtest.event === "select") {
node.click();
} else if (subtest.event.startsWith('key:')) {
var key = subtest.event.replace('key:', '');
evt = new KeyboardEvent("keypress", { "key": key});
node.dispatchEvent(evt);
} else {
evt = new Event(subtest.element);
node.dispatchEvent(evt);
}
}
}
catch (e) {
test(function() {
assert_true(false, "Subtest event failed to dispatch: " +e);
}, "Event subtest " + testNum);
}
} else {
test(function() {
var err = "";
if (!subtest.hasOwnProperty("event")) {
err += "Event subtest has no event property; ";
} else if (!subtest.hasOwnProperty("element")) {
err += "Event subtest has no element property; ";
}
assert_true(false, err);
}, "Event subtest " + testNum );
}
}
return;
},
// runScript - run a script in the context of the window
/**
* @param {integer} testNum - The subtest number
* @param {object} subtest - script and related information
*/
runScript: function(testNum, subtest) {
"use strict";
if (subtest) {
if (subtest.hasOwnProperty("script") && typeof subtest.script === "string") {
try {
/* jshint evil:true */
eval(subtest.script);
}
catch (e) {
test(function() {
assert_true(false, "Subtest script " + subtest.script + " failed to evaluate: " +e);
}, "Event subtest " + testNum);
}
} else {
test(function() {
assert_true(false, "Event subtest has no script property");
}, "Event subtest " + testNum );
}
}
return;
},
// runTest - process subtest
/**
* @param {integer} testNum - The subtest number
* @param {string} API - name of the API being tested
* @param {object} subtest - a subtest to run; contains 'title', 'element', and
* 'test array'
* @returns {Promise} - a Promise that resolves when the test completes
*/
runTest: function(testNum, API, subtest) {
'use strict';
var data = {
"title" : subtest.title,
"id" : subtest.element,
"data": this.normalize(subtest.test[API])
};
return new Promise(function(resolve) {
var ANNO = this;
if (subtest.test[API]) {
// we actually have a test to run
promise_test(function() {
// force a resolve of the promise regardless
this.add_cleanup(function() { resolve(true); });
return ANNO.sendTest(data)
.then(function(res) {
if (typeof res.body === "object" && res.body.hasOwnProperty("status")) {
// we got some sort of response
if (res.body.status === "OK") {
// the test ran - yay!
var messages = "";
var thisResult = null;
var theLog = "";
var assertionCount = 0;
res.body.results.forEach( function (a) {
if (typeof a === "object") {
// we have a result for this assertion
// first, what is the assertion?
var aRef = data.data[assertionCount];
var assertionText = '"' + aRef.join(" ") +'"';
if (a.hasOwnProperty("log") && a.log !== null && a.log !== '' ) {
// there is log data - save it
theLog += "\n--- Assertion " + assertionCount + " ---";
theLog += "\nAssertion: " + assertionText + "\nLog data: "+a.log ;
}
// is there a message?
var theMessage = "";
if (a.hasOwnProperty("message")) {
theMessage = a.message;
}
if (!a.hasOwnProperty("result")) {
messages += "ATTA did not report a result " + theMessage + "; ";
} else if (a.result === "ERROR") {
messages += "ATTA reported ERROR with message: " + theMessage + "; ";
} else if (a.result === "FAIL") {
thisResult = false;
messages += assertionText + " failed " + theMessage + "; ";
} else if (a.result === "PASS" && thisResult === null) {
// if we got a pass and there was no other result thus far
// then we are passing
thisResult = true;
}
}
assertionCount++;
});
if (theLog !== "") {
ANNO.saveLog("runTest", theLog, subtest);
}
if (thisResult !== null) {
assert_true(thisResult, messages);
} else {
assert_true(false, "ERROR: No results reported from ATTA; " + messages);
}
} else if (res.body.status === "ERROR") {
assert_true(false, "ATTA returned ERROR with message: " + res.body.statusText);
} else {
assert_true(false, "ATTA returned unknown status " + res.body.status + " with message: " + res.body.statusText);
}
} else {
// the return wasn't an object!
assert_true(false, "ATTA failed to return a result object: returned: "+JSON.stringify(res));
}
});
}, subtest.name );
} else {
// there are no test steps for this API. fake a subtest result
promise_test(function() {
// force a resolve of the promise regardless
this.add_cleanup(function() { resolve(true); });
return new Promise(function(innerResolve) {
innerResolve(true);
})
.then(function(res) {
var theLog = "\nSUBTEST NOTRUN: No assertions for API " + API + "\n";
if (theLog !== "") {
ANNO.saveLog("runTest", theLog, subtest);
}
assert_false(true, "NOTRUN: No assertion for API " + API);
});
}, subtest.name );
}
}.bind(this));
},
// loadTest - load a test from an external JSON file
//
// returns a promise that resolves with the contents of the
// test
loadTest: function(params) {
'use strict';
if (params.hasOwnProperty('stepFile')) {
// the test is referred to by a file name
return this._fetch("GET", params.stepFile);
} // else
return new Promise(function(resolve, reject) {
if (params.hasOwnProperty('steps')) {
resolve(params.steps);
} else {
reject("Must supply a 'steps' or 'stepFile' parameter");
}
});
},
/* dumpLog - put log information into the log div on the page if it exists
*/
dumpLog: function() {
'use strict';
if (this.log !== "") {
var ref = document.getElementById("ATTAmessages");
if (ref) {
// we have a manualMode block. Populate it
var content = "<h2>Logging information recorded</h2>";
if (this.startResponse && this.startResponse.hasOwnProperty("API")) {
content += "<h3>ATTA Information</h3>";
content += "<pre>"+JSON.stringify(this.startResponse, null, " ")+"</pre>";
}
content += "<textarea rows='50' style='width:100%'>"+this.log+"</textarea>";
ref.innerHTML = content ;
}
}
},
/* saveLog - capture logging information so that it can be displayed on the page after testing is complete
*
* @param {string} caller name
* @param {string} log message
* @param {object} subtest
*/
saveLog: function(caller, message, subtest) {
'use strict';
if (typeof message === "string" && message !== "") {
this.log += "============================================================\n";
this.log += "Message from " + caller + "\n";
if (subtest && typeof subtest === "object") {
var API = this.startResponse.API;
this.log += "\n SUBTEST TITLE: " + subtest.title;
this.log += "\n SUBTEST ELEMENT: " + subtest.element;
this.log += "\n SUBTEST DATA: " + JSON.stringify(subtest.test[API]);
this.log += "\n\n";
}
this.log += message;
}
return;
},
// startTest - send the test start message
//
// @returns {Promise} resolves if the start is successful, or rejects with
startTest: function() {
'use strict';
return new Promise(function(resolve, reject) {
var params = {
test: this.testName || window.title,
url: document.location.href
};
this._fetch("POST", this.ATTAuri + "/start", null, params)
.then(function(res) {
if (res.body.hasOwnProperty("status")) {
if (res.body.status === "READY") {
this.startResponse = res.body;
if (res.body.hasOwnProperty("log")) {
// there is some logging data - capture it
this.saveLog("startTest", res.body.log);
}
// the system is ready for us - is it really?
if (res.body.hasOwnProperty("API")) {
resolve(res);
} else {
res.message = "No API in response from ATTA";
reject(res);
}
} else {
// the system reported something else - fail out with the statusText as a result
res.message = "ATTA reported an error: " + res.body.statusText;
reject(res);
}
} else {
res.message = "ATTA did not report a status";
reject(res);
}
}.bind(this))
.catch(function(res) {
reject(res);
});
}.bind(this));
},
// sendEvents - send the list of events the ATTA needs to listen for
//
// @param {string} API
// @param {array} collection - a list of tests
// @returns {Promise} resolves if the message is successful, or rejects with
sendEvents: function(API, collection) {
'use strict';
return new Promise(function(resolve, reject) {
var eList = this.eventList(API, collection) ;
if (eList && eList.length) {
var params = {
events: eList
};
this._fetch("POST", this.ATTAuri + "/startlisten", null, params)
.then(function(res) {
if (res.body.hasOwnProperty("status")) {
if (res.body.status === "READY") {
if (res.body.hasOwnProperty("log")) {
// there is some logging data - capture it
this.saveLog("sendEvents", res.body.log);
}
resolve(res.body.status);
} else {
// the system reported something else - fail out with the statusText as a result
res.message = "ATTA reported an error: " + res.body.statusText;
reject(res);
}
} else {
res.message = "ATTA did not report a status";
reject(res);
}
}.bind(this))
.catch(function(res) {
reject(res);
});
} else {
// there are no events
resolve("NOEVENTS");
}
}.bind(this));
},
sendStopListen: function() {
'use strict';
return this._fetch("POST", this.ATTAuri + "/stoplisten", null, null);
},
// sendTest - send test data to an ATTA and wait for a response
//
// returns a promise that resolves with the results of the test
sendTest: function(testData) {
'use strict';
if (typeof testData !== "string") {
testData = JSON.stringify(testData);
}
var ret = this._fetch("POST", this.ATTAuri + "/test", null, testData, true);
ret.then(function(res) {
if (res.body.hasOwnProperty("log")) {
// there is some logging data - capture it
this.saveLog("sendTest", res.body.log);
}
}.bind(this));
return ret;
},
endTest: function() {
'use strict';
return this._fetch("GET", this.ATTAuri + "/end");
},
/* normalize - ensure subtest data conforms to ATTA spec
*/
normalize: function( data ) {
'use strict';
var ret = [] ;
if (data) {
data.forEach(function(assert) {
var normal = [] ;
// ensure if there is a value list it is compressed
if (Array.isArray(assert)) {
// we have an array
normal[0] = assert[0];
normal[1] = assert[1];
normal[2] = assert[2];
if ("string" === typeof assert[3] && assert[3].match(/^\[.*\]$/)) {
// it is a string and matches the valuelist pattern
normal[3] = assert[3].replace(/, +/, ',');
} else {
normal[3] = assert[3];
}
ret.push(normal);
} else {
ret.push(assert);
}
});
}
return ret;
},
// _fetch - return a promise after sending data
//
// Resolves with the returned information in a structure
// including:
//
// xhr - a raw xhr object
// headers - an array of headers sent in the request
// status - the status code
// statusText - the text of the return status
// text - raw returned data
// body - an object parsed from the returned content
//
_fetch: function (method, url, headers, content, parse) {
'use strict';
if (method === null || method === undefined) {
method = "GET";
}
if (parse === null || parse === undefined) {
parse = true;
}
if (headers === null || headers === undefined) {
headers = [];
}
// note that this Promise always resolves - there is no reject
// condition
return new Promise(function (resolve, reject) {
var xhr = new XMLHttpRequest();
// this gets returned when the request completes
var resp = {
xhr: xhr,
headers: null,
status: 0,
statusText: "",
body: null,
text: ""
};
xhr.open(method, url);
// headers?
headers.forEach(function(ref) {
xhr.setRequestHeader(ref[0], ref[1]);
});
//if (this.timeout) {
// xhr.timeout = this.timeout;
//}
xhr.ontimeout = function() {
resp.timeout = this.timeout;
resolve(resp);
};
xhr.onerror = function() {
if (this.status) {
resp.status = this.status;
resp.statusText = xhr.statusText;
} else if (this.status === 0) {
resp.status = 0;
resp.statusText = "No response from ATTA";
}
reject(resp);
};
xhr.onload = function () {
resp.status = this.status;
if (this.status >= 200 && this.status < 300) {
var d = xhr.response;
// return the raw text of the response
resp.text = d;
// we have it; what is it?
if (parse) {
try {
d = JSON.parse(d);
resp.body = d;
}
catch(err) {
resp.body = null;
}
}
resolve(resp);
} else {
reject({
status: this.status,
statusText: xhr.statusText
});
}
};
if (content !== null && content !== undefined) {
if ("object" === typeof(content)) {
xhr.send(JSON.stringify(content));
} else if ("function" === typeof(content)) {
xhr.send(content());
} else if ("string" === typeof(content)) {
xhr.send(content);
}
} else {
xhr.send();
}
});
},
};
// vim: set ts=2 sw=2: