From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- .../CaptivePortalDetectComponents.manifest | 2 + toolkit/components/captivedetect/captivedetect.js | 476 +++++++++++++++++++++ toolkit/components/captivedetect/moz.build | 19 + .../captivedetect/nsICaptivePortalDetector.idl | 53 +++ .../captivedetect/test/unit/.eslintrc.js | 7 + .../captivedetect/test/unit/head_setprefs.js | 49 +++ .../captivedetect/test/unit/test_abort.js | 53 +++ .../test/unit/test_abort_during_user_login.js | 66 +++ .../test/unit/test_abort_ongoing_request.js | 72 ++++ .../test/unit/test_abort_pending_request.js | 71 +++ .../test/unit/test_captive_portal_found.js | 67 +++ .../test/unit/test_captive_portal_found_303.js | 74 ++++ .../test/unit/test_captive_portal_not_found.js | 52 +++ .../test/unit/test_captive_portal_not_found_404.js | 49 +++ .../test/unit/test_multiple_requests.js | 83 ++++ .../captivedetect/test/unit/test_user_cancel.js | 54 +++ .../captivedetect/test/unit/xpcshell.ini | 15 + 17 files changed, 1262 insertions(+) create mode 100644 toolkit/components/captivedetect/CaptivePortalDetectComponents.manifest create mode 100644 toolkit/components/captivedetect/captivedetect.js create mode 100644 toolkit/components/captivedetect/moz.build create mode 100644 toolkit/components/captivedetect/nsICaptivePortalDetector.idl create mode 100644 toolkit/components/captivedetect/test/unit/.eslintrc.js create mode 100644 toolkit/components/captivedetect/test/unit/head_setprefs.js create mode 100644 toolkit/components/captivedetect/test/unit/test_abort.js create mode 100644 toolkit/components/captivedetect/test/unit/test_abort_during_user_login.js create mode 100644 toolkit/components/captivedetect/test/unit/test_abort_ongoing_request.js create mode 100644 toolkit/components/captivedetect/test/unit/test_abort_pending_request.js create mode 100644 toolkit/components/captivedetect/test/unit/test_captive_portal_found.js create mode 100644 toolkit/components/captivedetect/test/unit/test_captive_portal_found_303.js create mode 100644 toolkit/components/captivedetect/test/unit/test_captive_portal_not_found.js create mode 100644 toolkit/components/captivedetect/test/unit/test_captive_portal_not_found_404.js create mode 100644 toolkit/components/captivedetect/test/unit/test_multiple_requests.js create mode 100644 toolkit/components/captivedetect/test/unit/test_user_cancel.js create mode 100644 toolkit/components/captivedetect/test/unit/xpcshell.ini (limited to 'toolkit/components/captivedetect') diff --git a/toolkit/components/captivedetect/CaptivePortalDetectComponents.manifest b/toolkit/components/captivedetect/CaptivePortalDetectComponents.manifest new file mode 100644 index 000000000..490545c82 --- /dev/null +++ b/toolkit/components/captivedetect/CaptivePortalDetectComponents.manifest @@ -0,0 +1,2 @@ +component {d9cd00ba-aa4d-47b1-8792-b1fe0cd35060} captivedetect.js +contract @mozilla.org/toolkit/captive-detector;1 {d9cd00ba-aa4d-47b1-8792-b1fe0cd35060} diff --git a/toolkit/components/captivedetect/captivedetect.js b/toolkit/components/captivedetect/captivedetect.js new file mode 100644 index 000000000..5493ecec6 --- /dev/null +++ b/toolkit/components/captivedetect/captivedetect.js @@ -0,0 +1,476 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +'use strict'; + +const { classes: Cc, interfaces: Ci, results: Cr, utils: Cu } = Components; + +Cu.import('resource://gre/modules/XPCOMUtils.jsm'); +Cu.import('resource://gre/modules/Services.jsm'); + +XPCOMUtils.defineLazyServiceGetter(this, "gSysMsgr", + "@mozilla.org/system-message-internal;1", + "nsISystemMessagesInternal"); + +const DEBUG = false; // set to true to show debug messages + +const kCAPTIVEPORTALDETECTOR_CONTRACTID = '@mozilla.org/toolkit/captive-detector;1'; +const kCAPTIVEPORTALDETECTOR_CID = Components.ID('{d9cd00ba-aa4d-47b1-8792-b1fe0cd35060}'); + +const kOpenCaptivePortalLoginEvent = 'captive-portal-login'; +const kAbortCaptivePortalLoginEvent = 'captive-portal-login-abort'; +const kCaptivePortalLoginSuccessEvent = 'captive-portal-login-success'; +const kCaptivePortalCheckComplete = 'captive-portal-check-complete'; + +const kCaptivePortalSystemMessage = 'captive-portal'; + +function URLFetcher(url, timeout) { + let self = this; + let xhr = Cc['@mozilla.org/xmlextras/xmlhttprequest;1'] + .createInstance(Ci.nsIXMLHttpRequest); + xhr.open('GET', url, true); + // Prevent the request from reading from the cache. + xhr.channel.loadFlags |= Ci.nsIRequest.LOAD_BYPASS_CACHE; + // Prevent the request from writing to the cache. + xhr.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING; + // Prevent privacy leaks + xhr.channel.loadFlags |= Ci.nsIRequest.LOAD_ANONYMOUS; + // The Cache-Control header is only interpreted by proxies and the + // final destination. It does not help if a resource is already + // cached locally. + xhr.setRequestHeader("Cache-Control", "no-cache"); + // HTTP/1.0 servers might not implement Cache-Control and + // might only implement Pragma: no-cache + xhr.setRequestHeader("Pragma", "no-cache"); + + xhr.timeout = timeout; + xhr.ontimeout = function () { self.ontimeout(); }; + xhr.onerror = function () { self.onerror(); }; + xhr.onreadystatechange = function(oEvent) { + if (xhr.readyState === 4) { + if (self._isAborted) { + return; + } + if (xhr.status === 200) { + self.onsuccess(xhr.responseText); + } else if (xhr.status) { + self.onredirectorerror(xhr.status); + } + } + }; + xhr.send(); + this._xhr = xhr; +} + +URLFetcher.prototype = { + _isAborted: false, + ontimeout: function() {}, + onerror: function() {}, + abort: function() { + if (!this._isAborted) { + this._isAborted = true; + this._xhr.abort(); + } + }, +} + +function LoginObserver(captivePortalDetector) { + const LOGIN_OBSERVER_STATE_DETACHED = 0; /* Should not monitor network activity since no ongoing login procedure */ + const LOGIN_OBSERVER_STATE_IDLE = 1; /* No network activity currently, waiting for a longer enough idle period */ + const LOGIN_OBSERVER_STATE_BURST = 2; /* Network activity is detected, probably caused by a login procedure */ + const LOGIN_OBSERVER_STATE_VERIFY_NEEDED = 3; /* Verifing network accessiblity is required after a long enough idle */ + const LOGIN_OBSERVER_STATE_VERIFYING = 4; /* LoginObserver is probing if public network is available */ + + let state = LOGIN_OBSERVER_STATE_DETACHED; + + let timer = Cc['@mozilla.org/timer;1'].createInstance(Ci.nsITimer); + let activityDistributor = Cc['@mozilla.org/network/http-activity-distributor;1'] + .getService(Ci.nsIHttpActivityDistributor); + let urlFetcher = null; + + let waitForNetworkActivity = Services.appinfo.widgetToolkit == "gonk"; + + let pageCheckingDone = function pageCheckingDone() { + if (state === LOGIN_OBSERVER_STATE_VERIFYING) { + urlFetcher = null; + // Finish polling the canonical site, switch back to idle state and + // waiting for next burst + state = LOGIN_OBSERVER_STATE_IDLE; + timer.initWithCallback(observer, + captivePortalDetector._pollingTime, + timer.TYPE_ONE_SHOT); + } + }; + + let checkPageContent = function checkPageContent() { + debug("checking if public network is available after the login procedure"); + + urlFetcher = new URLFetcher(captivePortalDetector._canonicalSiteURL, + captivePortalDetector._maxWaitingTime); + urlFetcher.ontimeout = pageCheckingDone; + urlFetcher.onerror = pageCheckingDone; + urlFetcher.onsuccess = function (content) { + if (captivePortalDetector.validateContent(content)) { + urlFetcher = null; + captivePortalDetector.executeCallback(true); + } else { + pageCheckingDone(); + } + }; + urlFetcher.onredirectorerror = pageCheckingDone; + }; + + // Public interface of LoginObserver + let observer = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsIHttpActivityObserver, + Ci.nsITimerCallback]), + + attach: function attach() { + if (state === LOGIN_OBSERVER_STATE_DETACHED) { + activityDistributor.addObserver(this); + state = LOGIN_OBSERVER_STATE_IDLE; + timer.initWithCallback(this, + captivePortalDetector._pollingTime, + timer.TYPE_ONE_SHOT); + debug('attach HttpObserver for login activity'); + } + }, + + detach: function detach() { + if (state !== LOGIN_OBSERVER_STATE_DETACHED) { + if (urlFetcher) { + urlFetcher.abort(); + urlFetcher = null; + } + activityDistributor.removeObserver(this); + timer.cancel(); + state = LOGIN_OBSERVER_STATE_DETACHED; + debug('detach HttpObserver for login activity'); + } + }, + + /* + * Treat all HTTP transactions as captive portal login activities. + */ + observeActivity: function observeActivity(aHttpChannel, aActivityType, + aActivitySubtype, aTimestamp, + aExtraSizeData, aExtraStringData) { + if (aActivityType === Ci.nsIHttpActivityObserver.ACTIVITY_TYPE_HTTP_TRANSACTION + && aActivitySubtype === Ci.nsIHttpActivityObserver.ACTIVITY_SUBTYPE_RESPONSE_COMPLETE) { + switch (state) { + case LOGIN_OBSERVER_STATE_IDLE: + case LOGIN_OBSERVER_STATE_VERIFY_NEEDED: + state = LOGIN_OBSERVER_STATE_BURST; + break; + default: + break; + } + } + }, + + /* + * Check if login activity is finished according to HTTP burst. + */ + notify : function notify() { + switch (state) { + case LOGIN_OBSERVER_STATE_BURST: + // Wait while network stays idle for a short period + state = LOGIN_OBSERVER_STATE_VERIFY_NEEDED; + // Fall though to start polling timer + case LOGIN_OBSERVER_STATE_IDLE: + if (waitForNetworkActivity) { + timer.initWithCallback(this, + captivePortalDetector._pollingTime, + timer.TYPE_ONE_SHOT); + break; + } + // if we don't need to wait for network activity, just fall through + // to perform a captive portal check. + case LOGIN_OBSERVER_STATE_VERIFY_NEEDED: + // Polling the canonical website since network stays idle for a while + state = LOGIN_OBSERVER_STATE_VERIFYING; + checkPageContent(); + break; + + default: + break; + } + }, + }; + + return observer; +} + +function CaptivePortalDetector() { + // Load preference + this._canonicalSiteURL = null; + this._canonicalSiteExpectedContent = null; + + try { + this._canonicalSiteURL = + Services.prefs.getCharPref('captivedetect.canonicalURL'); + this._canonicalSiteExpectedContent = + Services.prefs.getCharPref('captivedetect.canonicalContent'); + } catch (e) { + debug('canonicalURL or canonicalContent not set.') + } + + this._maxWaitingTime = + Services.prefs.getIntPref('captivedetect.maxWaitingTime'); + this._pollingTime = + Services.prefs.getIntPref('captivedetect.pollingTime'); + this._maxRetryCount = + Services.prefs.getIntPref('captivedetect.maxRetryCount'); + debug('Load Prefs {site=' + this._canonicalSiteURL + ',content=' + + this._canonicalSiteExpectedContent + ',time=' + this._maxWaitingTime + + "max-retry=" + this._maxRetryCount + '}'); + + // Create HttpObserver for monitoring the login procedure + this._loginObserver = LoginObserver(this); + + this._nextRequestId = 0; + this._runningRequest = null; + this._requestQueue = []; // Maintain a progress table, store callbacks and the ongoing XHR + this._interfaceNames = {}; // Maintain names of the requested network interfaces + + debug('CaptiveProtalDetector initiated, waiting for network connection established'); +} + +CaptivePortalDetector.prototype = { + classID: kCAPTIVEPORTALDETECTOR_CID, + classInfo: XPCOMUtils.generateCI({classID: kCAPTIVEPORTALDETECTOR_CID, + contractID: kCAPTIVEPORTALDETECTOR_CONTRACTID, + classDescription: 'Captive Portal Detector', + interfaces: [Ci.nsICaptivePortalDetector]}), + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalDetector]), + + // nsICaptivePortalDetector + checkCaptivePortal: function checkCaptivePortal(aInterfaceName, aCallback) { + if (!this._canonicalSiteURL) { + throw Components.Exception('No canonical URL set up.'); + } + + // Prevent multiple requests on a single network interface + if (this._interfaceNames[aInterfaceName]) { + throw Components.Exception('Do not allow multiple request on one interface: ' + aInterfaceName); + } + + let request = {interfaceName: aInterfaceName}; + if (aCallback) { + let callback = aCallback.QueryInterface(Ci.nsICaptivePortalCallback); + request['callback'] = callback; + request['retryCount'] = 0; + } + this._addRequest(request); + }, + + abort: function abort(aInterfaceName) { + debug('abort for ' + aInterfaceName); + this._removeRequest(aInterfaceName); + }, + + finishPreparation: function finishPreparation(aInterfaceName) { + debug('finish preparation phase for interface "' + aInterfaceName + '"'); + if (!this._runningRequest + || this._runningRequest.interfaceName !== aInterfaceName) { + debug('invalid finishPreparation for ' + aInterfaceName); + throw Components.Exception('only first request is allowed to invoke |finishPreparation|'); + } + + this._startDetection(); + }, + + cancelLogin: function cancelLogin(eventId) { + debug('login canceled by user for request "' + eventId + '"'); + // Captive portal login procedure is canceled by user + if (this._runningRequest && this._runningRequest.hasOwnProperty('eventId')) { + let id = this._runningRequest.eventId; + if (eventId === id) { + this.executeCallback(false); + } + } + }, + + _applyDetection: function _applyDetection() { + debug('enter applyDetection('+ this._runningRequest.interfaceName + ')'); + + // Execute network interface preparation + if (this._runningRequest.hasOwnProperty('callback')) { + this._runningRequest.callback.prepare(); + } else { + this._startDetection(); + } + }, + + _startDetection: function _startDetection() { + debug('startDetection {site=' + this._canonicalSiteURL + ',content=' + + this._canonicalSiteExpectedContent + ',time=' + this._maxWaitingTime + '}'); + let self = this; + + let urlFetcher = new URLFetcher(this._canonicalSiteURL, this._maxWaitingTime); + + let mayRetry = this._mayRetry.bind(this); + + urlFetcher.ontimeout = mayRetry; + urlFetcher.onerror = mayRetry; + urlFetcher.onsuccess = function (content) { + if (self.validateContent(content)) { + self.executeCallback(true); + } else { + // Content of the canonical website has been overwrite + self._startLogin(); + } + }; + urlFetcher.onredirectorerror = function (status) { + if (status >= 300 && status <= 399) { + // The canonical website has been redirected to an unknown location + self._startLogin(); + } else { + mayRetry(); + } + }; + + this._runningRequest['urlFetcher'] = urlFetcher; + }, + + _startLogin: function _startLogin() { + let id = this._allocateRequestId(); + let details = { + type: kOpenCaptivePortalLoginEvent, + id: id, + url: this._canonicalSiteURL, + }; + this._loginObserver.attach(); + this._runningRequest['eventId'] = id; + this._sendEvent(kOpenCaptivePortalLoginEvent, details); + gSysMsgr.broadcastMessage(kCaptivePortalSystemMessage, {}); + }, + + _mayRetry: function _mayRetry() { + if (this._runningRequest.retryCount++ < this._maxRetryCount) { + debug('retry-Detection: ' + this._runningRequest.retryCount + '/' + this._maxRetryCount); + this._startDetection(); + } else { + this.executeCallback(false); + } + }, + + executeCallback: function executeCallback(success) { + if (this._runningRequest) { + debug('callback executed'); + if (this._runningRequest.hasOwnProperty('callback')) { + this._runningRequest.callback.complete(success); + } + + // Only when the request has a event id and |success| is true + // do we need to notify the login-success event. + if (this._runningRequest.hasOwnProperty('eventId') && success) { + let details = { + type: kCaptivePortalLoginSuccessEvent, + id: this._runningRequest['eventId'], + }; + this._sendEvent(kCaptivePortalLoginSuccessEvent, details); + } + + // Continue the following request + this._runningRequest['complete'] = true; + this._removeRequest(this._runningRequest.interfaceName); + } + }, + + _sendEvent: function _sendEvent(topic, details) { + debug('sendEvent "' + JSON.stringify(details) + '"'); + Services.obs.notifyObservers(this, + topic, + JSON.stringify(details)); + }, + + validateContent: function validateContent(content) { + debug('received content: ' + content); + let valid = content === this._canonicalSiteExpectedContent; + // We need a way to indicate that a check has been performed, and if we are + // still in a captive portal. + this._sendEvent(kCaptivePortalCheckComplete, !valid); + return valid; + }, + + _allocateRequestId: function _allocateRequestId() { + let newId = this._nextRequestId++; + return newId.toString(); + }, + + _runNextRequest: function _runNextRequest() { + let nextRequest = this._requestQueue.shift(); + if (nextRequest) { + this._runningRequest = nextRequest; + this._applyDetection(); + } + }, + + _addRequest: function _addRequest(request) { + this._interfaceNames[request.interfaceName] = true; + this._requestQueue.push(request); + if (!this._runningRequest) { + this._runNextRequest(); + } + }, + + _removeRequest: function _removeRequest(aInterfaceName) { + if (!this._interfaceNames[aInterfaceName]) { + return; + } + + delete this._interfaceNames[aInterfaceName]; + + if (this._runningRequest + && this._runningRequest.interfaceName === aInterfaceName) { + this._loginObserver.detach(); + + if (!this._runningRequest.complete) { + // Abort the user login procedure + if (this._runningRequest.hasOwnProperty('eventId')) { + let details = { + type: kAbortCaptivePortalLoginEvent, + id: this._runningRequest.eventId + }; + this._sendEvent(kAbortCaptivePortalLoginEvent, details); + } + + // Abort the ongoing HTTP request + if (this._runningRequest.hasOwnProperty('urlFetcher')) { + this._runningRequest.urlFetcher.abort(); + } + } + + debug('remove running request'); + this._runningRequest = null; + + // Continue next pending reqeust if the ongoing one has been aborted + this._runNextRequest(); + return; + } + + // Check if a pending request has been aborted + for (let i = 0; i < this._requestQueue.length; i++) { + if (this._requestQueue[i].interfaceName == aInterfaceName) { + this._requestQueue.splice(i, 1); + + debug('remove pending request #' + i + ', remaining ' + this._requestQueue.length); + break; + } + } + }, +}; + +var debug; +if (DEBUG) { + debug = function (s) { + dump('-*- CaptivePortalDetector component: ' + s + '\n'); + }; +} else { + debug = function (s) {}; +} + +this.NSGetFactory = XPCOMUtils.generateNSGetFactory([CaptivePortalDetector]); diff --git a/toolkit/components/captivedetect/moz.build b/toolkit/components/captivedetect/moz.build new file mode 100644 index 000000000..3bb9cf573 --- /dev/null +++ b/toolkit/components/captivedetect/moz.build @@ -0,0 +1,19 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +XPCSHELL_TESTS_MANIFESTS += ['test/unit/xpcshell.ini'] + +XPIDL_SOURCES += [ + 'nsICaptivePortalDetector.idl', +] + +XPIDL_MODULE = 'captivedetect' + +EXTRA_COMPONENTS += [ + 'captivedetect.js', + 'CaptivePortalDetectComponents.manifest', +] + diff --git a/toolkit/components/captivedetect/nsICaptivePortalDetector.idl b/toolkit/components/captivedetect/nsICaptivePortalDetector.idl new file mode 100644 index 000000000..631685451 --- /dev/null +++ b/toolkit/components/captivedetect/nsICaptivePortalDetector.idl @@ -0,0 +1,53 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#include "nsISupports.idl" + +[scriptable, uuid(593fdeec-6284-4de8-b416-8e63cbdc695e)] +interface nsICaptivePortalCallback : nsISupports +{ + /** + * Preparation for network interface before captive portal detection started. + */ + void prepare(); + + /** + * Invoke callbacks after captive portal detection finished. + */ + void complete(in bool success); +}; + +[scriptable, uuid(2f827c5a-f551-477f-af09-71adbfbd854a)] +interface nsICaptivePortalDetector : nsISupports +{ + /** + * Perform captive portal detection on specific network interface. + * @param ifname The name of network interface, exception will be thrwon + * if the same interface has unfinished request. + * @param callback Callbacks when detection procedure starts and finishes. + */ + void checkCaptivePortal(in wstring ifname, + in nsICaptivePortalCallback callback); + + /** + * Abort captive portal detection for specific network interface + * due to system failure, callback will not be invoked. + * @param ifname The name of network interface. + */ + void abort(in wstring ifname); + + /** + * Cancel captive portal login procedure by user, callback will be invoked. + * @param eventId Login event id provided in |captive-portal-login| event. + */ + void cancelLogin(in wstring eventId); + + /** + * Notify prepare phase is finished, routing and dns must be ready for sending + * out XMLHttpRequest. this is callback for CaptivePortalDetector API user. + * @param ifname The name of network interface, must be unique. + */ + void finishPreparation(in wstring ifname); +}; diff --git a/toolkit/components/captivedetect/test/unit/.eslintrc.js b/toolkit/components/captivedetect/test/unit/.eslintrc.js new file mode 100644 index 000000000..d35787cd2 --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/.eslintrc.js @@ -0,0 +1,7 @@ +"use strict"; + +module.exports = { + "extends": [ + "../../../../../testing/xpcshell/xpcshell.eslintrc.js" + ] +}; diff --git a/toolkit/components/captivedetect/test/unit/head_setprefs.js b/toolkit/components/captivedetect/test/unit/head_setprefs.js new file mode 100644 index 000000000..bf621e31e --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/head_setprefs.js @@ -0,0 +1,49 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ +'use strict'; + +var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +Cu.import('resource://gre/modules/XPCOMUtils.jsm'); +Cu.import('resource://gre/modules/Services.jsm'); +Cu.import('resource://testing-common/httpd.js'); + +XPCOMUtils.defineLazyServiceGetter(this, 'gCaptivePortalDetector', + '@mozilla.org/toolkit/captive-detector;1', + 'nsICaptivePortalDetector'); + +const kCanonicalSitePath = '/canonicalSite.html'; +const kCanonicalSiteContent = 'true'; +const kPrefsCanonicalURL = 'captivedetect.canonicalURL'; +const kPrefsCanonicalContent = 'captivedetect.canonicalContent'; +const kPrefsMaxWaitingTime = 'captivedetect.maxWaitingTime'; +const kPrefsPollingTime = 'captivedetect.pollingTime'; + +var gServer; +var gServerURL; + +function setupPrefs() { + let prefs = Components.classes["@mozilla.org/preferences-service;1"] + .getService(Components.interfaces.nsIPrefService) + .QueryInterface(Components.interfaces.nsIPrefBranch); + prefs.setCharPref(kPrefsCanonicalURL, gServerURL + kCanonicalSitePath); + prefs.setCharPref(kPrefsCanonicalContent, kCanonicalSiteContent); + prefs.setIntPref(kPrefsMaxWaitingTime, 0); + prefs.setIntPref(kPrefsPollingTime, 1); +} + +function run_captivedetect_test(xhr_handler, fakeUIResponse, testfun) +{ + gServer = new HttpServer(); + gServer.registerPathHandler(kCanonicalSitePath, xhr_handler); + gServer.start(-1); + gServerURL = 'http://localhost:' + gServer.identity.primaryPort; + + setupPrefs(); + + fakeUIResponse(); + + testfun(); +} diff --git a/toolkit/components/captivedetect/test/unit/test_abort.js b/toolkit/components/captivedetect/test/unit/test_abort.js new file mode 100644 index 000000000..f99805dfb --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/test_abort.js @@ -0,0 +1,53 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ +'use strict'; + +const kInterfaceName = 'wifi'; + +var server; +var step = 0; +var loginFinished = false; + +function xhr_handler(metadata, response) { + response.setStatusLine(metadata.httpVersion, 200, 'OK'); + response.setHeader('Cache-Control', 'no-cache', false); + response.setHeader('Content-Type', 'text/plain', false); + if (loginFinished) { + response.write('true'); + } else { + response.write('false'); + } +} + +function fakeUIResponse() { + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login') { + do_throw('should not receive captive-portal-login event'); + } + }, 'captive-portal-login', false); +} + +function test_abort() { + do_test_pending(); + + let callback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 1); + gCaptivePortalDetector.finishPreparation(kInterfaceName); + }, + complete: function complete(success) { + do_throw('should not execute |complete| callback'); + }, + }; + + gCaptivePortalDetector.checkCaptivePortal(kInterfaceName, callback); + gCaptivePortalDetector.abort(kInterfaceName); + gServer.stop(do_test_finished); +} + +function run_test() { + run_captivedetect_test(xhr_handler, fakeUIResponse, test_abort); +} diff --git a/toolkit/components/captivedetect/test/unit/test_abort_during_user_login.js b/toolkit/components/captivedetect/test/unit/test_abort_during_user_login.js new file mode 100644 index 000000000..ef98ac5ea --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/test_abort_during_user_login.js @@ -0,0 +1,66 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ +'use strict'; + +const kInterfaceName = 'wifi'; + +var server; +var step = 0; +var loginFinished = false; + +function xhr_handler(metadata, response) { + response.setStatusLine(metadata.httpVersion, 200, 'OK'); + response.setHeader('Cache-Control', 'no-cache', false); + response.setHeader('Content-Type', 'text/plain', false); + if (loginFinished) { + response.write('true'); + } else { + response.write('false'); + } +} + +function fakeUIResponse() { + let requestId; + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login') { + let xhr = Cc['@mozilla.org/xmlextras/xmlhttprequest;1'] + .createInstance(Ci.nsIXMLHttpRequest); + xhr.open('GET', gServerURL + kCanonicalSitePath, true); + xhr.send(); + loginFinished = true; + do_check_eq(++step, 2); + requestId = JSON.parse(data).id; + gCaptivePortalDetector.abort(kInterfaceName); + } + }, 'captive-portal-login', false); + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login-abort') { + do_check_eq(++step, 3); + do_check_eq(JSON.parse(data).id, requestId); + gServer.stop(do_test_finished); + } + }, 'captive-portal-login-abort', false); +} + +function test_abort() { + do_test_pending(); + + let callback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 1); + gCaptivePortalDetector.finishPreparation(kInterfaceName); + }, + complete: function complete(success) { + do_throw('should not execute |complete| callback'); + }, + }; + + gCaptivePortalDetector.checkCaptivePortal(kInterfaceName, callback); +} + +function run_test() { + run_captivedetect_test(xhr_handler, fakeUIResponse, test_abort); +} diff --git a/toolkit/components/captivedetect/test/unit/test_abort_ongoing_request.js b/toolkit/components/captivedetect/test/unit/test_abort_ongoing_request.js new file mode 100644 index 000000000..ad99903df --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/test_abort_ongoing_request.js @@ -0,0 +1,72 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ +'use strict'; + +const kInterfaceName = 'wifi'; +const kOtherInterfaceName = 'ril'; + +var server; +var step = 0; +var loginFinished = false; + +function xhr_handler(metadata, response) { + response.setStatusLine(metadata.httpVersion, 200, 'OK'); + response.setHeader('Cache-Control', 'no-cache', false); + response.setHeader('Content-Type', 'text/plain', false); + if (loginFinished) { + response.write('true'); + } else { + response.write('false'); + } +} + +function fakeUIResponse() { + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login') { + let xhr = Cc['@mozilla.org/xmlextras/xmlhttprequest;1'] + .createInstance(Ci.nsIXMLHttpRequest); + xhr.open('GET', gServerURL + kCanonicalSitePath, true); + xhr.send(); + loginFinished = true; + do_check_eq(++step, 3); + } + }, 'captive-portal-login', false); +} + +function test_multiple_requests_abort() { + do_test_pending(); + + let callback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 1); + gCaptivePortalDetector.finishPreparation(kInterfaceName); + }, + complete: function complete(success) { + do_throw('should not execute |complete| callback for ' + kInterfaceName); + }, + }; + + let otherCallback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 2); + gCaptivePortalDetector.finishPreparation(kOtherInterfaceName); + }, + complete: function complete(success) { + do_check_eq(++step, 4); + do_check_true(success); + gServer.stop(do_test_finished); + } + }; + + gCaptivePortalDetector.checkCaptivePortal(kInterfaceName, callback); + gCaptivePortalDetector.checkCaptivePortal(kOtherInterfaceName, otherCallback); + gCaptivePortalDetector.abort(kInterfaceName); +} + +function run_test() { + run_captivedetect_test(xhr_handler, fakeUIResponse, test_multiple_requests_abort); +} diff --git a/toolkit/components/captivedetect/test/unit/test_abort_pending_request.js b/toolkit/components/captivedetect/test/unit/test_abort_pending_request.js new file mode 100644 index 000000000..ce36f1e79 --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/test_abort_pending_request.js @@ -0,0 +1,71 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ +'use strict'; + +const kInterfaceName = 'wifi'; +const kOtherInterfaceName = 'ril'; + +var server; +var step = 0; +var loginFinished = false; + +function xhr_handler(metadata, response) { + response.setStatusLine(metadata.httpVersion, 200, 'OK'); + response.setHeader('Cache-Control', 'no-cache', false); + response.setHeader('Content-Type', 'text/plain', false); + if (loginFinished) { + response.write('true'); + } else { + response.write('false'); + } +} + +function fakeUIResponse() { + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login') { + let xhr = Cc['@mozilla.org/xmlextras/xmlhttprequest;1'] + .createInstance(Ci.nsIXMLHttpRequest); + xhr.open('GET', gServerURL + kCanonicalSitePath, true); + xhr.send(); + loginFinished = true; + do_check_eq(++step, 2); + } + }, 'captive-portal-login', false); +} + +function test_abort() { + do_test_pending(); + + let callback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 1); + gCaptivePortalDetector.finishPreparation(kInterfaceName); + }, + complete: function complete(success) { + do_check_eq(++step, 3); + do_check_true(success); + gServer.stop(do_test_finished); + }, + }; + + let otherCallback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_throw('should not execute |prepare| callback for ' + kOtherInterfaceName); + }, + complete: function complete(success) { + do_throw('should not execute |complete| callback for ' + kInterfaceName); + } + }; + + gCaptivePortalDetector.checkCaptivePortal(kInterfaceName, callback); + gCaptivePortalDetector.checkCaptivePortal(kOtherInterfaceName, otherCallback); + gCaptivePortalDetector.abort(kOtherInterfaceName); +} + +function run_test() { + run_captivedetect_test(xhr_handler, fakeUIResponse, test_abort); +} diff --git a/toolkit/components/captivedetect/test/unit/test_captive_portal_found.js b/toolkit/components/captivedetect/test/unit/test_captive_portal_found.js new file mode 100644 index 000000000..7fb7ba89e --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/test_captive_portal_found.js @@ -0,0 +1,67 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ +'use strict'; + +const kInterfaceName = 'wifi'; + +var server; +var step = 0; +var loginFinished = false; + +function xhr_handler(metadata, response) { + response.setStatusLine(metadata.httpVersion, 200, 'OK'); + response.setHeader('Cache-Control', 'no-cache', false); + response.setHeader('Content-Type', 'text/plain', false); + if (loginFinished) { + response.write('true'); + } else { + response.write('false'); + } +} + +function fakeUIResponse() { + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login') { + let xhr = Cc['@mozilla.org/xmlextras/xmlhttprequest;1'] + .createInstance(Ci.nsIXMLHttpRequest); + xhr.open('GET', gServerURL + kCanonicalSitePath, true); + xhr.send(); + loginFinished = true; + do_check_eq(++step, 2); + } + }, 'captive-portal-login', false); + + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login-success') { + do_check_eq(++step, 4); + gServer.stop(do_test_finished); + } + }, 'captive-portal-login-success', false); +} + +function test_portal_found() { + do_test_pending(); + + let callback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 1); + gCaptivePortalDetector.finishPreparation(kInterfaceName); + }, + complete: function complete(success) { + // Since this is a synchronous callback, it must happen before + // 'captive-portal-login-success' is received. + // (Check captivedetect.js::executeCallback + do_check_eq(++step, 3); + do_check_true(success); + }, + }; + + gCaptivePortalDetector.checkCaptivePortal(kInterfaceName, callback); +} + +function run_test() { + run_captivedetect_test(xhr_handler, fakeUIResponse, test_portal_found); +} diff --git a/toolkit/components/captivedetect/test/unit/test_captive_portal_found_303.js b/toolkit/components/captivedetect/test/unit/test_captive_portal_found_303.js new file mode 100644 index 000000000..7064e12c9 --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/test_captive_portal_found_303.js @@ -0,0 +1,74 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ +'use strict'; + +const kInterfaceName = 'wifi'; + +var step = 0; +var loginFinished = false; + +var gRedirectServer; +var gRedirectServerURL; + +function xhr_handler(metadata, response) { + if (loginFinished) { + response.setStatusLine(metadata.httpVersion, 200, 'OK'); + response.setHeader('Cache-Control', 'no-cache', false); + response.setHeader('Content-Type', 'text/plain', false); + response.write('true'); + } else { + response.setStatusLine(metadata.httpVersion, 303, "See Other"); + response.setHeader("Location", gRedirectServerURL, false); + response.setHeader("Content-Type", "text/html", false); + } +} + +function fakeUIResponse() { + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login') { + let xhr = Cc['@mozilla.org/xmlextras/xmlhttprequest;1'] + .createInstance(Ci.nsIXMLHttpRequest); + xhr.open('GET', gServerURL + kCanonicalSitePath, true); + xhr.send(); + loginFinished = true; + do_check_eq(++step, 2); + } + }, 'captive-portal-login', false); + + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login-success') { + do_check_eq(++step, 4); + gServer.stop(function () { + gRedirectServer.stop(do_test_finished); + }); + } + }, 'captive-portal-login-success', false); +} + +function test_portal_found() { + do_test_pending(); + + let callback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 1); + gCaptivePortalDetector.finishPreparation(kInterfaceName); + }, + complete: function complete(success) { + do_check_eq(++step, 3); + do_check_true(success); + }, + }; + + gCaptivePortalDetector.checkCaptivePortal(kInterfaceName, callback); +} + +function run_test() { + gRedirectServer = new HttpServer(); + gRedirectServer.start(-1); + gRedirectServerURL = 'http://localhost:' + gRedirectServer.identity.primaryPort; + + run_captivedetect_test(xhr_handler, fakeUIResponse, test_portal_found); +} diff --git a/toolkit/components/captivedetect/test/unit/test_captive_portal_not_found.js b/toolkit/components/captivedetect/test/unit/test_captive_portal_not_found.js new file mode 100644 index 000000000..1dc4fe009 --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/test_captive_portal_not_found.js @@ -0,0 +1,52 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ +'use strict'; + +const kInterfaceName = 'wifi'; + +var server; +var step = 0; +var attempt = 0; + +function xhr_handler(metadata, response) { + dump('HTTP activity\n'); + response.setStatusLine(metadata.httpVersion, 200, 'OK'); + response.setHeader('Cache-Control', 'no-cache', false); + response.setHeader('Content-Type', 'text/plain', false); + response.write('true'); + attempt++; +} + +function fakeUIResponse() { + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic == 'captive-portal-login') { + do_throw('should not receive captive-portal-login event'); + } + }, 'captive-portal-login', false); +} + +function test_portal_not_found() { + do_test_pending(); + + let callback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 1); + gCaptivePortalDetector.finishPreparation(kInterfaceName); + }, + complete: function complete(success) { + do_check_eq(++step, 2); + do_check_true(success); + do_check_eq(attempt, 1); + gServer.stop(function() { dump('server stop\n'); do_test_finished(); }); + } + }; + + gCaptivePortalDetector.checkCaptivePortal(kInterfaceName, callback); +} + +function run_test() { + run_captivedetect_test(xhr_handler, fakeUIResponse, test_portal_not_found); +} diff --git a/toolkit/components/captivedetect/test/unit/test_captive_portal_not_found_404.js b/toolkit/components/captivedetect/test/unit/test_captive_portal_not_found_404.js new file mode 100644 index 000000000..66bcdd077 --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/test_captive_portal_not_found_404.js @@ -0,0 +1,49 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ +'use strict'; + +const kInterfaceName = 'wifi'; + +var server; +var step = 0; +var loginFinished = false; +var attempt = 0; + +function xhr_handler(metadata, response) { + response.setStatusLine(metadata.httpVersion, 404, "Page not Found"); + attempt++; +} + +function fakeUIResponse() { + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login') { + do_throw('should not receive captive-portal-login event'); + } + }, 'captive-portal-login', false); +} + +function test_portal_not_found() { + do_test_pending(); + + let callback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 1); + gCaptivePortalDetector.finishPreparation(kInterfaceName); + }, + complete: function complete(success) { + do_check_eq(++step, 2); + do_check_false(success); + do_check_eq(attempt, 6); + gServer.stop(do_test_finished); + }, + }; + + gCaptivePortalDetector.checkCaptivePortal(kInterfaceName, callback); +} + +function run_test() { + run_captivedetect_test(xhr_handler, fakeUIResponse, test_portal_not_found); +} diff --git a/toolkit/components/captivedetect/test/unit/test_multiple_requests.js b/toolkit/components/captivedetect/test/unit/test_multiple_requests.js new file mode 100644 index 000000000..11cf5e4b2 --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/test_multiple_requests.js @@ -0,0 +1,83 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ +'use strict'; + +const kInterfaceName = 'wifi'; +const kOtherInterfaceName = 'ril'; + +var server; +var step = 0; +var loginFinished = false; +var loginSuccessCount = 0; + +function xhr_handler(metadata, response) { + response.setStatusLine(metadata.httpVersion, 200, 'OK'); + response.setHeader('Cache-Control', 'no-cache', false); + response.setHeader('Content-Type', 'text/plain', false); + if (loginFinished) { + response.write('true'); + } else { + response.write('false'); + } +} + +function fakeUIResponse() { + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login') { + let xhr = Cc['@mozilla.org/xmlextras/xmlhttprequest;1'] + .createInstance(Ci.nsIXMLHttpRequest); + xhr.open('GET', gServerURL + kCanonicalSitePath, true); + xhr.send(); + loginFinished = true; + do_check_eq(++step, 2); + } + }, 'captive-portal-login', false); + + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login-success') { + loginSuccessCount++; + if (loginSuccessCount > 1) { + throw "We should only receive 'captive-portal-login-success' once"; + } + do_check_eq(++step, 4); + } + }, 'captive-portal-login-success', false); +} + +function test_multiple_requests() { + do_test_pending(); + + let callback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 1); + gCaptivePortalDetector.finishPreparation(kInterfaceName); + }, + complete: function complete(success) { + do_check_eq(++step, 3); + do_check_true(success); + }, + }; + + let otherCallback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 5); + gCaptivePortalDetector.finishPreparation(kOtherInterfaceName); + }, + complete: function complete(success) { + do_check_eq(++step, 6); + do_check_true(success); + gServer.stop(do_test_finished); + } + }; + + gCaptivePortalDetector.checkCaptivePortal(kInterfaceName, callback); + gCaptivePortalDetector.checkCaptivePortal(kOtherInterfaceName, otherCallback); +} + +function run_test() { + run_captivedetect_test(xhr_handler, fakeUIResponse, test_multiple_requests); +} diff --git a/toolkit/components/captivedetect/test/unit/test_user_cancel.js b/toolkit/components/captivedetect/test/unit/test_user_cancel.js new file mode 100644 index 000000000..a03876817 --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/test_user_cancel.js @@ -0,0 +1,54 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ +'use strict'; + +const kInterfaceName = 'wifi'; + +var server; +var step = 0; + +function xhr_handler(metadata, response) { + response.setStatusLine(metadata.httpVersion, 200, 'OK'); + response.setHeader('Cache-Control', 'no-cache', false); + response.setHeader('Content-Type', 'text/plain', false); + response.write('false'); +} + +function fakeUIResponse() { + Services.obs.addObserver(function observe(subject, topic, data) { + if (topic === 'captive-portal-login') { + let xhr = Cc['@mozilla.org/xmlextras/xmlhttprequest;1'] + .createInstance(Ci.nsIXMLHttpRequest); + xhr.open('GET', gServerURL + kCanonicalSitePath, true); + xhr.send(); + do_check_eq(++step, 2); + let details = JSON.parse(data); + gCaptivePortalDetector.cancelLogin(details.id); + } + }, 'captive-portal-login', false); +} + +function test_cancel() { + do_test_pending(); + + let callback = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsICaptivePortalCallback]), + prepare: function prepare() { + do_check_eq(++step, 1); + gCaptivePortalDetector.finishPreparation(kInterfaceName); + }, + complete: function complete(success) { + do_check_eq(++step, 3); + do_check_false(success); + gServer.stop(do_test_finished); + }, + }; + + gCaptivePortalDetector.checkCaptivePortal(kInterfaceName, callback); +} + +function run_test() { + run_captivedetect_test(xhr_handler, fakeUIResponse, test_cancel); +} diff --git a/toolkit/components/captivedetect/test/unit/xpcshell.ini b/toolkit/components/captivedetect/test/unit/xpcshell.ini new file mode 100644 index 000000000..0f440c438 --- /dev/null +++ b/toolkit/components/captivedetect/test/unit/xpcshell.ini @@ -0,0 +1,15 @@ +[DEFAULT] +head = head_setprefs.js +tail = + +[test_captive_portal_not_found.js] +[test_captive_portal_not_found_404.js] +[test_captive_portal_found.js] +[test_captive_portal_found_303.js] +[test_abort.js] +[test_abort_during_user_login.js] +[test_user_cancel.js] +[test_multiple_requests.js] +[test_abort_ongoing_request.js] +[test_abort_pending_request.js] + -- cgit v1.2.3