The Tor Browser: comparison services/sync/tps/extensions/mozmill/resource/modules/frame.js

comparison: services/sync/tps/extensions/mozmill/resource/modules/frame.js

services/sync/tps/extensions/mozmill/resource/modules/frame.js

branch: TOR_BUG_3246
changeset 5: 4ab42b5ab56c

equal deleted inserted replaced

--1:000000000000
+:b1e703448ff9
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, you can obtain one at http://mozilla.org/MPL/2.0/. */
+var EXPORTED_SYMBOLS = ['Collector','Runner','events', 'runTestFile', 'log',
+'timers', 'persisted', 'shutdownApplication'];
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+const TIMEOUT_SHUTDOWN_HTTPD = 15000;
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import('resource://mozmill/stdlib/httpd.js');
+var broker = {};  Cu.import('resource://mozmill/driver/msgbroker.js', broker);
+var assertions = {}; Cu.import('resource://mozmill/modules/assertions.js', assertions);
+var errors = {}; Cu.import('resource://mozmill/modules/errors.js', errors);
+var os = {};      Cu.import('resource://mozmill/stdlib/os.js', os);
+var strings = {}; Cu.import('resource://mozmill/stdlib/strings.js', strings);
+var arrays = {};  Cu.import('resource://mozmill/stdlib/arrays.js', arrays);
+var withs = {};   Cu.import('resource://mozmill/stdlib/withs.js', withs);
+var utils = {};   Cu.import('resource://mozmill/stdlib/utils.js', utils);
+var securableModule = {};
+Cu.import('resource://mozmill/stdlib/securable-module.js', securableModule);
+var uuidgen = Cc["@mozilla.org/uuid-generator;1"].getService(Ci.nsIUUIDGenerator);
+var httpd = null;
+var persisted = {};
+var assert = new assertions.Assert();
+var mozmill = undefined;
+var mozelement = undefined;
+var modules = undefined;
+var timers = [];
+/**
+* Shutdown or restart the application
+*
+* @param {boolean} [aFlags=undefined]
+*        Additional flags how to handle the shutdown or restart. The attributes
+*        eRestarti386 and eRestartx86_64 have not been documented yet.
+* @see https://developer.mozilla.org/nsIAppStartup#Attributes
+*/
+function shutdownApplication(aFlags) {
+var flags = Ci.nsIAppStartup.eForceQuit;
+if (aFlags) {
+flags |= aFlags;
+}
+// Send a request to shutdown the application. That will allow us and other
+// components to finish up with any shutdown code. Please note that we don't
+// care if other components or add-ons want to prevent this via cancelQuit,
+// we really force the shutdown.
+let cancelQuit = Components.classes["@mozilla.org/supports-PRBool;1"].
+createInstance(Components.interfaces.nsISupportsPRBool);
+Services.obs.notifyObservers(cancelQuit, "quit-application-requested", null);
+// Use a timer to trigger the application restart, which will allow us to
+// send an ACK packet via jsbridge if the method has been called via Python.
+var event = {
+notify: function(timer) {
+Services.startup.quit(flags);
+}
+}
+var timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+timer.initWithCallback(event, 100, Ci.nsITimer.TYPE_ONE_SHOT);
+}
+function stateChangeBase(possibilties, restrictions, target, cmeta, v) {
+if (possibilties) {
+if (!arrays.inArray(possibilties, v)) {
+// TODO Error value not in this.poss
+return;
+}
+}
+if (restrictions) {
+for (var i in restrictions) {
+var r = restrictions[i];
+if (!r(v)) {
+// TODO error value did not pass restriction
+return;
+}
+}
+}
+// Fire jsbridge notification, logging notification, listener notifications
+events[target] = v;
+events.fireEvent(cmeta, target);
+}
+var events = {
+appQuit           : false,
+currentModule     : null,
+currentState      : null,
+currentTest       : null,
+shutdownRequested : false,
+userShutdown      : null,
+userShutdownTimer : null,
+listeners       : {},
+globalListeners : []
+}
+events.setState = function (v) {
+return stateChangeBase(['dependencies', 'setupModule', 'teardownModule',
+'test', 'setupTest', 'teardownTest', 'collection'],
+null, 'currentState', 'setState', v);
+}
+events.toggleUserShutdown = function (obj){
+if (!this.userShutdown) {
+this.userShutdown = obj;
+var event = {
+notify: function(timer) {
+events.toggleUserShutdown(obj);
+}
+}
+this.userShutdownTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+this.userShutdownTimer.initWithCallback(event, obj.timeout, Ci.nsITimer.TYPE_ONE_SHOT);
+} else {
+this.userShutdownTimer.cancel();
+// If the application is not going to shutdown, the user shutdown failed and
+// we have to force a shutdown.
+if (!events.appQuit) {
+this.fail({'function':'events.toggleUserShutdown',
+'message':'Shutdown expected but none detected before timeout',
+'userShutdown': obj});
+var flags = Ci.nsIAppStartup.eAttemptQuit;
+if (events.isRestartShutdown()) {
+flags |= Ci.nsIAppStartup.eRestart;
+}
+shutdownApplication(flags);
+}
+}
+}
+events.isUserShutdown = function () {
+return this.userShutdown ? this.userShutdown["user"] : false;
+}
+events.isRestartShutdown = function () {
+return this.userShutdown.restart;
+}
+events.startShutdown = function (obj) {
+events.fireEvent('shutdown', obj);
+if (obj["user"]) {
+events.toggleUserShutdown(obj);
+} else {
+shutdownApplication(obj.flags);
+}
+}
+events.setTest = function (test) {
+test.__start__ = Date.now();
+test.__passes__ = [];
+test.__fails__ = [];
+events.currentTest = test;
+var obj = {'filename': events.currentModule.__file__,
+'name': test.__name__}
+events.fireEvent('setTest', obj);
+}
+events.endTest = function (test) {
+// use the current test unless specified
+if (test === undefined) {
+test = events.currentTest;
+}
+// If no test is set it has already been reported. Beside that we don't want
+// to report it a second time.
+if (!test || test.status === 'done')
+return;
+// report the end of a test
+test.__end__ = Date.now();
+test.status = 'done';
+var obj = {'filename': events.currentModule.__file__,
+'passed': test.__passes__.length,
+'failed': test.__fails__.length,
+'passes': test.__passes__,
+'fails' : test.__fails__,
+'name'  : test.__name__,
+'time_start': test.__start__,
+'time_end': test.__end__}
+if (test.skipped) {
+obj['skipped'] = true;
+obj.skipped_reason = test.skipped_reason;
+}
+if (test.meta) {
+obj.meta = test.meta;
+}
+// Report the test result only if the test is a true test or if it is failing
+if (withs.startsWith(test.__name__, "test") || test.__fails__.length > 0) {
+events.fireEvent('endTest', obj);
+}
+}
+events.setModule = function (aModule) {
+aModule.__start__ = Date.now();
+aModule.__status__ = 'running';
+var result = stateChangeBase(null,
+[function (aModule) {return (aModule.__file__ != undefined)}],
+'currentModule', 'setModule', aModule);
+return result;
+}
+events.endModule = function (aModule) {
+// It should only reported once, so check if it already has been done
+if (aModule.__status__ === 'done')
+return;
+aModule.__end__ = Date.now();
+aModule.__status__ = 'done';
+var obj = {
+'filename': aModule.__file__,
+'time_start': aModule.__start__,
+'time_end': aModule.__end__
+}
+events.fireEvent('endModule', obj);
+}
+events.pass = function (obj) {
+// a low level event, such as a keystroke, succeeds
+if (events.currentTest) {
+events.currentTest.__passes__.push(obj);
+}
+for each (var timer in timers) {
+timer.actions.push(
+{"currentTest": events.currentModule.__file__ + "::" + events.currentTest.__name__,
+"obj": obj,
+"result": "pass"}
+);
+}
+events.fireEvent('pass', obj);
+}
+events.fail = function (obj) {
+var error = obj.exception;
+if (error) {
+// Error objects aren't enumerable https://bugzilla.mozilla.org/show_bug.cgi?id=637207
+obj.exception = {
+name: error.name,
+message: error.message,
+lineNumber: error.lineNumber,
+fileName: error.fileName,
+stack: error.stack
+};
+}
+// a low level event, such as a keystroke, fails
+if (events.currentTest) {
+events.currentTest.__fails__.push(obj);
+}
+for each (var time in timers) {
+timer.actions.push(
+{"currentTest": events.currentModule.__file__ + "::" + events.currentTest.__name__,
+"obj": obj,
+"result": "fail"}
+);
+}
+events.fireEvent('fail', obj);
+}
+events.skip = function (reason) {
+// this is used to report skips associated with setupModule and nothing else
+events.currentTest.skipped = true;
+events.currentTest.skipped_reason = reason;
+for (var timer of timers) {
+timer.actions.push(
+{"currentTest": events.currentModule.__file__ + "::" + events.currentTest.__name__,
+"obj": reason,
+"result": "skip"}
+);
+}
+events.fireEvent('skip', reason);
+}
+events.fireEvent = function (name, obj) {
+if (events.appQuit) {
+// dump('* Event discarded: ' + name + ' ' + JSON.stringify(obj) + '\n');
+return;
+}
+if (this.listeners[name]) {
+for (var i in this.listeners[name]) {
+this.listeners[name][i](obj);
+}
+}
+for each(var listener in this.globalListeners) {
+listener(name, obj);
+}
+}
+events.addListener = function (name, listener) {
+if (this.listeners[name]) {
+this.listeners[name].push(listener);
+} else if (name == '') {
+this.globalListeners.push(listener)
+} else {
+this.listeners[name] = [listener];
+}
+}
+events.removeListener = function (listener) {
+for (var listenerIndex in this.listeners) {
+var e = this.listeners[listenerIndex];
+for (var i in e){
+if (e[i] == listener) {
+this.listeners[listenerIndex] = arrays.remove(e, i);
+}
+}
+}
+for (var i in this.globalListeners) {
+if (this.globalListeners[i] == listener) {
+this.globalListeners = arrays.remove(this.globalListeners, i);
+}
+}
+}
+events.persist = function () {
+try {
+events.fireEvent('persist', persisted);
+} catch (e) {
+events.fireEvent('error', "persist serialization failed.")
+}
+}
+events.firePythonCallback = function (obj) {
+obj['test'] = events.currentModule.__file__;
+events.fireEvent('firePythonCallback', obj);
+}
+events.screenshot = function (obj) {
+// Find the name of the test function
+for (var attr in events.currentModule) {
+if (events.currentModule[attr] == events.currentTest) {
+var testName = attr;
+break;
+}
+}
+obj['test_file'] = events.currentModule.__file__;
+obj['test_name'] = testName;
+events.fireEvent('screenshot', obj);
+}
+var log = function (obj) {
+events.fireEvent('log', obj);
+}
+// Register the listeners
+broker.addObject({'endTest': events.endTest,
+'fail': events.fail,
+'firePythonCallback': events.firePythonCallback,
+'log': log,
+'pass': events.pass,
+'persist': events.persist,
+'screenshot': events.screenshot,
+'shutdown': events.startShutdown,
+});
+try {
+Cu.import('resource://jsbridge/modules/Events.jsm');
+events.addListener('', function (name, obj) {
+Events.fireEvent('mozmill.' + name, obj);
+});
+} catch (e) {
+Services.console.logStringMessage("Event module of JSBridge not available.");
+}
+/**
+* Observer for notifications when the application is going to shutdown
+*/
+function AppQuitObserver() {
+this.runner = null;
+Services.obs.addObserver(this, "quit-application-requested", false);
+}
+AppQuitObserver.prototype = {
+observe: function (aSubject, aTopic, aData) {
+switch (aTopic) {
+case "quit-application-requested":
+Services.obs.removeObserver(this, "quit-application-requested");
+// If we observe a quit notification make sure to send the
+// results of the current test. In those cases we don't reach
+// the equivalent code in runTestModule()
+events.pass({'message': 'AppQuitObserver: ' + JSON.stringify(aData),
+'userShutdown': events.userShutdown});
+if (this.runner) {
+this.runner.end();
+}
+if (httpd) {
+httpd.stop();
+}
+events.appQuit = true;
+break;
+}
+}
+}
+var appQuitObserver = new AppQuitObserver();
+/**
+* The collector handles HTTPd.js and initilizing the module
+*/
+function Collector() {
+this.test_modules_by_filename = {};
+this.testing = [];
+}
+Collector.prototype.addHttpResource = function (aDirectory, aPath) {
+var fp = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFile);
+fp.initWithPath(os.abspath(aDirectory, this.current_file));
+return httpd.addHttpResource(fp, aPath);
+}
+Collector.prototype.initTestModule = function (filename, testname) {
+var test_module = this.loadFile(filename, this);
+var has_restarted = !(testname == null);
+test_module.__tests__ = [];
+for (var i in test_module) {
+if (typeof(test_module[i]) == "function") {
+test_module[i].__name__ = i;
+// Only run setupModule if we are a single test OR if we are the first
+// test of a restart chain (don't run it prior to members in a restart
+// chain)
+if (i == "setupModule" && !has_restarted) {
+test_module.__setupModule__ = test_module[i];
+} else if (i == "setupTest") {
+test_module.__setupTest__ = test_module[i];
+} else if (i == "teardownTest") {
+test_module.__teardownTest__ = test_module[i];
+} else if (i == "teardownModule") {
+test_module.__teardownModule__ = test_module[i];
+} else if (withs.startsWith(i, "test")) {
+if (testname && (i != testname)) {
+continue;
+}
+testname = null;
+test_module.__tests__.push(test_module[i]);
+}
+}
+}
+test_module.collector = this;
+test_module.status = 'loaded';
+this.test_modules_by_filename[filename] = test_module;
+return test_module;
+}
+Collector.prototype.loadFile = function (path, collector) {
+var moduleLoader = new securableModule.Loader({
+rootPaths: ["resource://mozmill/modules/"],
+defaultPrincipal: "system",
+globals : { Cc: Cc,
+Ci: Ci,
+Cu: Cu,
+Cr: Components.results}
+});
+// load a test module from a file and add some candy
+var file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFile);
+file.initWithPath(path);
+var uri = Services.io.newFileURI(file).spec;
+this.loadTestResources();
+var systemPrincipal = Services.scriptSecurityManager.getSystemPrincipal();
+var module = new Components.utils.Sandbox(systemPrincipal);
+module.assert = new assertions.Assert();
+module.Cc = Cc;
+module.Ci = Ci;
+module.Cr = Components.results;
+module.Cu = Cu;
+module.collector = collector;
+module.driver = moduleLoader.require("driver");
+module.elementslib = mozelement;
+module.errors = errors;
+module.expect = new assertions.Expect();
+module.findElement = mozelement;
+module.log = log;
+module.mozmill = mozmill;
+module.persisted = persisted;
+module.require = function (mod) {
+var loader = new securableModule.Loader({
+rootPaths: [Services.io.newFileURI(file.parent).spec,
+"resource://mozmill/modules/"],
+defaultPrincipal: "system",
+globals : { mozmill: mozmill,
+elementslib: mozelement,      // This a quick hack to maintain backwards compatibility with 1.5.x
+findElement: mozelement,
+persisted: persisted,
+Cc: Cc,
+Ci: Ci,
+Cu: Cu,
+log: log }
+});
+if (modules != undefined) {
+loader.modules = modules;
+}
+var retval = loader.require(mod);
+modules = loader.modules;
+return retval;
+}
+if (collector != undefined) {
+collector.current_file = file;
+collector.current_path = path;
+}
+try {
+Services.scriptloader.loadSubScript(uri, module, "UTF-8");
+} catch (e) {
+var obj = {
+'filename': path,
+'passed': 0,
+'failed': 1,
+'passes': [],
+'fails' : [{'exception' : {
+message: e.message,
+filename: e.filename,
+lineNumber: e.lineNumber}}],
+'name'  :'<TOP_LEVEL>'
+};
+events.fail({'exception': e});
+events.fireEvent('endTest', obj);
+}
+module.__file__ = path;
+module.__uri__ = uri;
+return module;
+}
+Collector.prototype.loadTestResources = function () {
+// load resources we want in our tests
+if (mozmill === undefined) {
+mozmill = {};
+Cu.import("resource://mozmill/driver/mozmill.js", mozmill);
+}
+if (mozelement === undefined) {
+mozelement = {};
+Cu.import("resource://mozmill/driver/mozelement.js", mozelement);
+}
+}
+/**
+*
+*/
+function Httpd(aPort) {
+this.http_port = aPort;
+while (true) {
+try {
+var srv = new HttpServer();
+srv.registerContentType("sjs", "sjs");
+srv.identity.setPrimary("http", "localhost", this.http_port);
+srv.start(this.http_port);
+this._httpd = srv;
+break;
+}
+catch (e) {
+// Failure most likely due to port conflict
+this.http_port++;
+}
+}
+}
+Httpd.prototype.addHttpResource = function (aDir, aPath) {
+var path = aPath ? ("/" + aPath + "/") : "/";
+try {
+this._httpd.registerDirectory(path, aDir);
+return 'http://localhost:' + this.http_port + path;
+}
+catch (e) {
+throw Error("Failure to register directory: " + aDir.path);
+}
+};
+Httpd.prototype.stop = function () {
+if (!this._httpd) {
+return;
+}
+var shutdown = false;
+this._httpd.stop(function () { shutdown = true; });
+assert.waitFor(function () {
+return shutdown;
+}, "Local HTTP server has been stopped", TIMEOUT_SHUTDOWN_HTTPD);
+this._httpd = null;
+};
+function startHTTPd() {
+if (!httpd) {
+// Ensure that we start the HTTP server only once during a session
+httpd = new Httpd(43336);
+}
+}
+function Runner() {
+this.collector = new Collector();
+this.ended = false;
+var m = {}; Cu.import('resource://mozmill/driver/mozmill.js', m);
+this.platform = m.platform;
+events.fireEvent('startRunner', true);
+}
+Runner.prototype.end = function () {
+if (!this.ended) {
+this.ended = true;
+appQuitObserver.runner = null;
+events.endTest();
+events.endModule(events.currentModule);
+events.fireEvent('endRunner', true);
+events.persist();
+}
+};
+Runner.prototype.runTestFile = function (filename, name) {
+var module = this.collector.initTestModule(filename, name);
+this.runTestModule(module);
+};
+Runner.prototype.runTestModule = function (module) {
+appQuitObserver.runner = this;
+events.setModule(module);
+// If setupModule passes, run all the tests. Otherwise mark them as skipped.
+if (this.execFunction(module.__setupModule__, module)) {
+for (var test of module.__tests__) {
+if (events.shutdownRequested) {
+break;
+}
+// If setupTest passes, run the test. Otherwise mark it as skipped.
+if (this.execFunction(module.__setupTest__, module)) {
+this.execFunction(test);
+} else {
+this.skipFunction(test, module.__setupTest__.__name__ + " failed");
+}
+this.execFunction(module.__teardownTest__, module);
+}
+} else {
+for (var test of module.__tests__) {
+this.skipFunction(test, module.__setupModule__.__name__ + " failed");
+}
+}
+this.execFunction(module.__teardownModule__, module);
+events.endModule(module);
+};
+Runner.prototype.execFunction = function (func, arg) {
+if (typeof func !== "function" || events.shutdownRequested) {
+return true;
+}
+var isTest = withs.startsWith(func.__name__, "test");
+events.setState(isTest ? "test" : func.__name);
+events.setTest(func);
+// skip excluded platforms
+if (func.EXCLUDED_PLATFORMS != undefined) {
+if (arrays.inArray(func.EXCLUDED_PLATFORMS, this.platform)) {
+events.skip("Platform exclusion");
+events.endTest(func);
+return false;
+}
+}
+// skip function if requested
+if (func.__force_skip__ != undefined) {
+events.skip(func.__force_skip__);
+events.endTest(func);
+return false;
+}
+// execute the test function
+try {
+func(arg);
+} catch (e) {
+if (e instanceof errors.ApplicationQuitError) {
+events.shutdownRequested = true;
+} else {
+events.fail({'exception': e, 'test': func})
+}
+}
+// If a user shutdown has been requested and the function already returned,
+// we can assume that a shutdown will not happen anymore. We should force a
+// shutdown then, to prevent the next test from being executed.
+if (events.isUserShutdown()) {
+events.shutdownRequested = true;
+events.toggleUserShutdown(events.userShutdown);
+}
+events.endTest(func);
+return events.currentTest.__fails__.length == 0;
+};
+function runTestFile(filename, name) {
+var runner = new Runner();
+runner.runTestFile(filename, name);
+runner.end();
+return true;
+}
+Runner.prototype.skipFunction = function (func, message) {
+events.setTest(func);
+events.skip(message);
+events.endTest(func);
+};