mirror of
https://github.com/servo/servo.git
synced 2025-07-13 18:33:40 +01:00
947 lines
31 KiB
JavaScript
947 lines
31 KiB
JavaScript
/* 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 {
|
|
this.ATTAuri = "http://localhost:4119";
|
|
}
|
|
|
|
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:
|