| /* 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: |
