diff options
Diffstat (limited to 'browser/base/content/test/urlbar')
75 files changed, 5568 insertions, 0 deletions
diff --git a/browser/base/content/test/urlbar/.eslintrc.js b/browser/base/content/test/urlbar/.eslintrc.js new file mode 100644 index 000000000..7c8021192 --- /dev/null +++ b/browser/base/content/test/urlbar/.eslintrc.js @@ -0,0 +1,7 @@ +"use strict"; + +module.exports = { + "extends": [ + "../../../../../testing/mochitest/browser.eslintrc.js" + ] +}; diff --git a/browser/base/content/test/urlbar/authenticate.sjs b/browser/base/content/test/urlbar/authenticate.sjs new file mode 100644 index 000000000..58da655cf --- /dev/null +++ b/browser/base/content/test/urlbar/authenticate.sjs @@ -0,0 +1,220 @@ +function handleRequest(request, response) +{ + try { + reallyHandleRequest(request, response); + } catch (e) { + response.setStatusLine("1.0", 200, "AlmostOK"); + response.write("Error handling request: " + e); + } +} + + +function reallyHandleRequest(request, response) { + var match; + var requestAuth = true, requestProxyAuth = true; + + // Allow the caller to drive how authentication is processed via the query. + // Eg, http://localhost:8888/authenticate.sjs?user=foo&realm=bar + // The extra ? allows the user/pass/realm checks to succeed if the name is + // at the beginning of the query string. + var query = "?" + request.queryString; + + var expected_user = "", expected_pass = "", realm = "mochitest"; + var proxy_expected_user = "", proxy_expected_pass = "", proxy_realm = "mochi-proxy"; + var huge = false, plugin = false, anonymous = false; + var authHeaderCount = 1; + // user=xxx + match = /[^_]user=([^&]*)/.exec(query); + if (match) + expected_user = match[1]; + + // pass=xxx + match = /[^_]pass=([^&]*)/.exec(query); + if (match) + expected_pass = match[1]; + + // realm=xxx + match = /[^_]realm=([^&]*)/.exec(query); + if (match) + realm = match[1]; + + // proxy_user=xxx + match = /proxy_user=([^&]*)/.exec(query); + if (match) + proxy_expected_user = match[1]; + + // proxy_pass=xxx + match = /proxy_pass=([^&]*)/.exec(query); + if (match) + proxy_expected_pass = match[1]; + + // proxy_realm=xxx + match = /proxy_realm=([^&]*)/.exec(query); + if (match) + proxy_realm = match[1]; + + // huge=1 + match = /huge=1/.exec(query); + if (match) + huge = true; + + // plugin=1 + match = /plugin=1/.exec(query); + if (match) + plugin = true; + + // multiple=1 + match = /multiple=([^&]*)/.exec(query); + if (match) + authHeaderCount = match[1]+0; + + // anonymous=1 + match = /anonymous=1/.exec(query); + if (match) + anonymous = true; + + // Look for an authentication header, if any, in the request. + // + // EG: Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ== + // + // This test only supports Basic auth. The value sent by the client is + // "username:password", obscured with base64 encoding. + + var actual_user = "", actual_pass = "", authHeader, authPresent = false; + if (request.hasHeader("Authorization")) { + authPresent = true; + authHeader = request.getHeader("Authorization"); + match = /Basic (.+)/.exec(authHeader); + if (match.length != 2) + throw "Couldn't parse auth header: " + authHeader; + + var userpass = base64ToString(match[1]); // no atob() :-( + match = /(.*):(.*)/.exec(userpass); + if (match.length != 3) + throw "Couldn't decode auth header: " + userpass; + actual_user = match[1]; + actual_pass = match[2]; + } + + var proxy_actual_user = "", proxy_actual_pass = ""; + if (request.hasHeader("Proxy-Authorization")) { + authHeader = request.getHeader("Proxy-Authorization"); + match = /Basic (.+)/.exec(authHeader); + if (match.length != 2) + throw "Couldn't parse auth header: " + authHeader; + + var userpass = base64ToString(match[1]); // no atob() :-( + match = /(.*):(.*)/.exec(userpass); + if (match.length != 3) + throw "Couldn't decode auth header: " + userpass; + proxy_actual_user = match[1]; + proxy_actual_pass = match[2]; + } + + // Don't request authentication if the credentials we got were what we + // expected. + if (expected_user == actual_user && + expected_pass == actual_pass) { + requestAuth = false; + } + if (proxy_expected_user == proxy_actual_user && + proxy_expected_pass == proxy_actual_pass) { + requestProxyAuth = false; + } + + if (anonymous) { + if (authPresent) { + response.setStatusLine("1.0", 400, "Unexpected authorization header found"); + } else { + response.setStatusLine("1.0", 200, "Authorization header not found"); + } + } else { + if (requestProxyAuth) { + response.setStatusLine("1.0", 407, "Proxy authentication required"); + for (i = 0; i < authHeaderCount; ++i) + response.setHeader("Proxy-Authenticate", "basic realm=\"" + proxy_realm + "\"", true); + } else if (requestAuth) { + response.setStatusLine("1.0", 401, "Authentication required"); + for (i = 0; i < authHeaderCount; ++i) + response.setHeader("WWW-Authenticate", "basic realm=\"" + realm + "\"", true); + } else { + response.setStatusLine("1.0", 200, "OK"); + } + } + + response.setHeader("Content-Type", "application/xhtml+xml", false); + response.write("<html xmlns='http://www.w3.org/1999/xhtml'>"); + response.write("<p>Login: <span id='ok'>" + (requestAuth ? "FAIL" : "PASS") + "</span></p>\n"); + response.write("<p>Proxy: <span id='proxy'>" + (requestProxyAuth ? "FAIL" : "PASS") + "</span></p>\n"); + response.write("<p>Auth: <span id='auth'>" + authHeader + "</span></p>\n"); + response.write("<p>User: <span id='user'>" + actual_user + "</span></p>\n"); + response.write("<p>Pass: <span id='pass'>" + actual_pass + "</span></p>\n"); + + if (huge) { + response.write("<div style='display: none'>"); + for (i = 0; i < 100000; i++) { + response.write("123456789\n"); + } + response.write("</div>"); + response.write("<span id='footnote'>This is a footnote after the huge content fill</span>"); + } + + if (plugin) { + response.write("<embed id='embedtest' style='width: 400px; height: 100px;' " + + "type='application/x-test'></embed>\n"); + } + + response.write("</html>"); +} + + +// base64 decoder +// +// Yoinked from extensions/xml-rpc/src/nsXmlRpcClient.js because btoa() +// doesn't seem to exist. :-( +/* Convert Base64 data to a string */ +const toBinaryTable = [ + -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, + -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, + -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63, + 52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1, 0,-1,-1, + -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14, + 15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1, + -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40, + 41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1 +]; +const base64Pad = '='; + +function base64ToString(data) { + + var result = ''; + var leftbits = 0; // number of bits decoded, but yet to be appended + var leftdata = 0; // bits decoded, but yet to be appended + + // Convert one by one. + for (var i = 0; i < data.length; i++) { + var c = toBinaryTable[data.charCodeAt(i) & 0x7f]; + var padding = (data[i] == base64Pad); + // Skip illegal characters and whitespace + if (c == -1) continue; + + // Collect data into leftdata, update bitcount + leftdata = (leftdata << 6) | c; + leftbits += 6; + + // If we have 8 or more bits, append 8 bits to the result + if (leftbits >= 8) { + leftbits -= 8; + // Append if not padding. + if (!padding) + result += String.fromCharCode((leftdata >> leftbits) & 0xff); + leftdata &= (1 << leftbits) - 1; + } + } + + // If there are any bits left, the base64 string was corrupted + if (leftbits) + throw Components.Exception('Corrupted base64 string'); + + return result; +} diff --git a/browser/base/content/test/urlbar/browser.ini b/browser/base/content/test/urlbar/browser.ini new file mode 100644 index 000000000..39bc086c9 --- /dev/null +++ b/browser/base/content/test/urlbar/browser.ini @@ -0,0 +1,101 @@ +[DEFAULT] +support-files = + dummy_page.html + head.js + +[browser_URLBarSetURI.js] +skip-if = (os == "linux" || os == "mac") && debug # bug 970052, bug 970053 +[browser_action_keyword.js] +skip-if = os == "linux" # Bug 1188154 +support-files = + print_postdata.sjs +[browser_action_keyword_override.js] +[browser_action_searchengine.js] +[browser_action_searchengine_alias.js] +[browser_autocomplete_a11y_label.js] +[browser_autocomplete_autoselect.js] +[browser_autocomplete_cursor.js] +[browser_autocomplete_edit_completed.js] +[browser_autocomplete_enter_race.js] +[browser_autocomplete_no_title.js] +[browser_autocomplete_tag_star_visibility.js] +[browser_bug1104165-switchtab-decodeuri.js] +[browser_bug1003461-switchtab-override.js] +[browser_bug1024133-switchtab-override-keynav.js] +[browser_bug1025195_switchToTabHavingURI_aOpenParams.js] +[browser_bug1070778.js] +[browser_bug1225194-remotetab.js] +[browser_bug304198.js] +[browser_bug556061.js] +subsuite = clipboard +[browser_bug562649.js] +[browser_bug623155.js] +support-files = + redirect_bug623155.sjs +[browser_bug783614.js] +[browser_canonizeURL.js] +[browser_dragdropURL.js] +[browser_locationBarCommand.js] +[browser_locationBarExternalLoad.js] +[browser_moz_action_link.js] +[browser_removeUnsafeProtocolsFromURLBarPaste.js] +subsuite = clipboard +[browser_search_favicon.js] +[browser_tabMatchesInAwesomebar.js] +support-files = + moz.png +[browser_tabMatchesInAwesomebar_perwindowpb.js] +skip-if = os == 'linux' # Bug 1104755 +[browser_urlbarAboutHomeLoading.js] +[browser_urlbarAutoFillTrimURLs.js] +[browser_urlbarCopying.js] +subsuite = clipboard +support-files = + authenticate.sjs +[browser_urlbarDecode.js] +[browser_urlbarDelete.js] +[browser_urlbarEnter.js] +[browser_urlbarEnterAfterMouseOver.js] +skip-if = os == "linux" # Bug 1073339 - Investigate autocomplete test unreliability on Linux/e10s +[browser_urlbarFocusedCmdK.js] +[browser_urlbarHashChangeProxyState.js] +[browser_urlbarKeepStateAcrossTabSwitches.js] +[browser_urlbarOneOffs.js] +[browser_urlbarPrivateBrowsingWindowChange.js] +[browser_urlbarRaceWithTabs.js] +[browser_urlbarRevert.js] +[browser_urlbarSearchSingleWordNotification.js] +[browser_urlbarSearchSuggestions.js] +support-files = + searchSuggestionEngine.xml + searchSuggestionEngine.sjs +[browser_urlbarSearchSuggestionsNotification.js] +support-files = + searchSuggestionEngine.xml + searchSuggestionEngine.sjs +[browser_urlbarSearchTelemetry.js] +support-files = + searchSuggestionEngine.xml + searchSuggestionEngine.sjs +[browser_urlbarStop.js] +[browser_urlbarTrimURLs.js] +subsuite = clipboard +[browser_urlbarUpdateForDomainCompletion.js] +[browser_urlbar_autoFill_backspaced.js] +[browser_urlbar_blanking.js] +support-files = + file_blank_but_not_blank.html +[browser_urlbar_locationchange_urlbar_edit_dos.js] +support-files = + file_urlbar_edit_dos.html +[browser_urlbar_searchsettings.js] +[browser_urlbar_stop_pending.js] +support-files = + slow-page.sjs +[browser_urlbar_remoteness_switch.js] +run-if = e10s +[browser_urlHighlight.js] +[browser_wyciwyg_urlbarCopying.js] +subsuite = clipboard +support-files = + test_wyciwyg_copying.html diff --git a/browser/base/content/test/urlbar/browser_URLBarSetURI.js b/browser/base/content/test/urlbar/browser_URLBarSetURI.js new file mode 100644 index 000000000..ac8352f1a --- /dev/null +++ b/browser/base/content/test/urlbar/browser_URLBarSetURI.js @@ -0,0 +1,100 @@ +/* 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/. */ + +function test() { + waitForExplicitFinish(); + + // avoid prompting about phishing + Services.prefs.setIntPref(phishyUserPassPref, 32); + registerCleanupFunction(function () { + Services.prefs.clearUserPref(phishyUserPassPref); + }); + + nextTest(); +} + +const phishyUserPassPref = "network.http.phishy-userpass-length"; + +function nextTest() { + let test = tests.shift(); + if (test) { + test(function () { + executeSoon(nextTest); + }); + } else { + executeSoon(finish); + } +} + +var tests = [ + function revert(next) { + loadTabInWindow(window, function (tab) { + gURLBar.handleRevert(); + is(gURLBar.textValue, "example.com", "URL bar had user/pass stripped after reverting"); + gBrowser.removeTab(tab); + next(); + }); + }, + function customize(next) { + // Need to wait for delayedStartup for the customization part of the test, + // since that's where BrowserToolboxCustomizeDone is set. + BrowserTestUtils.openNewBrowserWindow().then(function(win) { + loadTabInWindow(win, function () { + openToolbarCustomizationUI(function () { + closeToolbarCustomizationUI(function () { + is(win.gURLBar.textValue, "example.com", "URL bar had user/pass stripped after customize"); + win.close(); + next(); + }, win); + }, win); + }); + }); + }, + function pageloaderror(next) { + loadTabInWindow(window, function (tab) { + // Load a new URL and then immediately stop it, to simulate a page load + // error. + tab.linkedBrowser.loadURI("http://test1.example.com"); + tab.linkedBrowser.stop(); + is(gURLBar.textValue, "example.com", "URL bar had user/pass stripped after load error"); + gBrowser.removeTab(tab); + next(); + }); + } +]; + +function loadTabInWindow(win, callback) { + info("Loading tab"); + let url = "http://user:pass@example.com/"; + let tab = win.gBrowser.selectedTab = win.gBrowser.addTab(url); + BrowserTestUtils.browserLoaded(tab.linkedBrowser, false, url).then(() => { + info("Tab loaded"); + is(win.gURLBar.textValue, "example.com", "URL bar had user/pass stripped initially"); + callback(tab); + }, true); +} + +function openToolbarCustomizationUI(aCallback, aBrowserWin) { + if (!aBrowserWin) + aBrowserWin = window; + + aBrowserWin.gCustomizeMode.enter(); + + aBrowserWin.gNavToolbox.addEventListener("customizationready", function UI_loaded() { + aBrowserWin.gNavToolbox.removeEventListener("customizationready", UI_loaded); + executeSoon(function() { + aCallback(aBrowserWin) + }); + }); +} + +function closeToolbarCustomizationUI(aCallback, aBrowserWin) { + aBrowserWin.gNavToolbox.addEventListener("aftercustomization", function unloaded() { + aBrowserWin.gNavToolbox.removeEventListener("aftercustomization", unloaded); + executeSoon(aCallback); + }); + + aBrowserWin.gCustomizeMode.exit(); +} + diff --git a/browser/base/content/test/urlbar/browser_action_keyword.js b/browser/base/content/test/urlbar/browser_action_keyword.js new file mode 100644 index 000000000..854a7b82f --- /dev/null +++ b/browser/base/content/test/urlbar/browser_action_keyword.js @@ -0,0 +1,119 @@ +function* promise_first_result(inputText) { + yield promiseAutocompleteResultPopup(inputText); + + let firstResult = gURLBar.popup.richlistbox.firstChild; + return firstResult; +} + +const TEST_URL = "http://mochi.test:8888/browser/browser/base/content/test/urlbar/print_postdata.sjs"; + +add_task(function* setup() { + yield PlacesUtils.keywords.insert({ keyword: "get", + url: TEST_URL + "?q=%s" }); + yield PlacesUtils.keywords.insert({ keyword: "post", + url: TEST_URL, + postData: "q=%s" }); + registerCleanupFunction(function* () { + yield PlacesUtils.keywords.remove("get"); + yield PlacesUtils.keywords.remove("post"); + while (gBrowser.tabs.length > 1) { + yield BrowserTestUtils.removeTab(gBrowser.selectedTab); + } + }); +}); + +add_task(function* get_keyword() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + + let result = yield promise_first_result("get something"); + isnot(result, null, "Expect a keyword result"); + + let types = new Set(result.getAttribute("type").split(/\s+/)); + Assert.ok(types.has("keyword")); + is(result.getAttribute("actiontype"), "keyword", "Expect correct `actiontype` attribute"); + is(result.getAttribute("title"), "mochi.test:8888", "Expect correct title"); + + // We need to make a real URI out of this to ensure it's normalised for + // comparison. + let uri = NetUtil.newURI(result.getAttribute("url")); + is(uri.spec, PlacesUtils.mozActionURI("keyword", + { url: TEST_URL + "?q=something", + input: "get something"}), + "Expect correct url"); + + let titleHbox = result._titleText.parentNode.parentNode; + ok(titleHbox.classList.contains("ac-title"), "Title hbox element sanity check"); + is_element_visible(titleHbox, "Title element should be visible"); + is(result._titleText.textContent, "mochi.test:8888: something", + "Node should contain the name of the bookmark and query"); + + let urlHbox = result._urlText.parentNode.parentNode; + ok(urlHbox.classList.contains("ac-url"), "URL hbox element sanity check"); + is_element_hidden(urlHbox, "URL element should be hidden"); + + let actionHbox = result._actionText.parentNode.parentNode; + ok(actionHbox.classList.contains("ac-action"), "Action hbox element sanity check"); + is_element_visible(actionHbox, "Action element should be visible"); + is(result._actionText.textContent, "", "Action text should be empty"); + + // Click on the result + info("Normal click on result"); + let tabPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + EventUtils.synthesizeMouseAtCenter(result, {}); + yield tabPromise; + is(tab.linkedBrowser.currentURI.spec, TEST_URL + "?q=something", + "Tab should have loaded from clicking on result"); + + // Middle-click on the result + info("Middle-click on result"); + result = yield promise_first_result("get somethingmore"); + isnot(result, null, "Expect a keyword result"); + // We need to make a real URI out of this to ensure it's normalised for + // comparison. + uri = NetUtil.newURI(result.getAttribute("url")); + is(uri.spec, PlacesUtils.mozActionURI("keyword", + { url: TEST_URL + "?q=somethingmore", + input: "get somethingmore" }), + "Expect correct url"); + + tabPromise = BrowserTestUtils.waitForEvent(gBrowser.tabContainer, "TabOpen"); + EventUtils.synthesizeMouseAtCenter(result, {button: 1}); + let tabOpenEvent = yield tabPromise; + let newTab = tabOpenEvent.target; + yield BrowserTestUtils.browserLoaded(newTab.linkedBrowser); + is(newTab.linkedBrowser.currentURI.spec, + TEST_URL + "?q=somethingmore", + "Tab should have loaded from middle-clicking on result"); +}); + + +add_task(function* post_keyword() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + + let result = yield promise_first_result("post something"); + isnot(result, null, "Expect a keyword result"); + + let types = new Set(result.getAttribute("type").split(/\s+/)); + Assert.ok(types.has("keyword")); + is(result.getAttribute("actiontype"), "keyword", "Expect correct `actiontype` attribute"); + is(result.getAttribute("title"), "mochi.test:8888", "Expect correct title"); + + is(result.getAttribute("url"), + PlacesUtils.mozActionURI("keyword", { url: TEST_URL, + input: "post something", + "postData": "q=something" }), + "Expect correct url"); + + // Click on the result + info("Normal click on result"); + let tabPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + EventUtils.synthesizeMouseAtCenter(result, {}); + yield tabPromise; + is(tab.linkedBrowser.currentURI.spec, TEST_URL, + "Tab should have loaded from clicking on result"); + + let postData = yield ContentTask.spawn(tab.linkedBrowser, null, function* () { + return content.document.body.textContent; + }); + is(postData, "q=something", "post data was submitted correctly"); +}); diff --git a/browser/base/content/test/urlbar/browser_action_keyword_override.js b/browser/base/content/test/urlbar/browser_action_keyword_override.js new file mode 100644 index 000000000..f5a865678 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_action_keyword_override.js @@ -0,0 +1,40 @@ +add_task(function*() { + let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid, + url: "http://example.com/?q=%s", + title: "test" }); + yield PlacesUtils.keywords.insert({ keyword: "keyword", + url: "http://example.com/?q=%s" }) + + registerCleanupFunction(function* () { + yield PlacesUtils.bookmarks.remove(bm); + }); + + yield promiseAutocompleteResultPopup("keyword search"); + let result = gURLBar.popup.richlistbox.children[0]; + + info("Before override"); + let titleHbox = result._titleText.parentNode.parentNode; + ok(titleHbox.classList.contains("ac-title"), "Title hbox element sanity check"); + is_element_visible(titleHbox, "Title element should be visible"); + + let urlHbox = result._urlText.parentNode.parentNode; + ok(urlHbox.classList.contains("ac-url"), "URL hbox element sanity check"); + is_element_hidden(urlHbox, "URL element should be hidden"); + + let actionHbox = result._actionText.parentNode.parentNode; + ok(actionHbox.classList.contains("ac-action"), "Action hbox element sanity check"); + is_element_visible(actionHbox, "Action element should be visible"); + is(result._actionText.textContent, "", "Action text should be empty"); + + info("During override"); + EventUtils.synthesizeKey("VK_SHIFT", { type: "keydown" }); + is_element_visible(titleHbox, "Title element should be visible"); + is_element_hidden(urlHbox, "URL element should be hidden"); + is_element_visible(actionHbox, "Action element should be visible"); + is(result._actionText.textContent, "", "Action text should be empty"); + + EventUtils.synthesizeKey("VK_SHIFT", { type: "keyup" }); + + gURLBar.popup.hidePopup(); + yield promisePopupHidden(gURLBar.popup); +}); diff --git a/browser/base/content/test/urlbar/browser_action_searchengine.js b/browser/base/content/test/urlbar/browser_action_searchengine.js new file mode 100644 index 000000000..d2115abba --- /dev/null +++ b/browser/base/content/test/urlbar/browser_action_searchengine.js @@ -0,0 +1,36 @@ +add_task(function* () { + Services.search.addEngineWithDetails("MozSearch", "", "", "", "GET", + "http://example.com/?q={searchTerms}"); + let engine = Services.search.getEngineByName("MozSearch"); + let originalEngine = Services.search.currentEngine; + Services.search.currentEngine = engine; + + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + + registerCleanupFunction(() => { + Services.search.currentEngine = originalEngine; + let engine = Services.search.getEngineByName("MozSearch"); + Services.search.removeEngine(engine); + + try { + gBrowser.removeTab(tab); + } catch (ex) { /* tab may have already been closed in case of failure */ } + + return PlacesTestUtils.clearHistory(); + }); + + yield promiseAutocompleteResultPopup("open a search"); + let result = gURLBar.popup.richlistbox.firstChild; + + isnot(result, null, "Should have a result"); + is(result.getAttribute("url"), + `moz-action:searchengine,{"engineName":"MozSearch","input":"open%20a%20search","searchQuery":"open%20a%20search"}`, + "Result should be a moz-action: for the correct search engine"); + is(result.hasAttribute("image"), false, "Result shouldn't have an image attribute"); + + let tabPromise = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + result.click(); + yield tabPromise; + + is(gBrowser.selectedBrowser.currentURI.spec, "http://example.com/?q=open+a+search", "Correct URL should be loaded"); +}); diff --git a/browser/base/content/test/urlbar/browser_action_searchengine_alias.js b/browser/base/content/test/urlbar/browser_action_searchengine_alias.js new file mode 100644 index 000000000..1967d178a --- /dev/null +++ b/browser/base/content/test/urlbar/browser_action_searchengine_alias.js @@ -0,0 +1,35 @@ +add_task(function* () { + let iconURI = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAABGklEQVQoz2NgGB6AnZ1dUlJSXl4eSDIyMhLW4Ovr%2B%2Fr168uXL69Zs4YoG%2BLi4i5dusTExMTGxsbNzd3f37937976%2BnpmZmagbHR09J49e5YvX66kpATVEBYW9ubNm2nTphkbG7e2tp44cQLIuHfvXm5urpaWFlDKysqqu7v73LlzECMYIiIiHj58mJCQoKKicvXq1bS0NKBgW1vbjh074uPjgeqAXE1NzSdPnvDz84M0AEUvXLgAsW379u1z5swBen3jxo2zZ892cHB4%2BvQp0KlAfwI1cHJyghQFBwfv2rULokFXV%2FfixYu7d%2B8GGqGgoMDKyrpu3br9%2B%2FcDuXl5eVA%2FAEWBfoWHAdAYoNuAYQ0XAeoUERFhGDYAAPoUaT2dfWJuAAAAAElFTkSuQmCC"; + Services.search.addEngineWithDetails("MozSearch", iconURI, "moz", "", "GET", + "http://example.com/?q={searchTerms}"); + let engine = Services.search.getEngineByName("MozSearch"); + let originalEngine = Services.search.currentEngine; + Services.search.currentEngine = engine; + + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + + registerCleanupFunction(() => { + Services.search.currentEngine = originalEngine; + let engine = Services.search.getEngineByName("MozSearch"); + Services.search.removeEngine(engine); + + try { + gBrowser.removeTab(tab); + } catch (ex) { /* tab may have already been closed in case of failure */ } + + return PlacesTestUtils.clearHistory(); + }); + + yield promiseAutocompleteResultPopup("moz open a search"); + + let result = gURLBar.popup.richlistbox.children[0]; + ok(result.hasAttribute("image"), "Result should have an image attribute"); + ok(result.getAttribute("image") === engine.iconURI.spec, + "Image attribute should have the search engine's icon"); + + let tabPromise = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + EventUtils.synthesizeKey("VK_RETURN", { }); + yield tabPromise; + + is(gBrowser.selectedBrowser.currentURI.spec, "http://example.com/?q=open+a+search"); +}); diff --git a/browser/base/content/test/urlbar/browser_autocomplete_a11y_label.js b/browser/base/content/test/urlbar/browser_autocomplete_a11y_label.js new file mode 100644 index 000000000..a27f9672e --- /dev/null +++ b/browser/base/content/test/urlbar/browser_autocomplete_a11y_label.js @@ -0,0 +1,57 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +const SUGGEST_ALL_PREF = "browser.search.suggest.enabled"; +const SUGGEST_URLBAR_PREF = "browser.urlbar.suggest.searches"; +const TEST_ENGINE_BASENAME = "searchSuggestionEngine.xml"; + +add_task(function* switchToTab() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:about"); + + yield promiseAutocompleteResultPopup("% about"); + + ok(gURLBar.popup.richlistbox.children.length > 1, "Should get at least 2 results"); + let result = gURLBar.popup.richlistbox.children[1]; + is(result.getAttribute("type"), "switchtab", "Expect right type attribute"); + is(result.label, "about:about about:about Tab", "Result a11y label should be: <title> <url> Tab"); + + gURLBar.popup.hidePopup(); + yield promisePopupHidden(gURLBar.popup); + gBrowser.removeTab(tab); +}); + +add_task(function* searchSuggestions() { + let engine = yield promiseNewSearchEngine(TEST_ENGINE_BASENAME); + let oldCurrentEngine = Services.search.currentEngine; + Services.search.currentEngine = engine; + Services.prefs.setBoolPref(SUGGEST_ALL_PREF, true); + Services.prefs.setBoolPref(SUGGEST_URLBAR_PREF, true); + registerCleanupFunction(function () { + Services.search.currentEngine = oldCurrentEngine; + Services.prefs.clearUserPref(SUGGEST_ALL_PREF); + Services.prefs.clearUserPref(SUGGEST_URLBAR_PREF); + }); + + yield promiseAutocompleteResultPopup("foo"); + // Don't assume that the search doesn't match history or bookmarks left around + // by earlier tests. + Assert.ok(gURLBar.popup.richlistbox.children.length >= 3, + "Should get at least heuristic result + two search suggestions"); + // The first expected search is the search term itself since the heuristic + // result will come before the search suggestions. + let expectedSearches = [ + "foo", + "foofoo", + "foobar", + ]; + for (let child of gURLBar.popup.richlistbox.children) { + if (child.getAttribute("type").split(/\s+/).indexOf("searchengine") >= 0) { + Assert.ok(expectedSearches.length > 0); + let suggestion = expectedSearches.shift(); + Assert.equal(child.label, suggestion + " browser_searchSuggestionEngine searchSuggestionEngine.xml Search", + "Result label should be: <search term> <engine name> Search"); + } + } + Assert.ok(expectedSearches.length == 0); + gURLBar.closePopup(); +}); diff --git a/browser/base/content/test/urlbar/browser_autocomplete_autoselect.js b/browser/base/content/test/urlbar/browser_autocomplete_autoselect.js new file mode 100644 index 000000000..e4e0daa8e --- /dev/null +++ b/browser/base/content/test/urlbar/browser_autocomplete_autoselect.js @@ -0,0 +1,92 @@ +const ONEOFF_URLBAR_PREF = "browser.urlbar.oneOffSearches"; + +function repeat(limit, func) { + for (let i = 0; i < limit; i++) { + func(i); + } +} + +function is_selected(index) { + is(gURLBar.popup.richlistbox.selectedIndex, index, `Item ${index + 1} should be selected`); + + // This is true because although both the listbox and the one-offs can have + // selections, the test doesn't check that. + is(gURLBar.popup.oneOffSearchButtons.selectedButton, null, + "A result is selected, so the one-offs should not have a selection"); +} + +function is_selected_one_off(index) { + is(gURLBar.popup.oneOffSearchButtons.selectedButtonIndex, index, + "Expected one-off button should be selected"); + + // This is true because although both the listbox and the one-offs can have + // selections, the test doesn't check that. + is(gURLBar.popup.richlistbox.selectedIndex, -1, + "A one-off is selected, so the listbox should not have a selection"); +} + +add_task(function*() { + let maxResults = Services.prefs.getIntPref("browser.urlbar.maxRichResults"); + + Services.prefs.setBoolPref(ONEOFF_URLBAR_PREF, true); + registerCleanupFunction(function* () { + yield PlacesTestUtils.clearHistory(); + Services.prefs.clearUserPref(ONEOFF_URLBAR_PREF); + }); + + let visits = []; + repeat(maxResults, i => { + visits.push({ + uri: makeURI("http://example.com/autocomplete/?" + i), + }); + }); + yield PlacesTestUtils.addVisits(visits); + + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + yield promiseAutocompleteResultPopup("example.com/autocomplete"); + + let popup = gURLBar.popup; + let results = popup.richlistbox.children; + is(results.length, maxResults, + "Should get maxResults=" + maxResults + " results"); + is_selected(0); + + info("Key Down to select the next item"); + EventUtils.synthesizeKey("VK_DOWN", {}); + is_selected(1); + + info("Key Down maxResults-1 times should select the first one-off"); + repeat(maxResults - 1, () => EventUtils.synthesizeKey("VK_DOWN", {})); + is_selected_one_off(0); + + info("Key Down numButtons-1 should select the last one-off"); + let numButtons = + gURLBar.popup.oneOffSearchButtons.getSelectableButtons(true).length; + repeat(numButtons - 1, () => EventUtils.synthesizeKey("VK_DOWN", {})); + is_selected_one_off(numButtons - 1); + + info("Key Down twice more should select the second result"); + repeat(2, () => EventUtils.synthesizeKey("VK_DOWN", {})); + is_selected(1); + + info("Key Down maxResults + numButtons times should wrap around"); + repeat(maxResults + numButtons, + () => EventUtils.synthesizeKey("VK_DOWN", {})); + is_selected(1); + + info("Key Up maxResults + numButtons times should wrap around the other way"); + repeat(maxResults + numButtons, () => EventUtils.synthesizeKey("VK_UP", {})); + is_selected(1); + + info("Page Up will go up the list, but not wrap"); + EventUtils.synthesizeKey("VK_PAGE_UP", {}) + is_selected(0); + + info("Page Up again will wrap around to the end of the list"); + EventUtils.synthesizeKey("VK_PAGE_UP", {}) + is_selected(maxResults - 1); + + EventUtils.synthesizeKey("VK_ESCAPE", {}); + yield promisePopupHidden(gURLBar.popup); + gBrowser.removeTab(tab); +}); diff --git a/browser/base/content/test/urlbar/browser_autocomplete_cursor.js b/browser/base/content/test/urlbar/browser_autocomplete_cursor.js new file mode 100644 index 000000000..9cc2c6eac --- /dev/null +++ b/browser/base/content/test/urlbar/browser_autocomplete_cursor.js @@ -0,0 +1,17 @@ +add_task(function*() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + yield promiseAutocompleteResultPopup("www.mozilla.org"); + + gURLBar.selectTextRange(4, 4); + + is(gURLBar.popup.state, "open", "Popup should be open"); + is(gURLBar.popup.richlistbox.selectedIndex, 0, "Should have selected something"); + + EventUtils.synthesizeKey("VK_RIGHT", {}); + yield promisePopupHidden(gURLBar.popup); + + is(gURLBar.selectionStart, 5, "Should have moved the cursor"); + is(gURLBar.selectionEnd, 5, "And not selected anything"); + + gBrowser.removeTab(tab); +}); diff --git a/browser/base/content/test/urlbar/browser_autocomplete_edit_completed.js b/browser/base/content/test/urlbar/browser_autocomplete_edit_completed.js new file mode 100644 index 000000000..19db1a368 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_autocomplete_edit_completed.js @@ -0,0 +1,48 @@ +add_task(function*() { + yield PlacesTestUtils.clearHistory(); + + yield PlacesTestUtils.addVisits([ + { uri: makeURI("http://example.com/foo") }, + { uri: makeURI("http://example.com/foo/bar") }, + ]); + + registerCleanupFunction(function* () { + yield PlacesTestUtils.clearHistory(); + }); + + gBrowser.selectedTab = gBrowser.addTab("about:blank"); + gURLBar.focus(); + + yield promiseAutocompleteResultPopup("http://example.com"); + + let popup = gURLBar.popup; + let list = popup.richlistbox; + let initialIndex = list.selectedIndex; + + info("Key Down to select the next item."); + EventUtils.synthesizeKey("VK_DOWN", {}); + + let nextIndex = initialIndex + 1; + let nextValue = gURLBar.controller.getFinalCompleteValueAt(nextIndex); + is(list.selectedIndex, nextIndex, "The next item is selected."); + is(gURLBar.value, nextValue, "The selected URL is completed."); + + info("Press backspace"); + EventUtils.synthesizeKey("VK_BACK_SPACE", {}); + yield promiseSearchComplete(); + + let editedValue = gURLBar.textValue; + is(list.selectedIndex, initialIndex, "The initial index is selected again."); + isnot(editedValue, nextValue, "The URL has changed."); + + let docLoad = waitForDocLoadAndStopIt("http://" + editedValue); + + info("Press return to load edited URL."); + EventUtils.synthesizeKey("VK_RETURN", {}); + yield Promise.all([ + promisePopupHidden(gURLBar.popup), + docLoad, + ]); + + gBrowser.removeTab(gBrowser.selectedTab); +}); diff --git a/browser/base/content/test/urlbar/browser_autocomplete_enter_race.js b/browser/base/content/test/urlbar/browser_autocomplete_enter_race.js new file mode 100644 index 000000000..4e3c8943c --- /dev/null +++ b/browser/base/content/test/urlbar/browser_autocomplete_enter_race.js @@ -0,0 +1,122 @@ +// The order of these tests matters! + +add_task(function* setup () { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser); + let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid, + url: "http://example.com/?q=%s", + title: "test" }); + registerCleanupFunction(function* () { + yield PlacesUtils.bookmarks.remove(bm); + yield BrowserTestUtils.removeTab(tab); + }); + yield PlacesUtils.keywords.insert({ keyword: "keyword", + url: "http://example.com/?q=%s" }); + // Needs at least one success. + ok(true, "Setup complete"); +}); + +add_task(function* test_keyword() { + yield promiseAutocompleteResultPopup("keyword bear"); + gURLBar.focus(); + EventUtils.synthesizeKey("d", {}); + EventUtils.synthesizeKey("VK_RETURN", {}); + info("wait for the page to load"); + yield BrowserTestUtils.browserLoaded(gBrowser.selectedTab.linkedBrowser, + false, "http://example.com/?q=beard"); +}); + +add_task(function* test_sametext() { + yield promiseAutocompleteResultPopup("example.com", window, true); + + // Simulate re-entering the same text searched the last time. This may happen + // through a copy paste, but clipboard handling is not much reliable, so just + // fire an input event. + info("synthesize input event"); + let event = document.createEvent("Events"); + event.initEvent("input", true, true); + gURLBar.dispatchEvent(event); + EventUtils.synthesizeKey("VK_RETURN", {}); + + info("wait for the page to load"); + yield BrowserTestUtils.browserLoaded(gBrowser.selectedTab.linkedBrowser, + false, "http://example.com/"); +}); + +add_task(function* test_after_empty_search() { + yield promiseAutocompleteResultPopup(""); + gURLBar.focus(); + gURLBar.value = "e"; + EventUtils.synthesizeKey("x", {}); + EventUtils.synthesizeKey("VK_RETURN", {}); + + info("wait for the page to load"); + yield BrowserTestUtils.browserLoaded(gBrowser.selectedTab.linkedBrowser, + false, "http://example.com/"); +}); + +add_task(function* test_disabled_ac() { + // Disable autocomplete. + let suggestHistory = Preferences.get("browser.urlbar.suggest.history"); + Preferences.set("browser.urlbar.suggest.history", false); + let suggestBookmarks = Preferences.get("browser.urlbar.suggest.bookmark"); + Preferences.set("browser.urlbar.suggest.bookmark", false); + let suggestOpenPages = Preferences.get("browser.urlbar.suggest.openpage"); + Preferences.set("browser.urlbar.suggest.openpages", false); + + Services.search.addEngineWithDetails("MozSearch", "", "", "", "GET", + "http://example.com/?q={searchTerms}"); + let engine = Services.search.getEngineByName("MozSearch"); + let originalEngine = Services.search.currentEngine; + Services.search.currentEngine = engine; + + function* cleanup() { + Preferences.set("browser.urlbar.suggest.history", suggestHistory); + Preferences.set("browser.urlbar.suggest.bookmark", suggestBookmarks); + Preferences.set("browser.urlbar.suggest.openpage", suggestOpenPages); + + Services.search.currentEngine = originalEngine; + let engine = Services.search.getEngineByName("MozSearch"); + if (engine) { + Services.search.removeEngine(engine); + } + } + registerCleanupFunction(cleanup); + + gURLBar.focus(); + gURLBar.value = "e"; + EventUtils.synthesizeKey("x", {}); + EventUtils.synthesizeKey("VK_RETURN", {}); + + info("wait for the page to load"); + yield BrowserTestUtils.browserLoaded(gBrowser.selectedTab.linkedBrowser, + false, "http://example.com/?q=ex"); + yield cleanup(); +}); + +add_task(function* test_delay() { + const TIMEOUT = 10000; + // Set a large delay. + let delay = Preferences.get("browser.urlbar.delay"); + Preferences.set("browser.urlbar.delay", TIMEOUT); + + registerCleanupFunction(function* () { + Preferences.set("browser.urlbar.delay", delay); + }); + + // This is needed to clear the current value, otherwise autocomplete may think + // the user removed text from the end. + let start = Date.now(); + yield promiseAutocompleteResultPopup(""); + Assert.ok((Date.now() - start) < TIMEOUT); + + start = Date.now(); + gURLBar.closePopup(); + gURLBar.focus(); + gURLBar.value = "e"; + EventUtils.synthesizeKey("x", {}); + EventUtils.synthesizeKey("VK_RETURN", {}); + info("wait for the page to load"); + yield BrowserTestUtils.browserLoaded(gBrowser.selectedTab.linkedBrowser, + false, "http://example.com/"); + Assert.ok((Date.now() - start) < TIMEOUT); +}); diff --git a/browser/base/content/test/urlbar/browser_autocomplete_no_title.js b/browser/base/content/test/urlbar/browser_autocomplete_no_title.js new file mode 100644 index 000000000..8d608550b --- /dev/null +++ b/browser/base/content/test/urlbar/browser_autocomplete_no_title.js @@ -0,0 +1,15 @@ +add_task(function*() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + + let uri = NetUtil.newURI("http://bug1060642.example.com/beards/are/pretty/great"); + yield PlacesTestUtils.addVisits([{uri: uri, title: ""}]); + + yield promiseAutocompleteResultPopup("bug1060642"); + ok(gURLBar.popup.richlistbox.children.length > 1, "Should get at least 2 results"); + let result = gURLBar.popup.richlistbox.children[1]; + is(result._titleText.textContent, "bug1060642.example.com", "Result title should be as expected"); + + gURLBar.popup.hidePopup(); + yield promisePopupHidden(gURLBar.popup); + gBrowser.removeTab(tab); +}); diff --git a/browser/base/content/test/urlbar/browser_autocomplete_tag_star_visibility.js b/browser/base/content/test/urlbar/browser_autocomplete_tag_star_visibility.js new file mode 100644 index 000000000..8a69b4b44 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_autocomplete_tag_star_visibility.js @@ -0,0 +1,102 @@ +add_task(function*() { + registerCleanupFunction(() => { + PlacesUtils.bookmarks.removeFolderChildren(PlacesUtils.unfiledBookmarksFolderId); + }); + + function* addTagItem(tagName) { + let uri = NetUtil.newURI(`http://example.com/this/is/tagged/${tagName}`); + PlacesUtils.bookmarks.insertBookmark(PlacesUtils.unfiledBookmarksFolderId, + uri, + PlacesUtils.bookmarks.DEFAULT_INDEX, + `test ${tagName}`); + PlacesUtils.tagging.tagURI(uri, [tagName]); + yield PlacesTestUtils.addVisits([{uri: uri, title: `Test page with tag ${tagName}`}]); + } + + // We use different tags for each part of the test, as otherwise the + // autocomplete code tries to be smart by using the previously cached element + // without updating it (since all parameters it knows about are the same). + + let testcases = [{ + description: "Test with suggest.bookmark=true", + tagName: "tagtest1", + prefs: { + "suggest.bookmark": true, + }, + input: "tagtest1", + expected: { + type: "bookmark", + typeImageVisible: true, + }, + }, { + description: "Test with suggest.bookmark=false", + tagName: "tagtest2", + prefs: { + "suggest.bookmark": false, + }, + input: "tagtest2", + expected: { + type: "tag", + typeImageVisible: false, + }, + }, { + description: "Test with suggest.bookmark=true (again)", + tagName: "tagtest3", + prefs: { + "suggest.bookmark": true, + }, + input: "tagtest3", + expected: { + type: "bookmark", + typeImageVisible: true, + }, + }, { + description: "Test with bookmark restriction token", + tagName: "tagtest4", + prefs: { + "suggest.bookmark": true, + }, + input: "* tagtest4", + expected: { + type: "bookmark", + typeImageVisible: true, + }, + }, { + description: "Test with history restriction token", + tagName: "tagtest5", + prefs: { + "suggest.bookmark": true, + }, + input: "^ tagtest5", + expected: { + type: "tag", + typeImageVisible: false, + }, + }]; + + for (let testcase of testcases) { + info(`Test case: ${testcase.description}`); + + yield addTagItem(testcase.tagName); + for (let prefName of Object.keys(testcase.prefs)) { + Services.prefs.setBoolPref(`browser.urlbar.${prefName}`, testcase.prefs[prefName]); + } + + yield promiseAutocompleteResultPopup(testcase.input); + let result = gURLBar.popup.richlistbox.children[1]; + ok(result && !result.collasped, "Should have result"); + + is(result.getAttribute("type"), testcase.expected.type, "Result should have expected type"); + + let typeIconStyle = window.getComputedStyle(result._typeIcon); + let imageURL = typeIconStyle.listStyleImage; + if (testcase.expected.typeImageVisible) { + ok(/^url\(.+\)$/.test(imageURL), "Type image should be visible"); + } else { + is(imageURL, "none", "Type image should be hidden"); + } + + gURLBar.popup.hidePopup(); + yield promisePopupHidden(gURLBar.popup); + } +}); diff --git a/browser/base/content/test/urlbar/browser_bug1003461-switchtab-override.js b/browser/base/content/test/urlbar/browser_bug1003461-switchtab-override.js new file mode 100644 index 000000000..89f604491 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_bug1003461-switchtab-override.js @@ -0,0 +1,61 @@ +/* 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/. */ + +add_task(function* test_switchtab_override() { + let testURL = "http://example.org/browser/browser/base/content/test/urlbar/dummy_page.html"; + + info("Opening first tab"); + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, testURL); + + info("Opening and selecting second tab"); + let secondTab = gBrowser.selectedTab = gBrowser.addTab(); + registerCleanupFunction(() => { + try { + gBrowser.removeTab(tab); + gBrowser.removeTab(secondTab); + } catch (ex) { /* tabs may have already been closed in case of failure */ } + }); + + info("Wait for autocomplete") + let deferred = Promise.defer(); + let onSearchComplete = gURLBar.onSearchComplete; + registerCleanupFunction(() => { + gURLBar.onSearchComplete = onSearchComplete; + }); + gURLBar.onSearchComplete = function () { + ok(gURLBar.popupOpen, "The autocomplete popup is correctly open"); + onSearchComplete.apply(gURLBar); + deferred.resolve(); + } + + gURLBar.focus(); + gURLBar.value = "dummy_pag"; + EventUtils.synthesizeKey("e", {}); + yield deferred.promise; + + info("Select second autocomplete popup entry"); + EventUtils.synthesizeKey("VK_DOWN", {}); + ok(/moz-action:switchtab/.test(gURLBar.value), "switch to tab entry found"); + + info("Override switch-to-tab"); + deferred = Promise.defer(); + // In case of failure this would switch tab. + let onTabSelect = event => { + deferred.reject(new Error("Should have overridden switch to tab")); + }; + gBrowser.tabContainer.addEventListener("TabSelect", onTabSelect, false); + registerCleanupFunction(() => { + gBrowser.tabContainer.removeEventListener("TabSelect", onTabSelect, false); + }); + // Otherwise it would load the page. + BrowserTestUtils.browserLoaded(secondTab.linkedBrowser).then(deferred.resolve); + + EventUtils.synthesizeKey("VK_SHIFT", { type: "keydown" }); + EventUtils.synthesizeKey("VK_RETURN", { }); + info(`gURLBar.value = ${gURLBar.value}`); + EventUtils.synthesizeKey("VK_SHIFT", { type: "keyup" }); + yield deferred.promise; + + yield PlacesTestUtils.clearHistory(); +}); diff --git a/browser/base/content/test/urlbar/browser_bug1024133-switchtab-override-keynav.js b/browser/base/content/test/urlbar/browser_bug1024133-switchtab-override-keynav.js new file mode 100644 index 000000000..2d97ea07b --- /dev/null +++ b/browser/base/content/test/urlbar/browser_bug1024133-switchtab-override-keynav.js @@ -0,0 +1,37 @@ +/* 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/. */ + +add_task(function* test_switchtab_override_keynav() { + let testURL = "http://example.org/browser/browser/base/content/test/urlbar/dummy_page.html"; + + info("Opening first tab"); + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, testURL); + + info("Opening and selecting second tab"); + let secondTab = gBrowser.selectedTab = gBrowser.addTab(); + registerCleanupFunction(() => { + try { + gBrowser.removeTab(tab); + gBrowser.removeTab(secondTab); + } catch (ex) { /* tabs may have already been closed in case of failure */ } + return PlacesTestUtils.clearHistory(); + }); + + gURLBar.focus(); + gURLBar.value = "dummy_pag"; + EventUtils.synthesizeKey("e", {}); + yield promiseSearchComplete(); + + info("Select second autocomplete popup entry"); + EventUtils.synthesizeKey("VK_DOWN", {}); + ok(/moz-action:switchtab/.test(gURLBar.value), "switch to tab entry found"); + + info("Shift+left on switch-to-tab entry"); + + EventUtils.synthesizeKey("VK_SHIFT", { type: "keydown" }); + EventUtils.synthesizeKey("VK_LEFT", { shiftKey: true }); + EventUtils.synthesizeKey("VK_SHIFT", { type: "keyup" }); + + ok(!/moz-action:switchtab/.test(gURLBar.inputField.value), "switch to tab should be hidden"); +}); diff --git a/browser/base/content/test/urlbar/browser_bug1025195_switchToTabHavingURI_aOpenParams.js b/browser/base/content/test/urlbar/browser_bug1025195_switchToTabHavingURI_aOpenParams.js new file mode 100644 index 000000000..9e779ade1 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_bug1025195_switchToTabHavingURI_aOpenParams.js @@ -0,0 +1,124 @@ +/* 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/. */ + +add_task(function* test_ignoreFragment() { + let tabRefAboutHome = + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:home#1"); + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + let numTabsAtStart = gBrowser.tabs.length; + + switchTab("about:home#1", true); + switchTab("about:mozilla", true); + + let hashChangePromise = ContentTask.spawn(tabRefAboutHome.linkedBrowser, null, function* () { + yield ContentTaskUtils.waitForEvent(this, "hashchange", false); + }); + switchTab("about:home#2", true, { ignoreFragment: "whenComparingAndReplace" }); + is(tabRefAboutHome, gBrowser.selectedTab, "The same about:home tab should be switched to"); + yield hashChangePromise; + is(gBrowser.currentURI.ref, "2", "The ref should be updated to the new ref"); + switchTab("about:mozilla", true); + switchTab("about:home#3", true, { ignoreFragment: "whenComparing" }); + is(tabRefAboutHome, gBrowser.selectedTab, "The same about:home tab should be switched to"); + is(gBrowser.currentURI.ref, "2", "The ref should be unchanged since the fragment is only ignored when comparing"); + switchTab("about:mozilla", true); + switchTab("about:home#1", false); + isnot(tabRefAboutHome, gBrowser.selectedTab, "Selected tab should not be initial about:blank tab"); + is(gBrowser.tabs.length, numTabsAtStart + 1, "Should have one new tab opened"); + switchTab("about:mozilla", true); + switchTab("about:home", true, {ignoreFragment: "whenComparingAndReplace"}); + yield BrowserTestUtils.waitForCondition(function() { + return tabRefAboutHome.linkedBrowser.currentURI.spec == "about:home"; + }); + is(tabRefAboutHome.linkedBrowser.currentURI.spec, "about:home", "about:home shouldn't have hash"); + switchTab("about:about", false, { ignoreFragment: "whenComparingAndReplace" }); + cleanupTestTabs(); +}); + +add_task(function* test_ignoreQueryString() { + let tabRefAboutHome = + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:home?hello=firefox"); + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + + switchTab("about:home?hello=firefox", true); + switchTab("about:home?hello=firefoxos", false); + // Remove the last opened tab to test ignoreQueryString option. + gBrowser.removeCurrentTab(); + switchTab("about:home?hello=firefoxos", true, { ignoreQueryString: true }); + is(tabRefAboutHome, gBrowser.selectedTab, "Selected tab should be the initial about:home tab"); + is(gBrowser.currentURI.spec, "about:home?hello=firefox", "The spec should NOT be updated to the new query string"); + cleanupTestTabs(); +}); + +add_task(function* test_replaceQueryString() { + let tabRefAboutHome = + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:home?hello=firefox"); + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + + switchTab("about:home", false); + switchTab("about:home?hello=firefox", true); + switchTab("about:home?hello=firefoxos", false); + // Remove the last opened tab to test replaceQueryString option. + gBrowser.removeCurrentTab(); + switchTab("about:home?hello=firefoxos", true, { replaceQueryString: true }); + is(tabRefAboutHome, gBrowser.selectedTab, "Selected tab should be the initial about:home tab"); + // Wait for the tab to load the new URI spec. + yield BrowserTestUtils.browserLoaded(tabRefAboutHome.linkedBrowser); + is(gBrowser.currentURI.spec, "about:home?hello=firefoxos", "The spec should be updated to the new spec"); + cleanupTestTabs(); +}); + +add_task(function* test_replaceQueryStringAndFragment() { + let tabRefAboutHome = + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:home?hello=firefox#aaa"); + let tabRefAboutMozilla = + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla?hello=firefoxos#aaa"); + + switchTab("about:home", false); + gBrowser.removeCurrentTab(); + switchTab("about:home?hello=firefox#aaa", true); + is(tabRefAboutHome, gBrowser.selectedTab, "Selected tab should be the initial about:home tab"); + switchTab("about:mozilla?hello=firefox#bbb", true, { replaceQueryString: true, ignoreFragment: "whenComparingAndReplace" }); + is(tabRefAboutMozilla, gBrowser.selectedTab, "Selected tab should be the initial about:mozilla tab"); + switchTab("about:home?hello=firefoxos#bbb", true, { ignoreQueryString: true, ignoreFragment: "whenComparingAndReplace" }); + is(tabRefAboutHome, gBrowser.selectedTab, "Selected tab should be the initial about:home tab"); + cleanupTestTabs(); +}); + +add_task(function* test_ignoreQueryStringIgnoresFragment() { + let tabRefAboutHome = + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:home?hello=firefox#aaa"); + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla?hello=firefoxos#aaa"); + + switchTab("about:home?hello=firefox#bbb", false, { ignoreQueryString: true }); + gBrowser.removeCurrentTab(); + switchTab("about:home?hello=firefoxos#aaa", true, { ignoreQueryString: true }); + is(tabRefAboutHome, gBrowser.selectedTab, "Selected tab should be the initial about:home tab"); + cleanupTestTabs(); +}); + +// Begin helpers + +function cleanupTestTabs() { + while (gBrowser.tabs.length > 1) + gBrowser.removeCurrentTab(); +} + +function switchTab(aURI, aShouldFindExistingTab, aOpenParams = {}) { + // Build the description before switchToTabHavingURI deletes the object properties. + let msg = `Should switch to existing ${aURI} tab if one existed, ` + + `${(aOpenParams.ignoreFragment ? "ignoring" : "including")} fragment portion, `; + if (aOpenParams.replaceQueryString) { + msg += "replacing"; + } else if (aOpenParams.ignoreQueryString) { + msg += "ignoring"; + } else { + msg += "including"; + } + msg += " query string."; + let tabFound = switchToTabHavingURI(aURI, true, aOpenParams); + is(tabFound, aShouldFindExistingTab, msg); +} + +registerCleanupFunction(cleanupTestTabs); diff --git a/browser/base/content/test/urlbar/browser_bug1070778.js b/browser/base/content/test/urlbar/browser_bug1070778.js new file mode 100644 index 000000000..ab88d04d8 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_bug1070778.js @@ -0,0 +1,55 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +function is_selected(index) { + is(gURLBar.popup.richlistbox.selectedIndex, index, `Item ${index + 1} should be selected`); +} + +add_task(function*() { + let bookmarks = []; + bookmarks.push((yield PlacesUtils.bookmarks + .insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid, + url: "http://example.com/?q=%s", + title: "test" }))); + yield PlacesUtils.keywords.insert({ keyword: "keyword", + url: "http://example.com/?q=%s" }); + + // This item only needed so we can select the keyword item, select something + // else, then select the keyword item again. + bookmarks.push((yield PlacesUtils.bookmarks + .insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid, + url: "http://example.com/keyword", + title: "keyword abc" }))); + + registerCleanupFunction(function* () { + for (let bm of bookmarks) { + yield PlacesUtils.bookmarks.remove(bm); + } + }); + + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + yield promiseAutocompleteResultPopup("keyword a"); + + // First item should already be selected + is_selected(0); + // Select next one (important!) + EventUtils.synthesizeKey("VK_DOWN", {}); + is_selected(1); + // Re-select keyword item + EventUtils.synthesizeKey("VK_UP", {}); + is_selected(0); + + EventUtils.synthesizeKey("b", {}); + yield promiseSearchComplete(); + + is(gURLBar.textValue, "keyword ab", "urlbar should have expected input"); + + let result = gURLBar.popup.richlistbox.firstChild; + isnot(result, null, "Should have first item"); + let uri = NetUtil.newURI(result.getAttribute("url")); + is(uri.spec, PlacesUtils.mozActionURI("keyword", {url: "http://example.com/?q=ab", input: "keyword ab"}), "Expect correct url"); + + EventUtils.synthesizeKey("VK_ESCAPE", {}); + yield promisePopupHidden(gURLBar.popup); + gBrowser.removeTab(tab); +}); diff --git a/browser/base/content/test/urlbar/browser_bug1104165-switchtab-decodeuri.js b/browser/base/content/test/urlbar/browser_bug1104165-switchtab-decodeuri.js new file mode 100644 index 000000000..d165d7304 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_bug1104165-switchtab-decodeuri.js @@ -0,0 +1,29 @@ +add_task(function* test_switchtab_decodeuri() { + info("Opening first tab"); + const TEST_URL = "http://example.org/browser/browser/base/content/test/urlbar/dummy_page.html#test%7C1"; + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_URL); + + info("Opening and selecting second tab"); + gBrowser.selectedTab = gBrowser.addTab(); + + info("Wait for autocomplete") + yield promiseAutocompleteResultPopup("dummy_page"); + + info("Select autocomplete popup entry"); + EventUtils.synthesizeKey("VK_DOWN", {}); + ok(gURLBar.value.startsWith("moz-action:switchtab"), "switch to tab entry found"); + + info("switch-to-tab"); + yield new Promise((resolve, reject) => { + // In case of success it should switch tab. + gBrowser.tabContainer.addEventListener("TabSelect", function select() { + gBrowser.tabContainer.removeEventListener("TabSelect", select, false); + is(gBrowser.selectedTab, tab, "Should have switched to the right tab"); + resolve(); + }, false); + EventUtils.synthesizeKey("VK_RETURN", { }); + }); + + gBrowser.removeCurrentTab(); + yield PlacesTestUtils.clearHistory(); +}); diff --git a/browser/base/content/test/urlbar/browser_bug1225194-remotetab.js b/browser/base/content/test/urlbar/browser_bug1225194-remotetab.js new file mode 100644 index 000000000..3b4a44e76 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_bug1225194-remotetab.js @@ -0,0 +1,16 @@ +add_task(function* test_remotetab_opens() { + const url = "http://example.org/browser/browser/base/content/test/urlbar/dummy_page.html"; + yield BrowserTestUtils.withNewTab({url: "about:robots", gBrowser}, function* () { + // Set the urlbar to include the moz-action + gURLBar.value = "moz-action:remotetab," + JSON.stringify({ url }); + // Focus the urlbar so we can press enter + gURLBar.focus(); + + // The URL is going to open in the current tab as it is currently about:blank + let promiseTabLoaded = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + EventUtils.synthesizeKey("VK_RETURN", {}); + yield promiseTabLoaded; + + Assert.equal(gBrowser.selectedTab.linkedBrowser.currentURI.spec, url, "correct URL loaded"); + }); +}); diff --git a/browser/base/content/test/urlbar/browser_bug304198.js b/browser/base/content/test/urlbar/browser_bug304198.js new file mode 100644 index 000000000..dc8d39fae --- /dev/null +++ b/browser/base/content/test/urlbar/browser_bug304198.js @@ -0,0 +1,109 @@ +/* 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/. */ + +add_task(function* () { + let charsToDelete, deletedURLTab, fullURLTab, partialURLTab, testPartialURL, testURL; + + charsToDelete = 5; + deletedURLTab = gBrowser.addTab(); + fullURLTab = gBrowser.addTab(); + partialURLTab = gBrowser.addTab(); + testURL = "http://example.org/browser/browser/base/content/test/urlbar/dummy_page.html"; + + let loaded1 = BrowserTestUtils.browserLoaded(deletedURLTab.linkedBrowser, testURL); + let loaded2 = BrowserTestUtils.browserLoaded(fullURLTab.linkedBrowser, testURL); + let loaded3 = BrowserTestUtils.browserLoaded(partialURLTab.linkedBrowser, testURL); + deletedURLTab.linkedBrowser.loadURI(testURL); + fullURLTab.linkedBrowser.loadURI(testURL); + partialURLTab.linkedBrowser.loadURI(testURL); + yield Promise.all([loaded1, loaded2, loaded3]); + + testURL = gURLBar.trimValue(testURL); + testPartialURL = testURL.substr(0, (testURL.length - charsToDelete)); + + function cleanUp() { + gBrowser.removeTab(fullURLTab); + gBrowser.removeTab(partialURLTab); + gBrowser.removeTab(deletedURLTab); + } + + function* cycleTabs() { + yield BrowserTestUtils.switchTab(gBrowser, fullURLTab); + is(gURLBar.textValue, testURL, 'gURLBar.textValue should be testURL after switching back to fullURLTab'); + + yield BrowserTestUtils.switchTab(gBrowser, partialURLTab); + is(gURLBar.textValue, testPartialURL, 'gURLBar.textValue should be testPartialURL after switching back to partialURLTab'); + yield BrowserTestUtils.switchTab(gBrowser, deletedURLTab); + is(gURLBar.textValue, '', 'gURLBar.textValue should be "" after switching back to deletedURLTab'); + + yield BrowserTestUtils.switchTab(gBrowser, fullURLTab); + is(gURLBar.textValue, testURL, 'gURLBar.textValue should be testURL after switching back to fullURLTab'); + } + + function urlbarBackspace() { + return new Promise((resolve, reject) => { + gBrowser.selectedBrowser.focus(); + gURLBar.addEventListener("input", function () { + gURLBar.removeEventListener("input", arguments.callee, false); + resolve(); + }, false); + gURLBar.focus(); + if (gURLBar.selectionStart == gURLBar.selectionEnd) { + gURLBar.selectionStart = gURLBar.selectionEnd = gURLBar.textValue.length; + } + EventUtils.synthesizeKey("VK_BACK_SPACE", {}); + }); + } + + function* prepareDeletedURLTab() { + yield BrowserTestUtils.switchTab(gBrowser, deletedURLTab); + is(gURLBar.textValue, testURL, 'gURLBar.textValue should be testURL after initial switch to deletedURLTab'); + + // simulate the user removing the whole url from the location bar + gPrefService.setBoolPref("browser.urlbar.clickSelectsAll", true); + + yield urlbarBackspace(); + is(gURLBar.textValue, "", 'gURLBar.textValue should be "" (just set)'); + if (gPrefService.prefHasUserValue("browser.urlbar.clickSelectsAll")) { + gPrefService.clearUserPref("browser.urlbar.clickSelectsAll"); + } + } + + function* prepareFullURLTab() { + yield BrowserTestUtils.switchTab(gBrowser, fullURLTab); + is(gURLBar.textValue, testURL, 'gURLBar.textValue should be testURL after initial switch to fullURLTab'); + } + + function* preparePartialURLTab() { + yield BrowserTestUtils.switchTab(gBrowser, partialURLTab); + is(gURLBar.textValue, testURL, 'gURLBar.textValue should be testURL after initial switch to partialURLTab'); + + // simulate the user removing part of the url from the location bar + gPrefService.setBoolPref("browser.urlbar.clickSelectsAll", false); + + let deleted = 0; + while (deleted < charsToDelete) { + yield urlbarBackspace(arguments.callee); + deleted++; + } + + is(gURLBar.textValue, testPartialURL, "gURLBar.textValue should be testPartialURL (just set)"); + if (gPrefService.prefHasUserValue("browser.urlbar.clickSelectsAll")) { + gPrefService.clearUserPref("browser.urlbar.clickSelectsAll"); + } + } + + // prepare the three tabs required by this test + + // First tab + yield* prepareFullURLTab(); + yield* preparePartialURLTab(); + yield* prepareDeletedURLTab(); + + // now cycle the tabs and make sure everything looks good + yield* cycleTabs(); + cleanUp(); +}); + + diff --git a/browser/base/content/test/urlbar/browser_bug556061.js b/browser/base/content/test/urlbar/browser_bug556061.js new file mode 100644 index 000000000..4c6ac5bf5 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_bug556061.js @@ -0,0 +1,98 @@ +/* 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 testURL = "http://example.org/browser/browser/base/content/test/urlbar/dummy_page.html"; +var testActionURL = "moz-action:switchtab," + JSON.stringify({url: testURL}); +testURL = gURLBar.trimValue(testURL); +var testTab; + +function runNextTest() { + if (tests.length) { + let t = tests.shift(); + waitForClipboard(t.expected, t.setup, function() { + t.success(); + runNextTest(); + }, cleanup); + } + else { + cleanup(); + } +} + +function cleanup() { + gBrowser.removeTab(testTab); + finish(); +} + +var tests = [ + { + expected: testURL, + setup: function() { + gURLBar.value = testActionURL; + gURLBar.valueIsTyped = true; + is(gURLBar.value, testActionURL, "gURLBar starts with the correct real value"); + is(gURLBar.textValue, testURL, "gURLBar starts with the correct display value"); + + // Focus the urlbar so we can select it all & copy + gURLBar.focus(); + gURLBar.select(); + goDoCommand("cmd_copy"); + }, + success: function() { + is(gURLBar.value, testActionURL, "gURLBar.value didn't change when copying"); + } + }, + { + expected: testURL.substring(0, 10), + setup: function() { + // Set selectionStart/End manually and make sure it matches the substring + gURLBar.selectionStart = 0; + gURLBar.selectionEnd = 10; + goDoCommand("cmd_copy"); + }, + success: function() { + is(gURLBar.value, testActionURL, "gURLBar.value didn't change when copying"); + } + }, + { + expected: testURL, + setup: function() { + // Setup for cut test... + // Select all + gURLBar.select(); + goDoCommand("cmd_cut"); + }, + success: function() { + is(gURLBar.value, "", "gURLBar.value is now empty"); + } + }, + { + expected: testURL.substring(testURL.length - 10, testURL.length), + setup: function() { + // Reset urlbar value + gURLBar.value = testActionURL; + gURLBar.valueIsTyped = true; + // Sanity check that we have the right value + is(gURLBar.value, testActionURL, "gURLBar starts with the correct real value"); + is(gURLBar.textValue, testURL, "gURLBar starts with the correct display value"); + + // Now just select part of the value & cut that. + gURLBar.selectionStart = testURL.length - 10; + gURLBar.selectionEnd = testURL.length; + goDoCommand("cmd_cut"); + }, + success: function() { + is(gURLBar.value, testURL.substring(0, testURL.length - 10), "gURLBar.value has the correct value"); + } + } +]; + +function test() { + waitForExplicitFinish(); + testTab = gBrowser.addTab(); + gBrowser.selectedTab = testTab; + + // Kick off the testing + runNextTest(); +} diff --git a/browser/base/content/test/urlbar/browser_bug562649.js b/browser/base/content/test/urlbar/browser_bug562649.js new file mode 100644 index 000000000..f56e430ee --- /dev/null +++ b/browser/base/content/test/urlbar/browser_bug562649.js @@ -0,0 +1,24 @@ +function test() { + const URI = "data:text/plain,bug562649"; + browserDOMWindow.openURI(makeURI(URI), + null, + Ci.nsIBrowserDOMWindow.OPEN_NEWTAB, + Ci.nsIBrowserDOMWindow.OPEN_EXTERNAL); + + is(gBrowser.userTypedValue, URI, "userTypedValue matches test URI"); + is(gURLBar.value, URI, "location bar value matches test URI"); + + gBrowser.selectedTab = gBrowser.addTab(); + gBrowser.removeCurrentTab({ skipPermitUnload: true }); + is(gBrowser.userTypedValue, URI, "userTypedValue matches test URI after switching tabs"); + is(gURLBar.value, URI, "location bar value matches test URI after switching tabs"); + + waitForExplicitFinish(); + BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser).then(() => { + is(gBrowser.userTypedValue, null, "userTypedValue is null as the page has loaded"); + is(gURLBar.value, URI, "location bar value matches test URI as the page has loaded"); + + gBrowser.removeCurrentTab({ skipPermitUnload: true }); + finish(); + }); +} diff --git a/browser/base/content/test/urlbar/browser_bug623155.js b/browser/base/content/test/urlbar/browser_bug623155.js new file mode 100644 index 000000000..dd6ff8c85 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_bug623155.js @@ -0,0 +1,137 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +const REDIRECT_FROM = "https://example.com/browser/browser/base/content/test/urlbar/" + + "redirect_bug623155.sjs"; + +const REDIRECT_TO = "https://www.bank1.com/"; // Bad-cert host. + +function isRedirectedURISpec(aURISpec) { + return isRedirectedURI(Services.io.newURI(aURISpec, null, null)); +} + +function isRedirectedURI(aURI) { + // Compare only their before-hash portion. + return Services.io.newURI(REDIRECT_TO, null, null) + .equalsExceptRef(aURI); +} + +/* + Test. + +1. Load +https://example.com/browser/browser/base/content/test/urlbar/redirect_bug623155.sjs#BG + in a background tab. + +2. The redirected URI is <https://www.bank1.com/#BG>, which displayes a cert + error page. + +3. Switch the tab to foreground. + +4. Check the URLbar's value, expecting <https://www.bank1.com/#BG> + +5. Load +https://example.com/browser/browser/base/content/test/urlbar/redirect_bug623155.sjs#FG + in the foreground tab. + +6. The redirected URI is <https://www.bank1.com/#FG>. And this is also + a cert-error page. + +7. Check the URLbar's value, expecting <https://www.bank1.com/#FG> + +8. End. + + */ + +var gNewTab; + +function test() { + waitForExplicitFinish(); + + // Load a URI in the background. + gNewTab = gBrowser.addTab(REDIRECT_FROM + "#BG"); + gBrowser.getBrowserForTab(gNewTab) + .webProgress + .addProgressListener(gWebProgressListener, + Components.interfaces.nsIWebProgress + .NOTIFY_LOCATION); +} + +var gWebProgressListener = { + QueryInterface: function(aIID) { + if (aIID.equals(Components.interfaces.nsIWebProgressListener) || + aIID.equals(Components.interfaces.nsISupportsWeakReference) || + aIID.equals(Components.interfaces.nsISupports)) + return this; + throw Components.results.NS_NOINTERFACE; + }, + + // --------------------------------------------------------------------------- + // NOTIFY_LOCATION mode should work fine without these methods. + // + // onStateChange: function() {}, + // onStatusChange: function() {}, + // onProgressChange: function() {}, + // onSecurityChange: function() {}, + // ---------------------------------------------------------------------------- + + onLocationChange: function(aWebProgress, aRequest, aLocation, aFlags) { + if (!aRequest) { + // This is bug 673752, or maybe initial "about:blank". + return; + } + + ok(gNewTab, "There is a new tab."); + ok(isRedirectedURI(aLocation), + "onLocationChange catches only redirected URI."); + + if (aLocation.ref == "BG") { + // This is background tab's request. + isnot(gNewTab, gBrowser.selectedTab, "This is a background tab."); + } else if (aLocation.ref == "FG") { + // This is foreground tab's request. + is(gNewTab, gBrowser.selectedTab, "This is a foreground tab."); + } + else { + // We shonuld not reach here. + ok(false, "This URI hash is not expected:" + aLocation.ref); + } + + let isSelectedTab = gNewTab.selected; + setTimeout(delayed, 0, isSelectedTab); + } +}; + +function delayed(aIsSelectedTab) { + // Switch tab and confirm URL bar. + if (!aIsSelectedTab) { + gBrowser.selectedTab = gNewTab; + } + + let currentURI = gBrowser.selectedBrowser.currentURI.spec; + ok(isRedirectedURISpec(currentURI), + "The content area is redirected. aIsSelectedTab:" + aIsSelectedTab); + is(gURLBar.value, currentURI, + "The URL bar shows the content URI. aIsSelectedTab:" + aIsSelectedTab); + + if (!aIsSelectedTab) { + // If this was a background request, go on a foreground request. + gBrowser.selectedBrowser.loadURI(REDIRECT_FROM + "#FG"); + } + else { + // Othrewise, nothing to do remains. + finish(); + } +} + +/* Cleanup */ +registerCleanupFunction(function() { + if (gNewTab) { + gBrowser.getBrowserForTab(gNewTab) + .webProgress + .removeProgressListener(gWebProgressListener); + + gBrowser.removeTab(gNewTab); + } + gNewTab = null; +}); diff --git a/browser/base/content/test/urlbar/browser_bug783614.js b/browser/base/content/test/urlbar/browser_bug783614.js new file mode 100644 index 000000000..ebc62e8fa --- /dev/null +++ b/browser/base/content/test/urlbar/browser_bug783614.js @@ -0,0 +1,13 @@ +/* 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/. */ + +function test() { + gURLBar.focus(); + gURLBar.inputField.value = "https://example.com/"; + gURLBar.selectionStart = 4; + gURLBar.selectionEnd = 5; + goDoCommand("cmd_cut"); + is(gURLBar.inputField.value, "http://example.com/", "location bar value after cutting 's' from https"); + gURLBar.handleRevert(); +} diff --git a/browser/base/content/test/urlbar/browser_canonizeURL.js b/browser/base/content/test/urlbar/browser_canonizeURL.js new file mode 100644 index 000000000..59ab54ca0 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_canonizeURL.js @@ -0,0 +1,42 @@ +add_task(function*() { + let testcases = [ + ["example", "http://www.example.net/", { shiftKey: true }], + // Check that a direct load is not overwritten by a previous canonization. + ["http://example.com/test/", "http://example.com/test/", {}], + ["ex-ample", "http://www.ex-ample.net/", { shiftKey: true }], + [" example ", "http://www.example.net/", { shiftKey: true }], + [" example/foo ", "http://www.example.net/foo", { shiftKey: true }], + [" example/foo bar ", "http://www.example.net/foo%20bar", { shiftKey: true }], + ["example.net", "http://example.net/", { shiftKey: true }], + ["http://example", "http://example/", { shiftKey: true }], + ["example:8080", "http://example:8080/", { shiftKey: true }], + ["ex-ample.foo", "http://ex-ample.foo/", { shiftKey: true }], + ["example.foo/bar ", "http://example.foo/bar", { shiftKey: true }], + ["1.1.1.1", "http://1.1.1.1/", { shiftKey: true }], + ["ftp://example", "ftp://example/", { shiftKey: true }], + ["ftp.example.bar", "http://ftp.example.bar/", { shiftKey: true }], + ["ex ample", Services.search.defaultEngine.getSubmission("ex ample", null, "keyword").uri.spec, { shiftKey: true }], + ]; + + // Disable autoFill for this test, since it could mess up the results. + let autoFill = Preferences.get("browser.urlbar.autoFill"); + Preferences.set("browser.urlbar.autoFill", false); + registerCleanupFunction(() => { + Preferences.set("browser.urlbar.autoFill", autoFill); + }); + + for (let [inputValue, expectedURL, options] of testcases) { + let promiseLoad = waitForDocLoadAndStopIt(expectedURL); + gURLBar.focus(); + if (Object.keys(options).length > 0) { + gURLBar.selectionStart = gURLBar.selectionEnd = + gURLBar.inputField.value.length; + gURLBar.inputField.value = inputValue.slice(0, -1); + EventUtils.synthesizeKey(inputValue.slice(-1), {}); + } else { + gURLBar.textValue = inputValue; + } + EventUtils.synthesizeKey("VK_RETURN", options); + yield promiseLoad; + } +}); diff --git a/browser/base/content/test/urlbar/browser_dragdropURL.js b/browser/base/content/test/urlbar/browser_dragdropURL.js new file mode 100644 index 000000000..ec2906700 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_dragdropURL.js @@ -0,0 +1,15 @@ +"use strict"; + +const TEST_URL = "data:text/html,a test page"; +const DRAG_URL = "http://www.example.com/"; + +add_task(function* checkURLBarUpdateForDrag() { + yield BrowserTestUtils.withNewTab(TEST_URL, function* (browser) { + // Have to use something other than the URL bar as a source, so picking the + // downloads button somewhat arbitrarily: + EventUtils.synthesizeDrop(document.getElementById("downloads-button"), gURLBar, + [[{type: "text/plain", data: DRAG_URL}]], "copy", window); + is(gURLBar.value, TEST_URL, "URL bar value should not have changed"); + is(gBrowser.selectedBrowser.userTypedValue, null, "Stored URL bar value should not have changed"); + }); +}); diff --git a/browser/base/content/test/urlbar/browser_locationBarCommand.js b/browser/base/content/test/urlbar/browser_locationBarCommand.js new file mode 100644 index 000000000..935bdf758 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_locationBarCommand.js @@ -0,0 +1,218 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +const TEST_VALUE = "example.com"; +const START_VALUE = "example.org"; + +add_task(function* setup() { + Services.prefs.setBoolPref("browser.altClickSave", true); + + registerCleanupFunction(() => { + Services.prefs.clearUserPref("browser.altClickSave"); + }); +}); + +add_task(function* alt_left_click_test() { + info("Running test: Alt left click"); + + // Monkey patch saveURL() to avoid dealing with file save code paths. + let oldSaveURL = saveURL; + let saveURLPromise = new Promise(resolve => { + saveURL = () => { + // Restore old saveURL() value. + saveURL = oldSaveURL; + resolve(); + }; + }); + + triggerCommand(true, {altKey: true}); + + yield saveURLPromise; + ok(true, "SaveURL was called"); + is(gURLBar.value, "", "Urlbar reverted to original value"); +}); + +add_task(function* shift_left_click_test() { + info("Running test: Shift left click"); + + let newWindowPromise = BrowserTestUtils.waitForNewWindow(); + triggerCommand(true, {shiftKey: true}); + let win = yield newWindowPromise; + + // Wait for the initial browser to load. + let browser = win.gBrowser.selectedBrowser; + let destinationURL = "http://" + TEST_VALUE + "/"; + yield Promise.all([ + BrowserTestUtils.browserLoaded(browser), + BrowserTestUtils.waitForLocationChange(win.gBrowser, destinationURL) + ]); + + info("URL should be loaded in a new window"); + is(gURLBar.value, "", "Urlbar reverted to original value"); + yield promiseCheckChildNoFocusedElement(gBrowser.selectedBrowser); + is(document.activeElement, gBrowser.selectedBrowser, "Content window should be focused"); + is(win.gURLBar.textValue, TEST_VALUE, "New URL is loaded in new window"); + + // Cleanup. + yield BrowserTestUtils.closeWindow(win); +}); + +add_task(function* right_click_test() { + info("Running test: Right click on go button"); + + // Add a new tab. + yield* promiseOpenNewTab(); + + triggerCommand(true, {button: 2}); + + // Right click should do nothing (context menu will be shown). + is(gURLBar.value, TEST_VALUE, "Urlbar still has the value we entered"); + + // Cleanup. + gBrowser.removeCurrentTab(); +}); + +add_task(function* shift_accel_left_click_test() { + info("Running test: Shift+Ctrl/Cmd left click on go button"); + + // Add a new tab. + let tab = yield* promiseOpenNewTab(); + + let loadStartedPromise = promiseLoadStarted(); + triggerCommand(true, {accelKey: true, shiftKey: true}); + yield loadStartedPromise; + + // Check the load occurred in a new background tab. + info("URL should be loaded in a new background tab"); + is(gURLBar.value, "", "Urlbar reverted to original value"); + ok(!gURLBar.focused, "Urlbar is no longer focused after urlbar command"); + is(gBrowser.selectedTab, tab, "Focus did not change to the new tab"); + + // Select the new background tab + gBrowser.selectedTab = gBrowser.selectedTab.nextSibling; + is(gURLBar.value, TEST_VALUE, "New URL is loaded in new tab"); + + // Cleanup. + gBrowser.removeCurrentTab(); + gBrowser.removeCurrentTab(); +}); + +add_task(function* load_in_current_tab_test() { + let tests = [ + {desc: "Simple return keypress"}, + {desc: "Left click on go button", click: true}, + {desc: "Ctrl/Cmd+Return keypress", event: {accelKey: true}}, + {desc: "Alt+Return keypress in a blank tab", event: {altKey: true}} + ]; + + for (let test of tests) { + info(`Running test: ${test.desc}`); + + // Add a new tab. + let tab = yield* promiseOpenNewTab(); + + // Trigger a load and check it occurs in the current tab. + let loadStartedPromise = promiseLoadStarted(); + triggerCommand(test.click || false, test.event || {}); + yield loadStartedPromise; + + info("URL should be loaded in the current tab"); + is(gURLBar.value, TEST_VALUE, "Urlbar still has the value we entered"); + yield promiseCheckChildNoFocusedElement(gBrowser.selectedBrowser); + is(document.activeElement, gBrowser.selectedBrowser, "Content window should be focused"); + is(gBrowser.selectedTab, tab, "New URL was loaded in the current tab"); + + // Cleanup. + gBrowser.removeCurrentTab(); + } +}); + +add_task(function* load_in_new_tab_test() { + let tests = [ + {desc: "Ctrl/Cmd left click on go button", click: true, event: {accelKey: true}}, + {desc: "Alt+Return keypress in a dirty tab", event: {altKey: true}, url: START_VALUE} + ]; + + for (let test of tests) { + info(`Running test: ${test.desc}`); + + // Add a new tab. + let tab = yield* promiseOpenNewTab(test.url || "about:blank"); + + // Trigger a load and check it occurs in the current tab. + let tabSwitchedPromise = promiseNewTabSwitched(); + triggerCommand(test.click || false, test.event || {}); + yield tabSwitchedPromise; + + // Check the load occurred in a new tab. + info("URL should be loaded in a new focused tab"); + is(gURLBar.inputField.value, TEST_VALUE, "Urlbar still has the value we entered"); + yield promiseCheckChildNoFocusedElement(gBrowser.selectedBrowser); + is(document.activeElement, gBrowser.selectedBrowser, "Content window should be focused"); + isnot(gBrowser.selectedTab, tab, "New URL was loaded in a new tab"); + + // Cleanup. + gBrowser.removeCurrentTab(); + gBrowser.removeCurrentTab(); + } +}); + +function triggerCommand(shouldClick, event) { + gURLBar.value = TEST_VALUE; + gURLBar.focus(); + + if (shouldClick) { + is(gURLBar.getAttribute("pageproxystate"), "invalid", + "page proxy state must be invalid for go button to be visible"); + + let goButton = document.getElementById("urlbar-go-button"); + EventUtils.synthesizeMouseAtCenter(goButton, event); + } else { + EventUtils.synthesizeKey("VK_RETURN", event); + } +} + +function promiseLoadStarted() { + return new Promise(resolve => { + gBrowser.addTabsProgressListener({ + onStateChange(browser, webProgress, req, flags, status) { + if (flags & Ci.nsIWebProgressListener.STATE_START) { + gBrowser.removeTabsProgressListener(this); + resolve(); + } + } + }); + }); +} + +function* promiseOpenNewTab(url = "about:blank") { + let tab = gBrowser.addTab(url); + let tabSwitchPromise = promiseNewTabSwitched(tab); + gBrowser.selectedTab = tab; + yield BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + yield tabSwitchPromise; + return tab; +} + +function promiseNewTabSwitched() { + return new Promise(resolve => { + gBrowser.addEventListener("TabSwitchDone", function onSwitch() { + gBrowser.removeEventListener("TabSwitchDone", onSwitch); + executeSoon(resolve); + }); + }); +} + +function promiseCheckChildNoFocusedElement(browser) +{ + if (!gMultiProcessBrowser) { + Assert.equal(Services.focus.focusedElement, null, "There should be no focused element"); + return null; + } + + return ContentTask.spawn(browser, { }, function* () { + const fm = Components.classes["@mozilla.org/focus-manager;1"]. + getService(Components.interfaces.nsIFocusManager); + Assert.equal(fm.focusedElement, null, "There should be no focused element"); + }); +} diff --git a/browser/base/content/test/urlbar/browser_locationBarExternalLoad.js b/browser/base/content/test/urlbar/browser_locationBarExternalLoad.js new file mode 100644 index 000000000..31fc84768 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_locationBarExternalLoad.js @@ -0,0 +1,65 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +const url = "data:text/html,<body>hi"; + +add_task(function*() { + yield* testURL(url, urlEnter); + yield* testURL(url, urlClick); +}); + +function urlEnter(url) { + gURLBar.value = url; + gURLBar.focus(); + EventUtils.synthesizeKey("VK_RETURN", {}); +} + +function urlClick(url) { + gURLBar.value = url; + gURLBar.focus(); + let goButton = document.getElementById("urlbar-go-button"); + EventUtils.synthesizeMouseAtCenter(goButton, {}); +} + +function promiseNewTabSwitched() { + return new Promise(resolve => { + gBrowser.addEventListener("TabSwitchDone", function onSwitch() { + gBrowser.removeEventListener("TabSwitchDone", onSwitch); + executeSoon(resolve); + }); + }); +} + +function* testURL(url, loadFunc, endFunc) { + let tabSwitchedPromise = promiseNewTabSwitched(); + let tab = gBrowser.selectedTab = gBrowser.addTab(); + let browser = gBrowser.selectedBrowser; + + let pageshowPromise = BrowserTestUtils.waitForContentEvent(browser, "pageshow"); + + yield tabSwitchedPromise; + yield pageshowPromise; + + let pagePrincipal = gBrowser.contentPrincipal; + loadFunc(url); + + yield BrowserTestUtils.waitForContentEvent(browser, "pageshow"); + + yield ContentTask.spawn(browser, { isRemote: gMultiProcessBrowser }, + function* (arg) { + const fm = Components.classes["@mozilla.org/focus-manager;1"]. + getService(Components.interfaces.nsIFocusManager); + Assert.equal(fm.focusedElement, null, "focusedElement not null"); + + if (arg.isRemote) { + Assert.equal(fm.activeWindow, content, "activeWindow not correct"); + } + }); + + is(document.activeElement, browser, "content window should be focused"); + + ok(!gBrowser.contentPrincipal.equals(pagePrincipal), + "load of " + url + " by " + loadFunc.name + " should produce a page with a different principal"); + + gBrowser.removeTab(tab); +} diff --git a/browser/base/content/test/urlbar/browser_moz_action_link.js b/browser/base/content/test/urlbar/browser_moz_action_link.js new file mode 100644 index 000000000..ed2d36ee5 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_moz_action_link.js @@ -0,0 +1,31 @@ +"use strict"; + +const kURIs = [ + "moz-action:foo,", + "moz-action:foo", +]; + +add_task(function*() { + for (let uri of kURIs) { + let dataURI = `data:text/html,<a id=a href="${uri}" target=_blank>Link</a>`; + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, dataURI); + + let tabSwitchPromise = BrowserTestUtils.switchTab(gBrowser, function() {}); + yield ContentTask.spawn(tab.linkedBrowser, null, function*() { + content.document.getElementById("a").click(); + }); + yield tabSwitchPromise; + isnot(gBrowser.selectedTab, tab, "Switched to new tab!"); + is(gURLBar.value, "about:blank", "URL bar should be displaying about:blank"); + let newTab = gBrowser.selectedTab; + yield BrowserTestUtils.switchTab(gBrowser, tab); + yield BrowserTestUtils.switchTab(gBrowser, newTab); + is(gBrowser.selectedTab, newTab, "Switched to new tab again!"); + is(gURLBar.value, "about:blank", "URL bar should be displaying about:blank after tab switch"); + // Finally, check that directly setting it produces the right results, too: + URLBarSetURI(makeURI(uri)); + is(gURLBar.value, "about:blank", "URL bar should still be displaying about:blank"); + yield BrowserTestUtils.removeTab(newTab); + yield BrowserTestUtils.removeTab(tab); + } +}); diff --git a/browser/base/content/test/urlbar/browser_removeUnsafeProtocolsFromURLBarPaste.js b/browser/base/content/test/urlbar/browser_removeUnsafeProtocolsFromURLBarPaste.js new file mode 100644 index 000000000..e9ba8d989 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_removeUnsafeProtocolsFromURLBarPaste.js @@ -0,0 +1,49 @@ +function test() { + waitForExplicitFinish(); + testNext(); +} + +var pairs = [ + ["javascript:", ""], + ["javascript:1+1", "1+1"], + ["javascript:document.domain", "document.domain"], + ["data:text/html,<body>hi</body>", "data:text/html,<body>hi</body>"], + // Nested things get confusing because some things don't parse as URIs: + ["javascript:javascript:alert('hi!')", "alert('hi!')"], + ["data:data:text/html,<body>hi</body>", "data:data:text/html,<body>hi</body>"], + ["javascript:data:javascript:alert('hi!')", "data:javascript:alert('hi!')"], + ["javascript:data:text/html,javascript:alert('hi!')", "data:text/html,javascript:alert('hi!')"], + ["data:data:text/html,javascript:alert('hi!')", "data:data:text/html,javascript:alert('hi!')"], +]; + +var clipboardHelper = Cc["@mozilla.org/widget/clipboardhelper;1"].getService(Ci.nsIClipboardHelper); + +function paste(input, cb) { + waitForClipboard(input, function() { + clipboardHelper.copyString(input); + }, function() { + document.commandDispatcher.getControllerForCommand("cmd_paste").doCommand("cmd_paste"); + cb(); + }, function() { + ok(false, "Failed to copy string '" + input + "' to clipboard"); + cb(); + }); +} + +function testNext() { + gURLBar.value = ''; + if (!pairs.length) { + finish(); + return; + } + + let [inputValue, expectedURL] = pairs.shift(); + + gURLBar.focus(); + paste(inputValue, function() { + is(gURLBar.textValue, expectedURL, "entering '" + inputValue + "' strips relevant bits."); + + setTimeout(testNext, 0); + }); +} + diff --git a/browser/base/content/test/urlbar/browser_search_favicon.js b/browser/base/content/test/urlbar/browser_search_favicon.js new file mode 100644 index 000000000..a8e6dbbcd --- /dev/null +++ b/browser/base/content/test/urlbar/browser_search_favicon.js @@ -0,0 +1,52 @@ +var gOriginalEngine; +var gEngine; +var gRestyleSearchesPref = "browser.urlbar.restyleSearches"; + +registerCleanupFunction(() => { + Services.prefs.clearUserPref(gRestyleSearchesPref); + Services.search.currentEngine = gOriginalEngine; + Services.search.removeEngine(gEngine); + return PlacesTestUtils.clearHistory(); +}); + +add_task(function*() { + Services.prefs.setBoolPref(gRestyleSearchesPref, true); +}); + +add_task(function*() { + + Services.search.addEngineWithDetails("SearchEngine", "", "", "", + "GET", "http://s.example.com/search"); + gEngine = Services.search.getEngineByName("SearchEngine"); + gEngine.addParam("q", "{searchTerms}", null); + gOriginalEngine = Services.search.currentEngine; + Services.search.currentEngine = gEngine; + + let uri = NetUtil.newURI("http://s.example.com/search?q=foo&client=1"); + yield PlacesTestUtils.addVisits({ uri: uri, title: "Foo - SearchEngine Search" }); + + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:mozilla"); + + // The first autocomplete result has the action searchengine, while + // the second result is the "search favicon" element. + yield promiseAutocompleteResultPopup("foo"); + let result = gURLBar.popup.richlistbox.children[1]; + + isnot(result, null, "Expect a search result"); + is(result.getAttribute("type"), "searchengine", "Expect correct `type` attribute"); + + let titleHbox = result._titleText.parentNode.parentNode; + ok(titleHbox.classList.contains("ac-title"), "Title hbox sanity check"); + is_element_visible(titleHbox, "Title element should be visible"); + + let urlHbox = result._urlText.parentNode.parentNode; + ok(urlHbox.classList.contains("ac-url"), "URL hbox sanity check"); + is_element_hidden(urlHbox, "URL element should be hidden"); + + let actionHbox = result._actionText.parentNode.parentNode; + ok(actionHbox.classList.contains("ac-action"), "Action hbox sanity check"); + is_element_hidden(actionHbox, "Action element should be hidden because it is not selected"); + is(result._actionText.textContent, "Search with SearchEngine", "Action text should be as expected"); + + gBrowser.removeCurrentTab(); +}); diff --git a/browser/base/content/test/urlbar/browser_tabMatchesInAwesomebar.js b/browser/base/content/test/urlbar/browser_tabMatchesInAwesomebar.js new file mode 100644 index 000000000..d207092d4 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_tabMatchesInAwesomebar.js @@ -0,0 +1,216 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- + * vim:set ts=2 sw=2 sts=2 et: + * 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/. */ + +requestLongerTimeout(2); + +const TEST_URL_BASES = [ + "http://example.org/browser/browser/base/content/test/urlbar/dummy_page.html#tabmatch", + "http://example.org/browser/browser/base/content/test/urlbar/moz.png#tabmatch" +]; + +var gController = Cc["@mozilla.org/autocomplete/controller;1"]. + getService(Ci.nsIAutoCompleteController); + +var gTabCounter = 0; + +add_task(function* step_1() { + info("Running step 1"); + let maxResults = Services.prefs.getIntPref("browser.urlbar.maxRichResults"); + let promises = []; + for (let i = 0; i < maxResults - 1; i++) { + let tab = gBrowser.addTab(); + promises.push(loadTab(tab, TEST_URL_BASES[0] + (++gTabCounter))); + } + + yield Promise.all(promises); + yield ensure_opentabs_match_db(); +}); + +add_task(function* step_2() { + info("Running step 2"); + gBrowser.selectTabAtIndex(1); + gBrowser.removeCurrentTab(); + gBrowser.selectTabAtIndex(1); + gBrowser.removeCurrentTab(); + + let promises = []; + for (let i = 1; i < gBrowser.tabs.length; i++) + promises.push(loadTab(gBrowser.tabs[i], TEST_URL_BASES[1] + (++gTabCounter))); + + yield Promise.all(promises); + yield ensure_opentabs_match_db(); +}); + +add_task(function* step_3() { + info("Running step 3"); + let promises = []; + for (let i = 1; i < gBrowser.tabs.length; i++) + promises.push(loadTab(gBrowser.tabs[i], TEST_URL_BASES[0] + gTabCounter)); + + yield Promise.all(promises); + yield ensure_opentabs_match_db(); +}); + +add_task(function* step_4() { + info("Running step 4 - ensure we don't register subframes as open pages"); + let tab = gBrowser.addTab(); + tab.linkedBrowser.loadURI('data:text/html,<body><iframe src=""></iframe></body>'); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + yield ContentTask.spawn(tab.linkedBrowser, null, function* () { + let iframe_loaded = ContentTaskUtils.waitForEvent(content.document, "load", true); + content.document.querySelector("iframe").src = "http://test2.example.org/"; + yield iframe_loaded; + }); + + yield ensure_opentabs_match_db(); +}); + +add_task(function* step_5() { + info("Running step 5 - remove tab immediately"); + let tab = gBrowser.addTab("about:logo"); + yield BrowserTestUtils.removeTab(tab); + yield ensure_opentabs_match_db(); +}); + +add_task(function* step_6() { + info("Running step 6 - check swapBrowsersAndCloseOther preserves registered switch-to-tab result"); + let tabToKeep = gBrowser.addTab(); + let tab = gBrowser.addTab(); + tab.linkedBrowser.loadURI("about:mozilla"); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + gBrowser.updateBrowserRemoteness(tabToKeep.linkedBrowser, tab.linkedBrowser.isRemoteBrowser); + gBrowser.swapBrowsersAndCloseOther(tabToKeep, tab); + + yield ensure_opentabs_match_db() + + yield BrowserTestUtils.removeTab(tabToKeep); + + yield ensure_opentabs_match_db(); +}); + +add_task(function* step_7() { + info("Running step 7 - close all tabs"); + + Services.prefs.clearUserPref("browser.sessionstore.restore_on_demand"); + + gBrowser.addTab("about:blank", {skipAnimation: true}); + while (gBrowser.tabs.length > 1) { + info("Removing tab: " + gBrowser.tabs[0].linkedBrowser.currentURI.spec); + gBrowser.selectTabAtIndex(0); + gBrowser.removeCurrentTab(); + } + + yield ensure_opentabs_match_db(); +}); + +add_task(function* cleanup() { + info("Cleaning up"); + + yield PlacesTestUtils.clearHistory(); +}); + +function loadTab(tab, url) { + // Because adding visits is async, we will not be notified immediately. + let loaded = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + let visited = new Promise(resolve => { + Services.obs.addObserver( + function observer(aSubject, aTopic, aData) { + if (url != aSubject.QueryInterface(Ci.nsIURI).spec) + return; + Services.obs.removeObserver(observer, aTopic); + resolve(); + }, + "uri-visit-saved", + false + ); + }); + + info("Loading page: " + url); + tab.linkedBrowser.loadURI(url); + return Promise.all([ loaded, visited ]); +} + +function ensure_opentabs_match_db() { + var tabs = {}; + + var winEnum = Services.wm.getEnumerator("navigator:browser"); + while (winEnum.hasMoreElements()) { + let browserWin = winEnum.getNext(); + // skip closed-but-not-destroyed windows + if (browserWin.closed) + continue; + + for (let i = 0; i < browserWin.gBrowser.tabContainer.childElementCount; i++) { + let browser = browserWin.gBrowser.getBrowserAtIndex(i); + let url = browser.currentURI.spec; + if (browserWin.isBlankPageURL(url)) + continue; + if (!(url in tabs)) + tabs[url] = 1; + else + tabs[url]++; + } + } + + return new Promise(resolve => { + checkAutocompleteResults(tabs, resolve); + }); +} + +function checkAutocompleteResults(aExpected, aCallback) +{ + gController.input = { + timeout: 10, + textValue: "", + searches: ["unifiedcomplete"], + searchParam: "enable-actions", + popupOpen: false, + minResultsForPopup: 0, + invalidate: function() {}, + disableAutoComplete: false, + completeDefaultIndex: false, + get popup() { return this; }, + onSearchBegin: function() {}, + onSearchComplete: function () + { + info("Found " + gController.matchCount + " matches."); + // Check to see the expected uris and titles match up (in any order) + for (let i = 0; i < gController.matchCount; i++) { + if (gController.getStyleAt(i).includes("heuristic")) { + info("Skip heuristic match"); + continue; + } + let action = gURLBar.popup.input._parseActionUrl(gController.getValueAt(i)); + let uri = action.params.url; + + info("Search for '" + uri + "' in open tabs."); + let expected = uri in aExpected; + ok(expected, uri + " was found in autocomplete, was " + (expected ? "" : "not ") + "expected"); + // Remove the found entry from expected results. + delete aExpected[uri]; + } + + // Make sure there is no reported open page that is not open. + for (let entry in aExpected) { + ok(false, "'" + entry + "' should be found in autocomplete"); + } + + executeSoon(aCallback); + }, + setSelectedIndex: function() {}, + get searchCount() { return this.searches.length; }, + getSearchAt: function(aIndex) { return this.searches[aIndex]; }, + QueryInterface: XPCOMUtils.generateQI([ + Ci.nsIAutoCompleteInput, + Ci.nsIAutoCompletePopup, + ]) + }; + + info("Searching open pages."); + gController.startSearch(Services.prefs.getCharPref("browser.urlbar.restrict.openpage")); +} diff --git a/browser/base/content/test/urlbar/browser_tabMatchesInAwesomebar_perwindowpb.js b/browser/base/content/test/urlbar/browser_tabMatchesInAwesomebar_perwindowpb.js new file mode 100644 index 000000000..08a18b38a --- /dev/null +++ b/browser/base/content/test/urlbar/browser_tabMatchesInAwesomebar_perwindowpb.js @@ -0,0 +1,84 @@ +let testURL = "http://example.org/browser/browser/base/content/test/urlbar/dummy_page.html"; + +add_task(function*() { + let normalWindow = yield BrowserTestUtils.openNewBrowserWindow(); + let privateWindow = yield BrowserTestUtils.openNewBrowserWindow({private: true}); + yield runTest(normalWindow, privateWindow, false); + yield BrowserTestUtils.closeWindow(normalWindow); + yield BrowserTestUtils.closeWindow(privateWindow); + + normalWindow = yield BrowserTestUtils.openNewBrowserWindow(); + privateWindow = yield BrowserTestUtils.openNewBrowserWindow({private: true}); + yield runTest(privateWindow, normalWindow, false); + yield BrowserTestUtils.closeWindow(normalWindow); + yield BrowserTestUtils.closeWindow(privateWindow); + + privateWindow = yield BrowserTestUtils.openNewBrowserWindow({private: true}); + yield runTest(privateWindow, privateWindow, false); + yield BrowserTestUtils.closeWindow(privateWindow); + + normalWindow = yield BrowserTestUtils.openNewBrowserWindow(); + yield runTest(normalWindow, normalWindow, true); + yield BrowserTestUtils.closeWindow(normalWindow); +}); + +function* runTest(aSourceWindow, aDestWindow, aExpectSwitch, aCallback) { + yield BrowserTestUtils.openNewForegroundTab(aSourceWindow.gBrowser, testURL); + let testTab = yield BrowserTestUtils.openNewForegroundTab(aDestWindow.gBrowser); + + info("waiting for focus on the window"); + yield SimpleTest.promiseFocus(aDestWindow); + info("got focus on the window"); + + // Select the testTab + aDestWindow.gBrowser.selectedTab = testTab; + + // Ensure that this tab has no history entries + let sessionHistoryCount = yield new Promise(resolve => { + SessionStore.getSessionHistory(gBrowser.selectedTab, function(sessionHistory) { + resolve(sessionHistory.entries.length); + }); + }); + + ok(sessionHistoryCount < 2, + `The test tab has 1 or fewer history entries. sessionHistoryCount=${sessionHistoryCount}`); + // Ensure that this tab is on about:blank + is(testTab.linkedBrowser.currentURI.spec, "about:blank", + "The test tab is on about:blank"); + // Ensure that this tab's document has no child nodes + yield ContentTask.spawn(testTab.linkedBrowser, null, function*() { + ok(!content.document.body.hasChildNodes(), + "The test tab has no child nodes"); + }); + ok(!testTab.hasAttribute("busy"), + "The test tab doesn't have the busy attribute"); + + // Wait for the Awesomebar popup to appear. + yield promiseAutocompleteResultPopup(testURL, aDestWindow); + + info(`awesomebar popup appeared. aExpectSwitch: ${aExpectSwitch}`); + // Make sure the last match is selected. + let {controller, popup} = aDestWindow.gURLBar; + while (popup.selectedIndex < controller.matchCount - 1) { + info("handling key navigation for DOM_VK_DOWN key"); + controller.handleKeyNavigation(KeyEvent.DOM_VK_DOWN); + } + + let awaitTabSwitch; + if (aExpectSwitch) { + awaitTabSwitch = BrowserTestUtils.removeTab(testTab, {dontRemove: true}) + } + + // Execute the selected action. + controller.handleEnter(true); + info("sent Enter command to the controller"); + + if (aExpectSwitch) { + // If we expect a tab switch then the current tab + // will be closed and we switch to the other tab. + yield awaitTabSwitch; + } else { + // If we don't expect a tab switch then wait for the tab to load. + yield BrowserTestUtils.browserLoaded(testTab.linkedBrowser); + } +} diff --git a/browser/base/content/test/urlbar/browser_urlHighlight.js b/browser/base/content/test/urlbar/browser_urlHighlight.js new file mode 100644 index 000000000..ba1537d91 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlHighlight.js @@ -0,0 +1,134 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +function testVal(aExpected) { + gURLBar.value = aExpected.replace(/[<>]/g, ""); + + let selectionController = gURLBar.editor.selectionController; + let selection = selectionController.getSelection(selectionController.SELECTION_URLSECONDARY); + let value = gURLBar.editor.rootElement.textContent; + let result = ""; + for (let i = 0; i < selection.rangeCount; i++) { + let range = selection.getRangeAt(i).toString(); + let pos = value.indexOf(range); + result += value.substring(0, pos) + "<" + range + ">"; + value = value.substring(pos + range.length); + } + result += value; + is(result, aExpected, + "Correct part of the urlbar contents is highlighted"); +} + +function test() { + const prefname = "browser.urlbar.formatting.enabled"; + + registerCleanupFunction(function () { + Services.prefs.clearUserPref(prefname); + URLBarSetURI(); + }); + + Services.prefs.setBoolPref(prefname, true); + + gURLBar.focus(); + + testVal("https://mozilla.org"); + + gBrowser.selectedBrowser.focus(); + + testVal("<https://>mozilla.org"); + testVal("<https://>mözilla.org"); + testVal("<https://>mozilla.imaginatory"); + + testVal("<https://www.>mozilla.org"); + testVal("<https://sub.>mozilla.org"); + testVal("<https://sub1.sub2.sub3.>mozilla.org"); + testVal("<www.>mozilla.org"); + testVal("<sub.>mozilla.org"); + testVal("<sub1.sub2.sub3.>mozilla.org"); + testVal("<mozilla.com.>mozilla.com"); + testVal("<https://mozilla.com:mozilla.com@>mozilla.com"); + testVal("<mozilla.com:mozilla.com@>mozilla.com"); + + testVal("<ftp.>mozilla.org"); + testVal("<ftp://ftp.>mozilla.org"); + + testVal("<https://sub.>mozilla.org"); + testVal("<https://sub1.sub2.sub3.>mozilla.org"); + testVal("<https://user:pass@sub1.sub2.sub3.>mozilla.org"); + testVal("<https://user:pass@>mozilla.org"); + testVal("<user:pass@sub1.sub2.sub3.>mozilla.org"); + testVal("<user:pass@>mozilla.org"); + + testVal("<https://>mozilla.org< >"); + testVal("mozilla.org< >"); + + testVal("<https://>mozilla.org</file.ext>"); + testVal("<https://>mozilla.org</sub/file.ext>"); + testVal("<https://>mozilla.org</sub/file.ext?foo>"); + testVal("<https://>mozilla.org</sub/file.ext?foo&bar>"); + testVal("<https://>mozilla.org</sub/file.ext?foo&bar#top>"); + testVal("<https://>mozilla.org</sub/file.ext?foo&bar#top>"); + testVal("foo.bar<?q=test>"); + testVal("foo.bar<#mozilla.org>"); + testVal("foo.bar<?somewhere.mozilla.org>"); + testVal("foo.bar<?@mozilla.org>"); + testVal("foo.bar<#x@mozilla.org>"); + testVal("foo.bar<#@x@mozilla.org>"); + testVal("foo.bar<?x@mozilla.org>"); + testVal("foo.bar<?@x@mozilla.org>"); + testVal("<foo.bar@x@>mozilla.org"); + testVal("<foo.bar@:baz@>mozilla.org"); + testVal("<foo.bar:@baz@>mozilla.org"); + testVal("<foo.bar@:ba:z@>mozilla.org"); + testVal("<foo.:bar:@baz@>mozilla.org"); + + testVal("<https://sub.>mozilla.org<:666/file.ext>"); + testVal("<sub.>mozilla.org<:666/file.ext>"); + testVal("localhost<:666/file.ext>"); + + let IPs = ["192.168.1.1", + "[::]", + "[::1]", + "[1::]", + "[::]", + "[::1]", + "[1::]", + "[1:2:3:4:5:6:7::]", + "[::1:2:3:4:5:6:7]", + "[1:2:a:B:c:D:e:F]", + "[1::8]", + "[1:2::8]", + "[fe80::222:19ff:fe11:8c76]", + "[0000:0123:4567:89AB:CDEF:abcd:ef00:0000]", + "[::192.168.1.1]", + "[1::0.0.0.0]", + "[1:2::255.255.255.255]", + "[1:2:3::255.255.255.255]", + "[1:2:3:4::255.255.255.255]", + "[1:2:3:4:5::255.255.255.255]", + "[1:2:3:4:5:6:255.255.255.255]"]; + IPs.forEach(function (IP) { + testVal(IP); + testVal(IP + "</file.ext>"); + testVal(IP + "<:666/file.ext>"); + testVal("<https://>" + IP); + testVal("<https://>" + IP + "</file.ext>"); + testVal("<https://user:pass@>" + IP + "<:666/file.ext>"); + testVal("<user:pass@>" + IP + "<:666/file.ext>"); + }); + + testVal("mailto:admin@mozilla.org"); + testVal("gopher://mozilla.org/"); + testVal("about:config"); + testVal("jar:http://mozilla.org/example.jar!/"); + testVal("view-source:http://mozilla.org/"); + testVal("foo9://mozilla.org/"); + testVal("foo+://mozilla.org/"); + testVal("foo.://mozilla.org/"); + testVal("foo-://mozilla.org/"); + + Services.prefs.setBoolPref(prefname, false); + + testVal("https://mozilla.org"); +} diff --git a/browser/base/content/test/urlbar/browser_urlbarAboutHomeLoading.js b/browser/base/content/test/urlbar/browser_urlbarAboutHomeLoading.js new file mode 100644 index 000000000..792826eb1 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarAboutHomeLoading.js @@ -0,0 +1,104 @@ +"use strict"; + +const {TabStateFlusher} = Cu.import("resource:///modules/sessionstore/TabStateFlusher.jsm", {}); + +/** + * Test what happens if loading a URL that should clear the + * location bar after a parent process URL. + */ +add_task(function* clearURLBarAfterParentProcessURL() { + let tab = yield new Promise(resolve => { + gBrowser.selectedTab = gBrowser.addTab("about:preferences"); + let newTabBrowser = gBrowser.getBrowserForTab(gBrowser.selectedTab); + newTabBrowser.addEventListener("Initialized", function onInit() { + newTabBrowser.removeEventListener("Initialized", onInit, true); + resolve(gBrowser.selectedTab); + }, true); + }); + document.getElementById("home-button").click(); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + is(gURLBar.value, "", "URL bar should be empty"); + is(tab.linkedBrowser.userTypedValue, null, "The browser should have no recorded userTypedValue"); + yield BrowserTestUtils.removeTab(tab); +}); + +/** + * Same as above, but open the tab without passing the URL immediately + * which changes behaviour in tabbrowser.xml. + */ +add_task(function* clearURLBarAfterParentProcessURLInExistingTab() { + let tab = yield new Promise(resolve => { + gBrowser.selectedTab = gBrowser.addTab(); + let newTabBrowser = gBrowser.getBrowserForTab(gBrowser.selectedTab); + newTabBrowser.addEventListener("Initialized", function onInit() { + newTabBrowser.removeEventListener("Initialized", onInit, true); + resolve(gBrowser.selectedTab); + }, true); + newTabBrowser.loadURI("about:preferences"); + }); + document.getElementById("home-button").click(); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + is(gURLBar.value, "", "URL bar should be empty"); + is(tab.linkedBrowser.userTypedValue, null, "The browser should have no recorded userTypedValue"); + yield BrowserTestUtils.removeTab(tab); +}); + +/** + * Load about:home directly from an about:newtab page. Because it is an + * 'initial' page, we need to treat this specially if the user actually + * loads a page like this from the URL bar. + */ +add_task(function* clearURLBarAfterManuallyLoadingAboutHome() { + let promiseTabOpenedAndSwitchedTo = BrowserTestUtils.switchTab(gBrowser, () => {}); + // This opens about:newtab: + BrowserOpenTab(); + let tab = yield promiseTabOpenedAndSwitchedTo; + is(gURLBar.value, "", "URL bar should be empty"); + is(tab.linkedBrowser.userTypedValue, null, "userTypedValue should be null"); + + gURLBar.value = "about:home"; + gURLBar.select(); + let aboutHomeLoaded = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser, false, "about:home"); + EventUtils.sendKey("return"); + yield aboutHomeLoaded; + + is(gURLBar.value, "", "URL bar should be empty"); + is(tab.linkedBrowser.userTypedValue, null, "userTypedValue should be null"); + yield BrowserTestUtils.removeTab(tab); +}); + +/** + * Ensure we don't show 'about:home' in the URL bar temporarily in new tabs + * while we're switching remoteness (when the URL we're loading and the + * default content principal are different). + */ +add_task(function* dontTemporarilyShowAboutHome() { + yield SpecialPowers.pushPrefEnv({set: [["browser.startup.page", 1]]}); + let windowOpenedPromise = BrowserTestUtils.waitForNewWindow(); + let win = OpenBrowserWindow(); + yield windowOpenedPromise; + let promiseTabSwitch = BrowserTestUtils.switchTab(win.gBrowser, () => {}); + win.BrowserOpenTab(); + yield promiseTabSwitch; + yield TabStateFlusher.flush(win.gBrowser.selectedBrowser); + yield BrowserTestUtils.closeWindow(win); + ok(SessionStore.getClosedWindowCount(), "Should have a closed window"); + + windowOpenedPromise = BrowserTestUtils.waitForNewWindow(); + win = SessionStore.undoCloseWindow(0); + yield windowOpenedPromise; + let wpl = { + onLocationChange(wpl, request, location, flags) { + is(win.gURLBar.value, "", "URL bar value should stay empty."); + }, + }; + win.gBrowser.addProgressListener(wpl); + let otherTab = win.gBrowser.selectedTab.previousSibling; + let tabLoaded = BrowserTestUtils.browserLoaded(otherTab.linkedBrowser, false, "about:home"); + yield BrowserTestUtils.switchTab(win.gBrowser, otherTab); + yield tabLoaded; + win.gBrowser.removeProgressListener(wpl); + is(win.gURLBar.value, "", "URL bar value should be empty."); + + yield BrowserTestUtils.closeWindow(win); +}); diff --git a/browser/base/content/test/urlbar/browser_urlbarAutoFillTrimURLs.js b/browser/base/content/test/urlbar/browser_urlbarAutoFillTrimURLs.js new file mode 100644 index 000000000..8101c101d --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarAutoFillTrimURLs.js @@ -0,0 +1,49 @@ +// This test ensures that autoFilled values are not trimmed, unless the user +// selects from the autocomplete popup. + +add_task(function* setup() { + const PREF_TRIMURL = "browser.urlbar.trimURLs"; + const PREF_AUTOFILL = "browser.urlbar.autoFill"; + + registerCleanupFunction(function* () { + Services.prefs.clearUserPref(PREF_TRIMURL); + Services.prefs.clearUserPref(PREF_AUTOFILL); + yield PlacesTestUtils.clearHistory(); + gURLBar.handleRevert(); + }); + Services.prefs.setBoolPref(PREF_TRIMURL, true); + Services.prefs.setBoolPref(PREF_AUTOFILL, true); + + // Adding a tab would hit switch-to-tab, so it's safer to just add a visit. + yield PlacesTestUtils.addVisits({ + uri: "http://www.autofilltrimurl.com/whatever", + transition: Ci.nsINavHistoryService.TRANSITION_TYPED, + }); +}); + +function* promiseSearch(searchtext) { + gURLBar.focus(); + gURLBar.inputField.value = searchtext.substr(0, searchtext.length -1); + EventUtils.synthesizeKey(searchtext.substr(-1, 1), {}); + yield promiseSearchComplete(); +} + +add_task(function* () { + yield promiseSearch("http://"); + is(gURLBar.inputField.value, "http://", "Autofilled value is as expected"); +}); + +add_task(function* () { + yield promiseSearch("http://au"); + is(gURLBar.inputField.value, "http://autofilltrimurl.com/", "Autofilled value is as expected"); +}); + +add_task(function* () { + yield promiseSearch("http://www.autofilltrimurl.com"); + is(gURLBar.inputField.value, "http://www.autofilltrimurl.com/", "Autofilled value is as expected"); + + // Now ensure selecting from the popup correctly trims. + is(gURLBar.controller.matchCount, 2, "Found the expected number of matches"); + EventUtils.synthesizeKey("VK_DOWN", {}); + is(gURLBar.inputField.value, "www.autofilltrimurl.com/whatever", "trim was applied correctly"); +}); diff --git a/browser/base/content/test/urlbar/browser_urlbarCopying.js b/browser/base/content/test/urlbar/browser_urlbarCopying.js new file mode 100644 index 000000000..8d5562b61 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarCopying.js @@ -0,0 +1,232 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +const trimPref = "browser.urlbar.trimURLs"; +const phishyUserPassPref = "network.http.phishy-userpass-length"; + +function toUnicode(input) { + let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"] + .createInstance(Ci.nsIScriptableUnicodeConverter); + converter.charset = "UTF-8"; + + return converter.ConvertToUnicode(input); +} + +function test() { + + let tab = gBrowser.selectedTab = gBrowser.addTab(); + + registerCleanupFunction(function () { + gBrowser.removeTab(tab); + Services.prefs.clearUserPref(trimPref); + Services.prefs.clearUserPref(phishyUserPassPref); + URLBarSetURI(); + }); + + Services.prefs.setBoolPref(trimPref, true); + Services.prefs.setIntPref(phishyUserPassPref, 32); // avoid prompting about phishing + + waitForExplicitFinish(); + + nextTest(); +} + +var tests = [ + // pageproxystate="invalid" + { + setURL: "http://example.com/", + expectedURL: "example.com", + copyExpected: "example.com" + }, + { + copyVal: "<e>xample.com", + copyExpected: "e" + }, + + // pageproxystate="valid" from this point on (due to the load) + { + loadURL: "http://example.com/", + expectedURL: "example.com", + copyExpected: "http://example.com/" + }, + { + copyVal: "<example.co>m", + copyExpected: "example.co" + }, + { + copyVal: "e<x>ample.com", + copyExpected: "x" + }, + { + copyVal: "<e>xample.com", + copyExpected: "e" + }, + + { + loadURL: "http://example.com/foo", + expectedURL: "example.com/foo", + copyExpected: "http://example.com/foo" + }, + { + copyVal: "<example.com>/foo", + copyExpected: "http://example.com" + }, + { + copyVal: "<example>.com/foo", + copyExpected: "example" + }, + + // Test that userPass is stripped out + { + loadURL: "http://user:pass@mochi.test:8888/browser/browser/base/content/test/urlbar/authenticate.sjs?user=user&pass=pass", + expectedURL: "mochi.test:8888/browser/browser/base/content/test/urlbar/authenticate.sjs?user=user&pass=pass", + copyExpected: "http://mochi.test:8888/browser/browser/base/content/test/urlbar/authenticate.sjs?user=user&pass=pass" + }, + + // Test escaping + { + loadURL: "http://example.com/()%28%29%C3%A9", + expectedURL: "example.com/()()\xe9", + copyExpected: "http://example.com/()%28%29%C3%A9" + }, + { + copyVal: "<example.com/(>)()\xe9", + copyExpected: "http://example.com/(" + }, + { + copyVal: "e<xample.com/(>)()\xe9", + copyExpected: "xample.com/(" + }, + + { + loadURL: "http://example.com/%C3%A9%C3%A9", + expectedURL: "example.com/\xe9\xe9", + copyExpected: "http://example.com/%C3%A9%C3%A9" + }, + { + copyVal: "e<xample.com/\xe9>\xe9", + copyExpected: "xample.com/\xe9" + }, + { + copyVal: "<example.com/\xe9>\xe9", + copyExpected: "http://example.com/\xe9" + }, + + { + loadURL: "http://example.com/?%C3%B7%C3%B7", + expectedURL: "example.com/?\xf7\xf7", + copyExpected: "http://example.com/?%C3%B7%C3%B7" + }, + { + copyVal: "e<xample.com/?\xf7>\xf7", + copyExpected: "xample.com/?\xf7" + }, + { + copyVal: "<example.com/?\xf7>\xf7", + copyExpected: "http://example.com/?\xf7" + }, + { + loadURL: "http://example.com/a%20test", + expectedURL: "example.com/a test", + copyExpected: "http://example.com/a%20test" + }, + { + loadURL: "http://example.com/a%E3%80%80test", + expectedURL: toUnicode("example.com/a test"), + copyExpected: "http://example.com/a%E3%80%80test" + }, + { + loadURL: "http://example.com/a%20%C2%A0test", + expectedURL: "example.com/a%20%C2%A0test", + copyExpected: "http://example.com/a%20%C2%A0test" + }, + { + loadURL: "http://example.com/%20%20%20", + expectedURL: "example.com/%20%20%20", + copyExpected: "http://example.com/%20%20%20" + }, + { + loadURL: "http://example.com/%E3%80%80%E3%80%80", + expectedURL: "example.com/%E3%80%80%E3%80%80", + copyExpected: "http://example.com/%E3%80%80%E3%80%80" + }, + + // data: and javsacript: URIs shouldn't be encoded + { + loadURL: "javascript:('%C3%A9%20%25%50')", + expectedURL: "javascript:('%C3%A9 %25P')", + copyExpected: "javascript:('%C3%A9 %25P')" + }, + { + copyVal: "<javascript:(>'%C3%A9 %25P')", + copyExpected: "javascript:(" + }, + + { + loadURL: "data:text/html,(%C3%A9%20%25%50)", + expectedURL: "data:text/html,(%C3%A9 %25P)", + copyExpected: "data:text/html,(%C3%A9 %25P)", + }, + { + copyVal: "<data:text/html,(>%C3%A9 %25P)", + copyExpected: "data:text/html,(" + }, + { + copyVal: "<data:text/html,(%C3%A9 %25P>)", + copyExpected: "data:text/html,(%C3%A9 %25P", + } +]; + +function nextTest() { + let test = tests.shift(); + if (tests.length == 0) + runTest(test, finish); + else + runTest(test, nextTest); +} + +function runTest(test, cb) { + function doCheck() { + if (test.setURL || test.loadURL) { + gURLBar.valueIsTyped = !!test.setURL; + is(gURLBar.textValue, test.expectedURL, "url bar value set"); + } + + testCopy(test.copyVal, test.copyExpected, cb); + } + + if (test.loadURL) { + loadURL(test.loadURL, doCheck); + } else { + if (test.setURL) + gURLBar.value = test.setURL; + doCheck(); + } +} + +function testCopy(copyVal, targetValue, cb) { + info("Expecting copy of: " + targetValue); + waitForClipboard(targetValue, function () { + gURLBar.focus(); + if (copyVal) { + let startBracket = copyVal.indexOf("<"); + let endBracket = copyVal.indexOf(">"); + if (startBracket == -1 || endBracket == -1 || + startBracket > endBracket || + copyVal.replace("<", "").replace(">", "") != gURLBar.textValue) { + ok(false, "invalid copyVal: " + copyVal); + } + gURLBar.selectionStart = startBracket; + gURLBar.selectionEnd = endBracket - 1; + } else { + gURLBar.select(); + } + + goDoCommand("cmd_copy"); + }, cb, cb); +} + +function loadURL(aURL, aCB) { + BrowserTestUtils.loadURI(gBrowser.selectedBrowser, aURL); + BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser, false, aURL).then(aCB); +} diff --git a/browser/base/content/test/urlbar/browser_urlbarDecode.js b/browser/base/content/test/urlbar/browser_urlbarDecode.js new file mode 100644 index 000000000..6a2c421ef --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarDecode.js @@ -0,0 +1,97 @@ +"use strict"; + +// This test makes sure (1) you can't break the urlbar by typing particular JSON +// or JS fragments into it, (2) urlbar.textValue shows URLs unescaped, and (3) +// the urlbar also shows the URLs embedded in action URIs unescaped. See bug +// 1233672. + +add_task(function* injectJSON() { + let inputStrs = [ + 'http://example.com/ ", "url": "bar', + 'http://example.com/\\', + 'http://example.com/"', + 'http://example.com/","url":"evil.com', + 'http://mozilla.org/\\u0020', + 'http://www.mozilla.org/","url":1e6,"some-key":"foo', + 'http://www.mozilla.org/","url":null,"some-key":"foo', + 'http://www.mozilla.org/","url":["foo","bar"],"some-key":"foo', + ]; + for (let inputStr of inputStrs) { + yield checkInput(inputStr); + } + gURLBar.value = ""; + gURLBar.handleRevert(); + gURLBar.blur(); +}); + +add_task(function losslessDecode() { + let urlNoScheme = "example.com/\u30a2\u30a4\u30a6\u30a8\u30aa"; + let url = "http://" + urlNoScheme; + gURLBar.textValue = url; + // Since this is directly setting textValue, it is expected to be trimmed. + Assert.equal(gURLBar.inputField.value, urlNoScheme, + "The string displayed in the textbox should not be escaped"); + gURLBar.value = ""; + gURLBar.handleRevert(); + gURLBar.blur(); +}); + +add_task(function* actionURILosslessDecode() { + let urlNoScheme = "example.com/\u30a2\u30a4\u30a6\u30a8\u30aa"; + let url = "http://" + urlNoScheme; + yield promiseAutocompleteResultPopup(url); + + // At this point the heuristic result is selected but the urlbar's value is + // simply `url`. Key down and back around until the heuristic result is + // selected again, and at that point the urlbar's value should be a visiturl + // moz-action. + + do { + gURLBar.controller.handleKeyNavigation(KeyEvent.DOM_VK_DOWN); + } while (gURLBar.popup.selectedIndex != 0); + + let [, type, ] = gURLBar.value.match(/^moz-action:([^,]+),(.*)$/); + Assert.equal(type, "visiturl", + "visiturl action URI should be in the urlbar"); + + Assert.equal(gURLBar.inputField.value, urlNoScheme, + "The string displayed in the textbox should not be escaped"); + + gURLBar.value = ""; + gURLBar.handleRevert(); + gURLBar.blur(); +}); + +function* checkInput(inputStr) { + yield promiseAutocompleteResultPopup(inputStr); + + let item = gURLBar.popup.richlistbox.firstChild; + Assert.ok(item, "Should have a result"); + + // visiturl matches have their param.urls fixed up. + let fixupInfo = Services.uriFixup.getFixupURIInfo(inputStr, + Ci.nsIURIFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS | + Ci.nsIURIFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP + ); + let expectedVisitURL = fixupInfo.fixedURI.spec; + + let type = "visiturl"; + let params = { + url: expectedVisitURL, + input: inputStr, + }; + for (let key in params) { + params[key] = encodeURIComponent(params[key]); + } + let expectedURL = "moz-action:" + type + "," + JSON.stringify(params); + Assert.equal(item.getAttribute("url"), expectedURL, "url"); + + Assert.equal(item.getAttribute("title"), inputStr.replace("\\", "/"), "title"); + Assert.equal(item.getAttribute("text"), inputStr, "text"); + + let itemType = item.getAttribute("type"); + Assert.equal(itemType, "visiturl"); + + Assert.equal(item._titleText.textContent, inputStr.replace("\\", "/"), "Visible title"); + Assert.equal(item._actionText.textContent, "Visit", "Visible action"); +} diff --git a/browser/base/content/test/urlbar/browser_urlbarDelete.js b/browser/base/content/test/urlbar/browser_urlbarDelete.js new file mode 100644 index 000000000..d4eb6c856 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarDelete.js @@ -0,0 +1,39 @@ +add_task(function*() { + let bm = yield PlacesUtils.bookmarks.insert({ parentGuid: PlacesUtils.bookmarks.unfiledGuid, + url: "http://bug1105244.example.com/", + title: "test" }); + + registerCleanupFunction(function* () { + yield PlacesUtils.bookmarks.remove(bm); + }); + + yield BrowserTestUtils.withNewTab({ gBrowser, url: "about:blank" }, testDelete); +}); + +function sendHome() { + // unclear why VK_HOME doesn't work on Mac, but it doesn't... + if (Services.appinfo.OS == "Darwin") { + EventUtils.synthesizeKey("VK_LEFT", { altKey: true }); + } else { + EventUtils.synthesizeKey("VK_HOME", {}); + } +} + +function sendDelete() { + EventUtils.synthesizeKey("VK_DELETE", {}); +} + +function* testDelete() { + yield promiseAutocompleteResultPopup("bug1105244"); + + // move to the start. + sendHome(); + // delete the first few chars - each delete should operate on the input field. + sendDelete(); + Assert.equal(gURLBar.inputField.value, "ug1105244"); + + yield promisePopupShown(gURLBar.popup); + + sendDelete(); + Assert.equal(gURLBar.inputField.value, "g1105244"); +} diff --git a/browser/base/content/test/urlbar/browser_urlbarEnter.js b/browser/base/content/test/urlbar/browser_urlbarEnter.js new file mode 100644 index 000000000..32cbaf2be --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarEnter.js @@ -0,0 +1,45 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const TEST_VALUE = "example.com/\xF7?\xF7"; +const START_VALUE = "example.com/%C3%B7?%C3%B7"; + +add_task(function* () { + info("Simple return keypress"); + let tab = gBrowser.selectedTab = gBrowser.addTab(START_VALUE); + + gURLBar.focus(); + EventUtils.synthesizeKey("VK_RETURN", {}); + yield BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + + // Check url bar and selected tab. + is(gURLBar.textValue, TEST_VALUE, "Urlbar should preserve the value on return keypress"); + is(gBrowser.selectedTab, tab, "New URL was loaded in the current tab"); + + // Cleanup. + yield BrowserTestUtils.removeTab(gBrowser.selectedTab); +}); + +add_task(function* () { + info("Alt+Return keypress"); + // due to bug 691608, we must wait for the load event, else isTabEmpty() will + // return true on e10s for this tab, so it will be reused even with altKey. + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, START_VALUE); + + let tabOpenPromise = BrowserTestUtils.waitForEvent(gBrowser.tabContainer, "TabOpen"); + gURLBar.focus(); + EventUtils.synthesizeKey("VK_RETURN", {altKey: true}); + + // wait for the new tab to appear. + yield tabOpenPromise; + + // Check url bar and selected tab. + is(gURLBar.textValue, TEST_VALUE, "Urlbar should preserve the value on return keypress"); + isnot(gBrowser.selectedTab, tab, "New URL was loaded in a new tab"); + + // Cleanup. + yield BrowserTestUtils.removeTab(tab); + yield BrowserTestUtils.removeTab(gBrowser.selectedTab); +}); diff --git a/browser/base/content/test/urlbar/browser_urlbarEnterAfterMouseOver.js b/browser/base/content/test/urlbar/browser_urlbarEnterAfterMouseOver.js new file mode 100644 index 000000000..22e336f91 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarEnterAfterMouseOver.js @@ -0,0 +1,69 @@ +function repeat(limit, func) { + for (let i = 0; i < limit; i++) { + func(i); + } +} + +function* promiseAutoComplete(inputText) { + gURLBar.focus(); + gURLBar.value = inputText.slice(0, -1); + EventUtils.synthesizeKey(inputText.slice(-1), {}); + yield promiseSearchComplete(); +} + +function is_selected(index) { + is(gURLBar.popup.richlistbox.selectedIndex, index, `Item ${index + 1} should be selected`); +} + +let gMaxResults; + +add_task(function*() { + registerCleanupFunction(function* () { + yield PlacesTestUtils.clearHistory(); + }); + + yield PlacesTestUtils.clearHistory(); + + gMaxResults = Services.prefs.getIntPref("browser.urlbar.maxRichResults"); + + let visits = []; + repeat(gMaxResults, i => { + visits.push({ + uri: makeURI("http://example.com/autocomplete/?" + i), + }); + }); + yield PlacesTestUtils.addVisits(visits); + + gBrowser.selectedTab = gBrowser.addTab("about:blank"); + yield promiseAutoComplete("http://example.com/autocomplete/"); + + let popup = gURLBar.popup; + let results = popup.richlistbox.children; + is(results.length, gMaxResults, + "Should get gMaxResults=" + gMaxResults + " results"); + + let initiallySelected = gURLBar.popup.richlistbox.selectedIndex; + + info("Key Down to select the next item"); + EventUtils.synthesizeKey("VK_DOWN", {}); + is_selected(initiallySelected + 1); + let expectedURL = gURLBar.controller.getFinalCompleteValueAt(initiallySelected + 1); + + is(gURLBar.value, gURLBar.controller.getValueAt(initiallySelected + 1), + "Value in the URL bar should be updated by keyboard selection"); + + // Verify that what we're about to do changes the selectedIndex: + isnot(initiallySelected + 1, 3, "Shouldn't be changing the selectedIndex to the same index we keyboard-selected."); + + // Would love to use a synthetic mousemove event here, but that doesn't seem to do anything. + // EventUtils.synthesizeMouseAtCenter(results[3], {type: "mousemove"}); + gURLBar.popup.richlistbox.selectedIndex = 3; + is_selected(3); + + let autocompletePopupHidden = promisePopupHidden(gURLBar.popup); + let openedExpectedPage = waitForDocLoadAndStopIt(expectedURL); + EventUtils.synthesizeKey("VK_RETURN", {}); + yield Promise.all([autocompletePopupHidden, openedExpectedPage]); + + gBrowser.removeCurrentTab(); +}); diff --git a/browser/base/content/test/urlbar/browser_urlbarFocusedCmdK.js b/browser/base/content/test/urlbar/browser_urlbarFocusedCmdK.js new file mode 100644 index 000000000..8c9e2c9f2 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarFocusedCmdK.js @@ -0,0 +1,17 @@ +/* Any copyright is dedicated to the Public Domain. +* http://creativecommons.org/publicdomain/zero/1.0/ */ + +add_task(function*() { + // Remove the search bar from toolbar + CustomizableUI.removeWidgetFromArea("search-container"); + + // Test that Ctrl/Cmd + K will focus the url bar + let focusPromise = BrowserTestUtils.waitForEvent(gURLBar, "focus"); + EventUtils.synthesizeKey("k", { accelKey: true }); + yield focusPromise; + Assert.equal(document.activeElement, gURLBar.inputField, "URL Bar should be focused"); + + // Reset changes made to toolbar + CustomizableUI.reset(); +}); + diff --git a/browser/base/content/test/urlbar/browser_urlbarHashChangeProxyState.js b/browser/base/content/test/urlbar/browser_urlbarHashChangeProxyState.js new file mode 100644 index 000000000..152106dad --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarHashChangeProxyState.js @@ -0,0 +1,111 @@ +"use strict"; + +/** + * Check that navigating through both the URL bar and using in-page hash- or ref- + * based links and back or forward navigation updates the URL bar and identity block correctly. + */ +add_task(function* () { + let baseURL = "https://example.org/browser/browser/base/content/test/urlbar/dummy_page.html"; + let url = baseURL + "#foo"; + yield BrowserTestUtils.withNewTab({ gBrowser, url }, function*(browser) { + let identityBox = document.getElementById("identity-box"); + let expectedURL = url; + + let verifyURLBarState = testType => { + is(gURLBar.textValue, expectedURL, "URL bar visible value should be correct " + testType); + is(gURLBar.value, expectedURL, "URL bar value should be correct " + testType); + ok(identityBox.classList.contains("verifiedDomain"), "Identity box should know we're doing SSL " + testType); + is(gURLBar.getAttribute("pageproxystate"), "valid", "URL bar is in valid page proxy state"); + }; + + verifyURLBarState("at the beginning"); + + let locationChangePromise; + let resolveLocationChangePromise; + let expectURL = url => { + expectedURL = url; + locationChangePromise = new Promise(r => resolveLocationChangePromise = r); + }; + let wpl = { + onLocationChange(wpl, request, location, flags) { + is(location.spec, expectedURL, "Got the expected URL"); + resolveLocationChangePromise(); + }, + }; + gBrowser.addProgressListener(wpl); + + expectURL(baseURL + "#foo"); + gURLBar.select(); + EventUtils.sendKey("return"); + + yield locationChangePromise; + verifyURLBarState("after hitting enter on the same URL a second time"); + + expectURL(baseURL + "#bar"); + gURLBar.value = expectedURL; + gURLBar.select(); + EventUtils.sendKey("return"); + + yield locationChangePromise; + verifyURLBarState("after a URL bar hash navigation"); + + expectURL(baseURL + "#foo"); + yield ContentTask.spawn(browser, null, function() { + let a = content.document.createElement("a"); + a.href = "#foo"; + a.textContent = "Foo Link"; + content.document.body.appendChild(a); + a.click(); + }); + + yield locationChangePromise; + verifyURLBarState("after a page link hash navigation"); + + expectURL(baseURL + "#bar"); + gBrowser.goBack(); + + yield locationChangePromise; + verifyURLBarState("after going back"); + + expectURL(baseURL + "#foo"); + gBrowser.goForward(); + + yield locationChangePromise; + verifyURLBarState("after going forward"); + + expectURL(baseURL + "#foo"); + gURLBar.select(); + EventUtils.sendKey("return"); + + yield locationChangePromise; + verifyURLBarState("after hitting enter on the same URL"); + + gBrowser.removeProgressListener(wpl); + }); +}); + +/** + * Check that initial secure loads that swap remoteness + * get the correct page icon when finished. + */ +add_task(function* () { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:newtab", false); + // NB: CPOW usage because new tab pages can be preloaded, in which case no + // load events fire. + yield BrowserTestUtils.waitForCondition(() => !tab.linkedBrowser.contentDocument.hidden) + let url = "https://example.org/browser/browser/base/content/test/urlbar/dummy_page.html#foo"; + gURLBar.value = url; + gURLBar.select(); + EventUtils.sendKey("return"); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + is(gURLBar.textValue, url, "URL bar visible value should be correct when the page loads from about:newtab"); + is(gURLBar.value, url, "URL bar value should be correct when the page loads from about:newtab"); + let identityBox = document.getElementById("identity-box"); + ok(identityBox.classList.contains("verifiedDomain"), + "Identity box should know we're doing SSL when the page loads from about:newtab"); + is(gURLBar.getAttribute("pageproxystate"), "valid", + "URL bar is in valid page proxy state when SSL page with hash loads from about:newtab"); + yield BrowserTestUtils.removeTab(tab); +}); + diff --git a/browser/base/content/test/urlbar/browser_urlbarKeepStateAcrossTabSwitches.js b/browser/base/content/test/urlbar/browser_urlbarKeepStateAcrossTabSwitches.js new file mode 100644 index 000000000..9c8996059 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarKeepStateAcrossTabSwitches.js @@ -0,0 +1,49 @@ +"use strict"; + +/** + * Verify user typed text remains in the URL bar when tab switching, even when + * loads fail. + */ +add_task(function* () { + let input = "i-definitely-dont-exist.example.com"; + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:newtab", false); + // NB: CPOW usage because new tab pages can be preloaded, in which case no + // load events fire. + yield BrowserTestUtils.waitForCondition(() => !tab.linkedBrowser.contentDocument.hidden) + let errorPageLoaded = BrowserTestUtils.waitForErrorPage(tab.linkedBrowser); + gURLBar.value = input; + gURLBar.select(); + EventUtils.sendKey("return"); + yield errorPageLoaded; + is(gURLBar.textValue, input, "Text is still in URL bar"); + yield BrowserTestUtils.switchTab(gBrowser, tab.previousSibling); + yield BrowserTestUtils.switchTab(gBrowser, tab); + is(gURLBar.textValue, input, "Text is still in URL bar after tab switch"); + yield BrowserTestUtils.removeTab(tab); +}); + +/** + * Invalid URIs fail differently (that is, immediately, in the loadURI call) + * if keyword searches are turned off. Test that this works, too. + */ +add_task(function* () { + let input = "To be or not to be-that is the question"; + yield new Promise(resolve => SpecialPowers.pushPrefEnv({set: [["keyword.enabled", false]]}, resolve)); + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:newtab", false); + // NB: CPOW usage because new tab pages can be preloaded, in which case no + // load events fire. + yield BrowserTestUtils.waitForCondition(() => !tab.linkedBrowser.contentDocument.hidden) + let errorPageLoaded = BrowserTestUtils.waitForErrorPage(tab.linkedBrowser); + gURLBar.value = input; + gURLBar.select(); + EventUtils.sendKey("return"); + yield errorPageLoaded; + is(gURLBar.textValue, input, "Text is still in URL bar"); + is(tab.linkedBrowser.userTypedValue, input, "Text still stored on browser"); + yield BrowserTestUtils.switchTab(gBrowser, tab.previousSibling); + yield BrowserTestUtils.switchTab(gBrowser, tab); + is(gURLBar.textValue, input, "Text is still in URL bar after tab switch"); + is(tab.linkedBrowser.userTypedValue, input, "Text still stored on browser"); + yield BrowserTestUtils.removeTab(tab); +}); + diff --git a/browser/base/content/test/urlbar/browser_urlbarOneOffs.js b/browser/base/content/test/urlbar/browser_urlbarOneOffs.js new file mode 100644 index 000000000..1f58b8edd --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarOneOffs.js @@ -0,0 +1,232 @@ +const TEST_ENGINE_BASENAME = "searchSuggestionEngine.xml"; + +let gMaxResults; + +add_task(function* init() { + Services.prefs.setBoolPref("browser.urlbar.oneOffSearches", true); + gMaxResults = Services.prefs.getIntPref("browser.urlbar.maxRichResults"); + + // Add a search suggestion engine and move it to the front so that it appears + // as the first one-off. + let engine = yield promiseNewSearchEngine(TEST_ENGINE_BASENAME); + Services.search.moveEngine(engine, 0); + + registerCleanupFunction(function* () { + yield hidePopup(); + yield PlacesTestUtils.clearHistory(); + }); + + yield PlacesTestUtils.clearHistory(); + + let visits = []; + for (let i = 0; i < gMaxResults; i++) { + visits.push({ + uri: makeURI("http://example.com/browser_urlbarOneOffs.js/?" + i), + // TYPED so that the visit shows up when the urlbar's drop-down arrow is + // pressed. + transition: Ci.nsINavHistoryService.TRANSITION_TYPED, + }); + } + yield PlacesTestUtils.addVisits(visits); +}); + +// Keys up and down through the history panel, i.e., the panel that's shown when +// there's no text in the textbox. +add_task(function* history() { + gURLBar.focus(); + EventUtils.synthesizeKey("VK_DOWN", {}) + yield promisePopupShown(gURLBar.popup); + + assertState(-1, -1, ""); + + // Key down through each result. + for (let i = 0; i < gMaxResults; i++) { + EventUtils.synthesizeKey("VK_DOWN", {}) + assertState(i, -1, + "example.com/browser_urlbarOneOffs.js/?" + (gMaxResults - i - 1)); + } + + // Key down through each one-off. + let numButtons = + gURLBar.popup.oneOffSearchButtons.getSelectableButtons(true).length; + for (let i = 0; i < numButtons; i++) { + EventUtils.synthesizeKey("VK_DOWN", {}) + assertState(-1, i, ""); + } + + // Key down once more. Nothing should be selected. + EventUtils.synthesizeKey("VK_DOWN", {}) + assertState(-1, -1, ""); + + // Once more. The first result should be selected. + EventUtils.synthesizeKey("VK_DOWN", {}) + assertState(0, -1, + "example.com/browser_urlbarOneOffs.js/?" + (gMaxResults - 1)); + + // Now key up. Nothing should be selected again. + EventUtils.synthesizeKey("VK_UP", {}) + assertState(-1, -1, ""); + + // Key up through each one-off. + for (let i = numButtons - 1; i >= 0; i--) { + EventUtils.synthesizeKey("VK_UP", {}) + assertState(-1, i, ""); + } + + // Key up through each result. + for (let i = gMaxResults - 1; i >= 0; i--) { + EventUtils.synthesizeKey("VK_UP", {}) + assertState(i, -1, + "example.com/browser_urlbarOneOffs.js/?" + (gMaxResults - i - 1)); + } + + // Key up once more. Nothing should be selected. + EventUtils.synthesizeKey("VK_UP", {}) + assertState(-1, -1, ""); + + yield hidePopup(); +}); + +// Keys up and down through the non-history panel, i.e., the panel that's shown +// when you type something in the textbox. +add_task(function* typedValue() { + // Use a typed value that returns the visits added above but that doesn't + // trigger autofill since that would complicate the test. + let typedValue = "browser_urlbarOneOffs"; + yield promiseAutocompleteResultPopup(typedValue, window, true); + + assertState(0, -1, typedValue); + + // Key down through each result. The first result is already selected, which + // is why gMaxResults - 1 is the correct number of times to do this. + for (let i = 0; i < gMaxResults - 1; i++) { + EventUtils.synthesizeKey("VK_DOWN", {}) + // i starts at zero so that the textValue passed to assertState is correct. + // But that means that i + 1 is the expected selected index, since initially + // (when this loop starts) the first result is selected. + assertState(i + 1, -1, + "example.com/browser_urlbarOneOffs.js/?" + (gMaxResults - i - 1)); + } + + // Key down through each one-off. + let numButtons = + gURLBar.popup.oneOffSearchButtons.getSelectableButtons(true).length; + for (let i = 0; i < numButtons; i++) { + EventUtils.synthesizeKey("VK_DOWN", {}) + assertState(-1, i, typedValue); + } + + // Key down once more. The selection should wrap around to the first result. + EventUtils.synthesizeKey("VK_DOWN", {}) + assertState(0, -1, typedValue); + + // Now key up. The selection should wrap back around to the one-offs. Key + // up through all the one-offs. + for (let i = numButtons - 1; i >= 0; i--) { + EventUtils.synthesizeKey("VK_UP", {}) + assertState(-1, i, typedValue); + } + + // Key up through each non-heuristic result. + for (let i = gMaxResults - 2; i >= 0; i--) { + EventUtils.synthesizeKey("VK_UP", {}) + assertState(i + 1, -1, + "example.com/browser_urlbarOneOffs.js/?" + (gMaxResults - i - 1)); + } + + // Key up once more. The heuristic result should be selected. + EventUtils.synthesizeKey("VK_UP", {}) + assertState(0, -1, typedValue); + + yield hidePopup(); +}); + +// Checks that "Search with Current Search Engine" items are updated to "Search +// with One-Off Engine" when a one-off is selected. +add_task(function* searchWith() { + let typedValue = "foo"; + yield promiseAutocompleteResultPopup(typedValue); + + assertState(0, -1, typedValue); + + let item = gURLBar.popup.richlistbox.firstChild; + Assert.equal(item._actionText.textContent, + "Search with " + Services.search.currentEngine.name, + "Sanity check: first result's action text"); + + // Alt+Down to the first one-off. Now the first result and the first one-off + // should both be selected. + EventUtils.synthesizeKey("VK_DOWN", { altKey: true }) + assertState(0, 0, typedValue); + + let engineName = gURLBar.popup.oneOffSearchButtons.selectedButton.engine.name; + Assert.notEqual(engineName, Services.search.currentEngine.name, + "Sanity check: First one-off engine should not be " + + "the current engine"); + Assert.equal(item._actionText.textContent, + "Search with " + engineName, + "First result's action text should be updated"); + + yield hidePopup(); +}); + +// Clicks a one-off. +add_task(function* oneOffClick() { + gBrowser.selectedTab = gBrowser.addTab(); + + // We are explicitly using something that looks like a url, to make the test + // stricter. Even if it looks like a url, we should search. + let typedValue = "foo.bar"; + yield promiseAutocompleteResultPopup(typedValue); + + assertState(0, -1, typedValue); + + let oneOffs = gURLBar.popup.oneOffSearchButtons.getSelectableButtons(true); + let resultsPromise = + BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser, false, + "http://mochi.test:8888/"); + EventUtils.synthesizeMouseAtCenter(oneOffs[0], {}); + yield resultsPromise; + + gBrowser.removeTab(gBrowser.selectedTab); +}); + +// Presses the Return key when a one-off is selected. +add_task(function* oneOffReturn() { + gBrowser.selectedTab = gBrowser.addTab(); + + // We are explicitly using something that looks like a url, to make the test + // stricter. Even if it looks like a url, we should search. + let typedValue = "foo.bar"; + yield promiseAutocompleteResultPopup(typedValue, window, true); + + assertState(0, -1, typedValue); + + // Alt+Down to select the first one-off. + EventUtils.synthesizeKey("VK_DOWN", { altKey: true }) + assertState(0, 0, typedValue); + + let resultsPromise = + BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser, false, + "http://mochi.test:8888/"); + EventUtils.synthesizeKey("VK_RETURN", {}) + yield resultsPromise; + + gBrowser.removeTab(gBrowser.selectedTab); +}); + + +function assertState(result, oneOff, textValue = undefined) { + Assert.equal(gURLBar.popup.selectedIndex, result, + "Expected result should be selected"); + Assert.equal(gURLBar.popup.oneOffSearchButtons.selectedButtonIndex, oneOff, + "Expected one-off should be selected"); + if (textValue !== undefined) { + Assert.equal(gURLBar.textValue, textValue, "Expected textValue"); + } +} + +function* hidePopup() { + EventUtils.synthesizeKey("VK_ESCAPE", {}); + yield promisePopupHidden(gURLBar.popup); +} diff --git a/browser/base/content/test/urlbar/browser_urlbarPrivateBrowsingWindowChange.js b/browser/base/content/test/urlbar/browser_urlbarPrivateBrowsingWindowChange.js new file mode 100644 index 000000000..5db0f0ea6 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarPrivateBrowsingWindowChange.js @@ -0,0 +1,41 @@ +"use strict"; + +/** + * Test that when opening a private browsing window and typing in it before about:privatebrowsing + * loads, we don't clear the URL bar. + */ +add_task(function*() { + let urlbarTestValue = "Mary had a little lamb"; + let win = OpenBrowserWindow({private: true}); + yield BrowserTestUtils.waitForEvent(win, "load"); + let urlbar = win.document.getElementById("urlbar"); + urlbar.value = urlbarTestValue; + // Need this so the autocomplete controller attaches: + let focusEv = new FocusEvent("focus", {}); + urlbar.dispatchEvent(focusEv); + // And so we know input happened: + let inputEv = new InputEvent("input", {data: "", view: win, bubbles: true}); + urlbar.onInput(inputEv); + // Check it worked: + is(urlbar.value, urlbarTestValue, "URL bar value should be there"); + is(win.gBrowser.selectedBrowser.userTypedValue, urlbarTestValue, "browser object should know the url bar value"); + + let continueTest; + let continuePromise = new Promise(resolve => continueTest = resolve); + let wpl = { + onLocationChange(aWebProgress, aRequest, aLocation) { + if (aLocation && aLocation.spec == "about:privatebrowsing") { + continueTest(); + } + }, + }; + win.gBrowser.addProgressListener(wpl); + + yield continuePromise; + is(urlbar.value, urlbarTestValue, + "URL bar value should be the same once about:privatebrowsing has loaded"); + is(win.gBrowser.selectedBrowser.userTypedValue, urlbarTestValue, + "browser object should still know url bar value once about:privatebrowsing has loaded"); + win.gBrowser.removeProgressListener(wpl); + yield BrowserTestUtils.closeWindow(win); +}); diff --git a/browser/base/content/test/urlbar/browser_urlbarRaceWithTabs.js b/browser/base/content/test/urlbar/browser_urlbarRaceWithTabs.js new file mode 100644 index 000000000..d66514c5a --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarRaceWithTabs.js @@ -0,0 +1,57 @@ +const kURL = "http://example.org/browser/browser/base/content/test/urlbar/dummy_page.html"; + +function* addBookmark(bookmark) { + if (bookmark.keyword) { + yield PlacesUtils.keywords.insert({ + keyword: bookmark.keyword, + url: bookmark.url, + }); + } + + let bm = yield PlacesUtils.bookmarks.insert({ + parentGuid: PlacesUtils.bookmarks.unfiledGuid, + url: bookmark.url, + title: bookmark.title, + }); + + registerCleanupFunction(function* () { + yield PlacesUtils.bookmarks.remove(bm); + if (bookmark.keyword) { + yield PlacesUtils.keywords.remove(bookmark.keyword); + } + }); +} + +/** + * Check that if the user hits enter and ctrl-t at the same time, we open the URL in the right tab. + */ +add_task(function* hitEnterLoadInRightTab() { + info("Opening new tab"); + let oldTabCreatedPromise = BrowserTestUtils.waitForEvent(gBrowser.tabContainer, "TabOpen"); + BrowserOpenTab(); + let oldTab = (yield oldTabCreatedPromise).target; + let oldTabLoadedPromise = BrowserTestUtils.browserLoaded(oldTab.linkedBrowser, false, kURL); + oldTabLoadedPromise.then(() => info("Old tab loaded")); + let newTabCreatedPromise = BrowserTestUtils.waitForEvent(gBrowser.tabContainer, "TabOpen"); + + info("Creating bookmark and keyword"); + yield addBookmark({title: "Test for keyword bookmark and URL", url: kURL, keyword: "urlbarkeyword"}); + info("Filling URL bar, sending <return> and opening a tab"); + gURLBar.value = "urlbarkeyword"; + gURLBar.select(); + EventUtils.sendKey("return"); + BrowserOpenTab(); + info("Waiting for new tab"); + let newTab = (yield newTabCreatedPromise).target; + info("Created new tab; waiting for either tab to load"); + let newTabLoadedPromise = BrowserTestUtils.browserLoaded(newTab.linkedBrowser, false, kURL); + newTabLoadedPromise.then(() => info("New tab loaded")); + yield Promise.race([newTabLoadedPromise, oldTabLoadedPromise]); + is(newTab.linkedBrowser.currentURI.spec, "about:newtab", "New tab still has about:newtab"); + is(oldTab.linkedBrowser.currentURI.spec, kURL, "Old tab loaded URL"); + info("Closing new tab"); + yield BrowserTestUtils.removeTab(newTab); + info("Closing old tab"); + yield BrowserTestUtils.removeTab(oldTab); + info("Finished"); +}); diff --git a/browser/base/content/test/urlbar/browser_urlbarRevert.js b/browser/base/content/test/urlbar/browser_urlbarRevert.js new file mode 100644 index 000000000..0ce3c8fac --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarRevert.js @@ -0,0 +1,37 @@ +var tab = null; + +function test() { + waitForExplicitFinish(); + + let pageLoaded = { + onStateChange: function onStateChange(aWebProgress, aRequest, aStateFlags, aStatus) { + if (aStateFlags & Ci.nsIWebProgressListener.STATE_STOP && + aStateFlags & Ci.nsIWebProgressListener.STATE_IS_NETWORK) { + gBrowser.removeProgressListener(this); + executeSoon(checkURLBarRevert); + } + } + } + + gBrowser.addProgressListener(pageLoaded); + tab = gBrowser.addTab("http://example.com"); + gBrowser.selectedTab = tab; +} + +function checkURLBarRevert() { + let originalValue = gURLBar.value; + + gBrowser.userTypedValue = "foobar"; + gBrowser.selectedTab = gBrowser.tabs[0]; + gBrowser.selectedTab = tab; + is(gURLBar.value, "foobar", "location bar displays typed value"); + + gURLBar.focus(); + + EventUtils.synthesizeKey("VK_ESCAPE", {}); + + is(gURLBar.value, originalValue, "ESC reverted the location bar value"); + + gBrowser.removeTab(tab); + finish(); +} diff --git a/browser/base/content/test/urlbar/browser_urlbarSearchSingleWordNotification.js b/browser/base/content/test/urlbar/browser_urlbarSearchSingleWordNotification.js new file mode 100644 index 000000000..ee0342055 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarSearchSingleWordNotification.js @@ -0,0 +1,198 @@ +"use strict"; + +var notificationObserver; +registerCleanupFunction(function() { + Services.prefs.clearUserPref("browser.fixup.domainwhitelist.localhost"); + if (notificationObserver) { + notificationObserver.disconnect(); + } +}); + +function promiseNotification(aBrowser, value, expected, input) { + let deferred = Promise.defer(); + let notificationBox = aBrowser.getNotificationBox(aBrowser.selectedBrowser); + if (expected) { + info("Waiting for " + value + " notification"); + let checkForNotification = function() { + if (notificationBox.getNotificationWithValue(value)) { + info("Saw the notification"); + notificationObserver.disconnect(); + notificationObserver = null; + deferred.resolve(); + } + } + if (notificationObserver) { + notificationObserver.disconnect(); + } + notificationObserver = new MutationObserver(checkForNotification); + notificationObserver.observe(notificationBox, {childList: true}); + } else { + setTimeout(() => { + is(notificationBox.getNotificationWithValue(value), null, + `We are expecting to not get a notification for ${input}`); + deferred.resolve(); + }, 1000); + } + return deferred.promise; +} + +function* runURLBarSearchTest({valueToOpen, expectSearch, expectNotification, aWindow=window}) { + aWindow.gURLBar.value = valueToOpen; + let expectedURI; + if (!expectSearch) { + expectedURI = "http://" + valueToOpen + "/"; + } else { + yield new Promise(resolve => { + Services.search.init(resolve); + }); + expectedURI = Services.search.defaultEngine.getSubmission(valueToOpen, null, "keyword").uri.spec; + } + aWindow.gURLBar.focus(); + let docLoadPromise = waitForDocLoadAndStopIt(expectedURI, aWindow.gBrowser.selectedBrowser); + EventUtils.synthesizeKey("VK_RETURN", {}, aWindow); + + yield Promise.all([ + docLoadPromise, + promiseNotification(aWindow.gBrowser, "keyword-uri-fixup", expectNotification, valueToOpen) + ]); +} + +add_task(function* test_navigate_full_domain() { + let tab = gBrowser.selectedTab = gBrowser.addTab("about:blank"); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + yield* runURLBarSearchTest({ + valueToOpen: "www.mozilla.org", + expectSearch: false, + expectNotification: false, + }); + gBrowser.removeTab(tab); +}); + +add_task(function* test_navigate_decimal_ip() { + let tab = gBrowser.selectedTab = gBrowser.addTab("about:blank"); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + yield* runURLBarSearchTest({ + valueToOpen: "1234", + expectSearch: true, + expectNotification: false, + }); + gBrowser.removeTab(tab); +}); + +add_task(function* test_navigate_decimal_ip_with_path() { + let tab = gBrowser.selectedTab = gBrowser.addTab("about:blank"); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + yield* runURLBarSearchTest({ + valueToOpen: "1234/12", + expectSearch: true, + expectNotification: false, + }); + gBrowser.removeTab(tab); +}); + +add_task(function* test_navigate_large_number() { + let tab = gBrowser.selectedTab = gBrowser.addTab("about:blank"); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + yield* runURLBarSearchTest({ + valueToOpen: "123456789012345", + expectSearch: true, + expectNotification: false + }); + gBrowser.removeTab(tab); +}); + +add_task(function* test_navigate_small_hex_number() { + let tab = gBrowser.selectedTab = gBrowser.addTab("about:blank"); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + yield* runURLBarSearchTest({ + valueToOpen: "0x1f00ffff", + expectSearch: true, + expectNotification: false + }); + gBrowser.removeTab(tab); +}); + +add_task(function* test_navigate_large_hex_number() { + let tab = gBrowser.selectedTab = gBrowser.addTab("about:blank"); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + yield* runURLBarSearchTest({ + valueToOpen: "0x7f0000017f000001", + expectSearch: true, + expectNotification: false + }); + gBrowser.removeTab(tab); +}); + +function get_test_function_for_localhost_with_hostname(hostName, isPrivate) { + return function* test_navigate_single_host() { + const pref = "browser.fixup.domainwhitelist.localhost"; + let win; + if (isPrivate) { + let promiseWin = BrowserTestUtils.waitForNewWindow(); + win = OpenBrowserWindow({private: true}); + yield promiseWin; + let deferredOpenFocus = Promise.defer(); + waitForFocus(deferredOpenFocus.resolve, win); + yield deferredOpenFocus.promise; + } else { + win = window; + } + let browser = win.gBrowser; + let tab = yield BrowserTestUtils.openNewForegroundTab(browser); + + Services.prefs.setBoolPref(pref, false); + yield* runURLBarSearchTest({ + valueToOpen: hostName, + expectSearch: true, + expectNotification: true, + aWindow: win, + }); + + let notificationBox = browser.getNotificationBox(tab.linkedBrowser); + let notification = notificationBox.getNotificationWithValue("keyword-uri-fixup"); + let docLoadPromise = waitForDocLoadAndStopIt("http://" + hostName + "/", tab.linkedBrowser); + notification.querySelector(".notification-button-default").click(); + + // check pref value + let prefValue = Services.prefs.getBoolPref(pref); + is(prefValue, !isPrivate, "Pref should have the correct state."); + + yield docLoadPromise; + browser.removeTab(tab); + + // Now try again with the pref set. + tab = browser.selectedTab = browser.addTab("about:blank"); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + // In a private window, the notification should appear again. + yield* runURLBarSearchTest({ + valueToOpen: hostName, + expectSearch: isPrivate, + expectNotification: isPrivate, + aWindow: win, + }); + browser.removeTab(tab); + if (isPrivate) { + info("Waiting for private window to close"); + yield BrowserTestUtils.closeWindow(win); + let deferredFocus = Promise.defer(); + info("Waiting for focus"); + waitForFocus(deferredFocus.resolve, window); + yield deferredFocus.promise; + } + } +} + +add_task(get_test_function_for_localhost_with_hostname("localhost")); +add_task(get_test_function_for_localhost_with_hostname("localhost.")); +add_task(get_test_function_for_localhost_with_hostname("localhost", true)); + +add_task(function* test_navigate_invalid_url() { + let tab = gBrowser.selectedTab = gBrowser.addTab("about:blank"); + yield BrowserTestUtils.browserLoaded(tab.linkedBrowser); + yield* runURLBarSearchTest({ + valueToOpen: "mozilla is awesome", + expectSearch: true, + expectNotification: false, + }); + gBrowser.removeTab(tab); +}); diff --git a/browser/base/content/test/urlbar/browser_urlbarSearchSuggestions.js b/browser/base/content/test/urlbar/browser_urlbarSearchSuggestions.js new file mode 100644 index 000000000..5146ba98c --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarSearchSuggestions.js @@ -0,0 +1,66 @@ +const SUGGEST_URLBAR_PREF = "browser.urlbar.suggest.searches"; +const TEST_ENGINE_BASENAME = "searchSuggestionEngine.xml"; + +// Must run first. +add_task(function* prepare() { + Services.prefs.setBoolPref(SUGGEST_URLBAR_PREF, true); + let engine = yield promiseNewSearchEngine(TEST_ENGINE_BASENAME); + let oldCurrentEngine = Services.search.currentEngine; + Services.search.currentEngine = engine; + registerCleanupFunction(function* () { + Services.prefs.clearUserPref(SUGGEST_URLBAR_PREF); + Services.search.currentEngine = oldCurrentEngine; + + // Clicking suggestions causes visits to search results pages, so clear that + // history now. + yield PlacesTestUtils.clearHistory(); + + // Make sure the popup is closed for the next test. + gURLBar.blur(); + Assert.ok(!gURLBar.popup.popupOpen, "popup should be closed"); + }); +}); + +add_task(function* clickSuggestion() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser); + gURLBar.focus(); + yield promiseAutocompleteResultPopup("foo"); + let [idx, suggestion, engineName] = yield promiseFirstSuggestion(); + Assert.equal(engineName, + "browser_searchSuggestionEngine%20searchSuggestionEngine.xml", + "Expected suggestion engine"); + let item = gURLBar.popup.richlistbox.getItemAtIndex(idx); + + let uri = Services.search.currentEngine.getSubmission(suggestion).uri; + let loadPromise = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser, + false, uri.spec); + item.click(); + yield loadPromise; + yield BrowserTestUtils.removeTab(tab); +}); + +function getFirstSuggestion() { + let controller = gURLBar.popup.input.controller; + let matchCount = controller.matchCount; + for (let i = 0; i < matchCount; i++) { + let url = controller.getValueAt(i); + let mozActionMatch = url.match(/^moz-action:([^,]+),(.*)$/); + if (mozActionMatch) { + let [, type, paramStr] = mozActionMatch; + let params = JSON.parse(paramStr); + if (type == "searchengine" && "searchSuggestion" in params) { + return [i, params.searchSuggestion, params.engineName]; + } + } + } + return [-1, null, null]; +} + +function* promiseFirstSuggestion() { + let tuple = [-1, null, null]; + yield BrowserTestUtils.waitForCondition(() => { + tuple = getFirstSuggestion(); + return tuple[0] >= 0; + }); + return tuple; +} diff --git a/browser/base/content/test/urlbar/browser_urlbarSearchSuggestionsNotification.js b/browser/base/content/test/urlbar/browser_urlbarSearchSuggestionsNotification.js new file mode 100644 index 000000000..94ae8a3ff --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarSearchSuggestionsNotification.js @@ -0,0 +1,254 @@ +const SUGGEST_ALL_PREF = "browser.search.suggest.enabled"; +const SUGGEST_URLBAR_PREF = "browser.urlbar.suggest.searches"; +const CHOICE_PREF = "browser.urlbar.userMadeSearchSuggestionsChoice"; +const TEST_ENGINE_BASENAME = "searchSuggestionEngine.xml"; + +// Must run first. +add_task(function* prepare() { + let engine = yield promiseNewSearchEngine(TEST_ENGINE_BASENAME); + let oldCurrentEngine = Services.search.currentEngine; + Services.search.currentEngine = engine; + registerCleanupFunction(function* () { + Services.search.currentEngine = oldCurrentEngine; + Services.prefs.clearUserPref(SUGGEST_ALL_PREF); + Services.prefs.clearUserPref(SUGGEST_URLBAR_PREF); + + // Disable the notification for future tests so it doesn't interfere with + // them. clearUserPref() won't work because by default the pref is false. + yield setUserMadeChoicePref(true); + + // Make sure the popup is closed for the next test. + gURLBar.blur(); + Assert.ok(!gURLBar.popup.popupOpen, "popup should be closed"); + }); +}); + +add_task(function* focus() { + // Focusing the urlbar used to open the popup in order to show the + // notification, but it doesn't anymore. Make sure it does not. + Services.prefs.setBoolPref(SUGGEST_ALL_PREF, true); + yield setUserMadeChoicePref(false); + gURLBar.blur(); + gURLBar.focus(); + Assert.ok(!gURLBar.popup.popupOpen, "popup should remain closed"); +}); + +add_task(function* dismissWithoutResults() { + Services.prefs.setBoolPref(SUGGEST_ALL_PREF, true); + yield setUserMadeChoicePref(false); + gURLBar.blur(); + gURLBar.focus(); + let popupPromise = promisePopupShown(gURLBar.popup); + gURLBar.openPopup(); + yield popupPromise; + Assert.ok(gURLBar.popup.popupOpen, "popup should be open"); + assertVisible(true); + Assert.equal(gURLBar.popup._matchCount, 0, "popup should have no results"); + let disableButton = document.getAnonymousElementByAttribute( + gURLBar.popup, "anonid", "search-suggestions-notification-disable" + ); + let transitionPromise = promiseTransition(); + disableButton.click(); + yield transitionPromise; + Assert.ok(!gURLBar.popup.popupOpen, "popup should be closed"); + gURLBar.blur(); + gURLBar.focus(); + Assert.ok(!gURLBar.popup.popupOpen, "popup should remain closed"); + yield promiseAutocompleteResultPopup("foo"); + Assert.ok(gURLBar.popup.popupOpen, "popup should be open"); + assertVisible(false); +}); + +add_task(function* dismissWithResults() { + Services.prefs.setBoolPref(SUGGEST_ALL_PREF, true); + yield setUserMadeChoicePref(false); + gURLBar.blur(); + gURLBar.focus(); + yield promiseAutocompleteResultPopup("foo"); + Assert.ok(gURLBar.popup.popupOpen, "popup should be open"); + assertVisible(true); + Assert.ok(gURLBar.popup._matchCount > 0, "popup should have results"); + let disableButton = document.getAnonymousElementByAttribute( + gURLBar.popup, "anonid", "search-suggestions-notification-disable" + ); + let transitionPromise = promiseTransition(); + disableButton.click(); + yield transitionPromise; + Assert.ok(gURLBar.popup.popupOpen, "popup should remain open"); + gURLBar.blur(); + gURLBar.focus(); + Assert.ok(!gURLBar.popup.popupOpen, "popup should remain closed"); + yield promiseAutocompleteResultPopup("foo"); + Assert.ok(gURLBar.popup.popupOpen, "popup should be open"); + assertVisible(false); +}); + +add_task(function* disable() { + Services.prefs.setBoolPref(SUGGEST_ALL_PREF, true); + yield setUserMadeChoicePref(false); + gURLBar.blur(); + gURLBar.focus(); + yield promiseAutocompleteResultPopup("foo"); + Assert.ok(gURLBar.popup.popupOpen, "popup should be open"); + assertVisible(true); + let disableButton = document.getAnonymousElementByAttribute( + gURLBar.popup, "anonid", "search-suggestions-notification-disable" + ); + let transitionPromise = promiseTransition(); + disableButton.click(); + yield transitionPromise; + gURLBar.blur(); + yield promiseAutocompleteResultPopup("foo"); + Assert.ok(!suggestionsPresent()); +}); + +add_task(function* enable() { + Services.prefs.setBoolPref(SUGGEST_ALL_PREF, true); + Services.prefs.setBoolPref(SUGGEST_URLBAR_PREF, false); + yield setUserMadeChoicePref(false); + gURLBar.blur(); + gURLBar.focus(); + yield promiseAutocompleteResultPopup("foo"); + assertVisible(true); + Assert.ok(!suggestionsPresent()); + let enableButton = document.getAnonymousElementByAttribute( + gURLBar.popup, "anonid", "search-suggestions-notification-enable" + ); + let searchPromise = BrowserTestUtils.waitForCondition(suggestionsPresent, + "waiting for suggestions"); + enableButton.click(); + yield searchPromise; + // Clicking Yes should trigger a new search so that suggestions appear + // immediately. + Assert.ok(suggestionsPresent()); + gURLBar.blur(); + gURLBar.focus(); + // Suggestions should still be present in a new search of course. + yield promiseAutocompleteResultPopup("bar"); + Assert.ok(suggestionsPresent()); +}); + +add_task(function* privateWindow() { + // Since suggestions are disabled in private windows, the notification should + // not appear even when suggestions are otherwise enabled. + let win = yield BrowserTestUtils.openNewBrowserWindow({ private: true }); + win.gURLBar.blur(); + win.gURLBar.focus(); + yield promiseAutocompleteResultPopup("foo", win); + assertVisible(false, win); + win.gURLBar.blur(); + yield BrowserTestUtils.closeWindow(win); +}); + +add_task(function* multipleWindows() { + // Opening multiple windows, using their urlbars, and then dismissing the + // notification in one should dismiss the notification in all. + Services.prefs.setBoolPref(SUGGEST_ALL_PREF, true); + Services.prefs.setBoolPref(SUGGEST_URLBAR_PREF, false); + yield setUserMadeChoicePref(false); + + gURLBar.focus(); + yield promiseAutocompleteResultPopup("win1"); + assertVisible(true); + + let win2 = yield BrowserTestUtils.openNewBrowserWindow(); + win2.gURLBar.focus(); + yield promiseAutocompleteResultPopup("win2", win2); + assertVisible(true, win2); + + let win3 = yield BrowserTestUtils.openNewBrowserWindow(); + win3.gURLBar.focus(); + yield promiseAutocompleteResultPopup("win3", win3); + assertVisible(true, win3); + + let enableButton = win3.document.getAnonymousElementByAttribute( + win3.gURLBar.popup, "anonid", "search-suggestions-notification-enable" + ); + let transitionPromise = promiseTransition(win3); + enableButton.click(); + yield transitionPromise; + assertVisible(false, win3); + + win2.gURLBar.focus(); + yield promiseAutocompleteResultPopup("win2done", win2); + assertVisible(false, win2); + + gURLBar.focus(); + yield promiseAutocompleteResultPopup("win1done"); + assertVisible(false); + + yield BrowserTestUtils.closeWindow(win2); + yield BrowserTestUtils.closeWindow(win3); +}); + +add_task(function* enableOutsideNotification() { + // Setting the suggest.searches pref outside the notification (e.g., by + // ticking the checkbox in the preferences window) should hide it. + Services.prefs.setBoolPref(SUGGEST_ALL_PREF, true); + Services.prefs.setBoolPref(SUGGEST_URLBAR_PREF, false); + yield setUserMadeChoicePref(false); + + Services.prefs.setBoolPref(SUGGEST_URLBAR_PREF, true); + gURLBar.focus(); + yield promiseAutocompleteResultPopup("foo"); + assertVisible(false); +}); + +/** + * Setting the choice pref triggers a pref observer in the urlbar, which hides + * the notification if it's present. This function returns a promise that's + * resolved once the observer fires. + * + * @param userMadeChoice A boolean, the pref's new value. + * @return A Promise that's resolved when the observer fires -- or, if the pref + * is currently the given value, that's resolved immediately. + */ +function setUserMadeChoicePref(userMadeChoice) { + return new Promise(resolve => { + let currentUserMadeChoice = Services.prefs.getBoolPref(CHOICE_PREF); + if (currentUserMadeChoice != userMadeChoice) { + Services.prefs.addObserver(CHOICE_PREF, function obs(subj, topic, data) { + Services.prefs.removeObserver(CHOICE_PREF, obs); + resolve(); + }, false); + } + Services.prefs.setBoolPref(CHOICE_PREF, userMadeChoice); + if (currentUserMadeChoice == userMadeChoice) { + resolve(); + } + }); +} + +function suggestionsPresent() { + let controller = gURLBar.popup.input.controller; + let matchCount = controller.matchCount; + for (let i = 0; i < matchCount; i++) { + let url = controller.getValueAt(i); + let mozActionMatch = url.match(/^moz-action:([^,]+),(.*)$/); + if (mozActionMatch) { + let [, type, paramStr] = mozActionMatch; + let params = JSON.parse(paramStr); + if (type == "searchengine" && "searchSuggestion" in params) { + return true; + } + } + } + return false; +} + +function assertVisible(visible, win=window) { + let style = + win.getComputedStyle(win.gURLBar.popup.searchSuggestionsNotification); + Assert.equal(style.visibility, visible ? "visible" : "collapse"); +} + +function promiseTransition(win=window) { + return new Promise(resolve => { + win.gURLBar.popup.addEventListener("transitionend", function onEnd() { + win.gURLBar.popup.removeEventListener("transitionend", onEnd, true); + // The urlbar needs to handle the transitionend first, but that happens + // naturally since promises are resolved at the end of the current tick. + resolve(); + }, true); + }); +} diff --git a/browser/base/content/test/urlbar/browser_urlbarSearchTelemetry.js b/browser/base/content/test/urlbar/browser_urlbarSearchTelemetry.js new file mode 100644 index 000000000..8c28401ea --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarSearchTelemetry.js @@ -0,0 +1,216 @@ +"use strict"; + +Cu.import("resource:///modules/BrowserUITelemetry.jsm"); + +const SUGGEST_URLBAR_PREF = "browser.urlbar.suggest.searches"; +const TEST_ENGINE_BASENAME = "searchSuggestionEngine.xml"; + +// Must run first. +add_task(function* prepare() { + Services.prefs.setBoolPref(SUGGEST_URLBAR_PREF, true); + let engine = yield promiseNewSearchEngine(TEST_ENGINE_BASENAME); + let oldCurrentEngine = Services.search.currentEngine; + Services.search.currentEngine = engine; + + registerCleanupFunction(function* () { + Services.prefs.clearUserPref(SUGGEST_URLBAR_PREF); + Services.search.currentEngine = oldCurrentEngine; + + // Clicking urlbar results causes visits to their associated pages, so clear + // that history now. + yield PlacesTestUtils.clearHistory(); + + // Make sure the popup is closed for the next test. + gURLBar.blur(); + Assert.ok(!gURLBar.popup.popupOpen, "popup should be closed"); + }); + + // Move the mouse away from the urlbar one-offs so that a one-off engine is + // not inadvertently selected. + yield new Promise(resolve => { + EventUtils.synthesizeNativeMouseMove(window.document.documentElement, 0, 0, + resolve); + }); +}); + +add_task(function* heuristicResultMouse() { + yield compareCounts(function* () { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser); + gURLBar.focus(); + yield promiseAutocompleteResultPopup("heuristicResult"); + let action = getActionAtIndex(0); + Assert.ok(!!action, "there should be an action at index 0"); + Assert.equal(action.type, "searchengine", "type should be searchengine"); + let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + gURLBar.popup.richlistbox.getItemAtIndex(0).click(); + yield loadPromise; + yield BrowserTestUtils.removeTab(tab); + }); +}); + +add_task(function* heuristicResultKeyboard() { + yield compareCounts(function* () { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser); + gURLBar.focus(); + yield promiseAutocompleteResultPopup("heuristicResult"); + let action = getActionAtIndex(0); + Assert.ok(!!action, "there should be an action at index 0"); + Assert.equal(action.type, "searchengine", "type should be searchengine"); + let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + EventUtils.sendKey("return"); + yield loadPromise; + yield BrowserTestUtils.removeTab(tab); + }); +}); + +add_task(function* searchSuggestionMouse() { + yield compareCounts(function* () { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser); + gURLBar.focus(); + yield promiseAutocompleteResultPopup("searchSuggestion"); + let idx = getFirstSuggestionIndex(); + Assert.ok(idx >= 0, "there should be a first suggestion"); + let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + gURLBar.popup.richlistbox.getItemAtIndex(idx).click(); + yield loadPromise; + yield BrowserTestUtils.removeTab(tab); + }); +}); + +add_task(function* searchSuggestionKeyboard() { + yield compareCounts(function* () { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser); + gURLBar.focus(); + yield promiseAutocompleteResultPopup("searchSuggestion"); + let idx = getFirstSuggestionIndex(); + Assert.ok(idx >= 0, "there should be a first suggestion"); + let loadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + while (idx--) { + EventUtils.sendKey("down"); + } + EventUtils.sendKey("return"); + yield loadPromise; + yield BrowserTestUtils.removeTab(tab); + }); +}); + +/** + * This does three things: gets current telemetry/FHR counts, calls + * clickCallback, gets telemetry/FHR counts again to compare them to the old + * counts. + * + * @param clickCallback Use this to open the urlbar popup and choose and click a + * result. + */ +function* compareCounts(clickCallback) { + // Search events triggered by clicks (not the Return key in the urlbar) are + // recorded in three places: + // * BrowserUITelemetry + // * Telemetry histogram named "SEARCH_COUNTS" + // * FHR + + let engine = Services.search.currentEngine; + let engineID = "org.mozilla.testsearchsuggestions"; + + // First, get the current counts. + + // BrowserUITelemetry + let uiTelemCount = 0; + let bucket = BrowserUITelemetry.currentBucket; + let events = BrowserUITelemetry.getToolbarMeasures().countableEvents; + if (events[bucket] && + events[bucket].search && + events[bucket].search.urlbar) { + uiTelemCount = events[bucket].search.urlbar; + } + + // telemetry histogram SEARCH_COUNTS + let histogramCount = 0; + let histogramKey = engineID + ".urlbar"; + let histogram; + try { + histogram = Services.telemetry.getKeyedHistogramById("SEARCH_COUNTS"); + } catch (ex) { + // No searches performed yet, not a problem. + } + if (histogram) { + let snapshot = histogram.snapshot(); + if (histogramKey in snapshot) { + histogramCount = snapshot[histogramKey].sum; + } + } + + // FHR -- first make sure the engine has an identifier so that FHR is happy. + Object.defineProperty(engine.wrappedJSObject, "identifier", + { value: engineID }); + + gURLBar.focus(); + yield clickCallback(); + + // Now get the new counts and compare them to the old. + + // BrowserUITelemetry + events = BrowserUITelemetry.getToolbarMeasures().countableEvents; + Assert.ok(bucket in events, "bucket should be recorded"); + events = events[bucket]; + Assert.ok("search" in events, "search should be recorded"); + events = events.search; + Assert.ok("urlbar" in events, "urlbar should be recorded"); + Assert.equal(events.urlbar, uiTelemCount + 1, + "clicked suggestion should be recorded"); + + // telemetry histogram SEARCH_COUNTS + histogram = Services.telemetry.getKeyedHistogramById("SEARCH_COUNTS"); + let snapshot = histogram.snapshot(); + Assert.ok(histogramKey in snapshot, "histogram with key should be recorded"); + Assert.equal(snapshot[histogramKey].sum, histogramCount + 1, + "histogram sum should be incremented"); +} + +/** + * Returns the "action" object at the given index in the urlbar results: + * { type, params: {}} + * + * @param index The index in the urlbar results. + * @return An action object, or null if index >= number of results. + */ +function getActionAtIndex(index) { + let controller = gURLBar.popup.input.controller; + if (controller.matchCount <= index) { + return null; + } + let url = controller.getValueAt(index); + let mozActionMatch = url.match(/^moz-action:([^,]+),(.*)$/); + if (!mozActionMatch) { + let msg = "result at index " + index + " is not a moz-action: " + url; + Assert.ok(false, msg); + throw new Error(msg); + } + let [, type, paramStr] = mozActionMatch; + return { + type: type, + params: JSON.parse(paramStr), + }; +} + +/** + * Returns the index of the first search suggestion in the urlbar results. + * + * @return An index, or -1 if there are no search suggestions. + */ +function getFirstSuggestionIndex() { + let controller = gURLBar.popup.input.controller; + let matchCount = controller.matchCount; + for (let i = 0; i < matchCount; i++) { + let url = controller.getValueAt(i); + let mozActionMatch = url.match(/^moz-action:([^,]+),(.*)$/); + if (mozActionMatch) { + let [, type, paramStr] = mozActionMatch; + let params = JSON.parse(paramStr); + if (type == "searchengine" && "searchSuggestion" in params) { + return i; + } + } + } + return -1; +} diff --git a/browser/base/content/test/urlbar/browser_urlbarStop.js b/browser/base/content/test/urlbar/browser_urlbarStop.js new file mode 100644 index 000000000..8cf9d8017 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarStop.js @@ -0,0 +1,30 @@ +"use strict"; + +const goodURL = "http://mochi.test:8888/"; +const badURL = "http://mochi.test:8888/whatever.html"; + +add_task(function* () { + gBrowser.selectedTab = gBrowser.addTab(goodURL); + yield BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + is(gURLBar.textValue, gURLBar.trimValue(goodURL), "location bar reflects loaded page"); + + yield typeAndSubmitAndStop(badURL); + is(gURLBar.textValue, gURLBar.trimValue(goodURL), "location bar reflects loaded page after stop()"); + gBrowser.removeCurrentTab(); + + gBrowser.selectedTab = gBrowser.addTab("about:blank"); + is(gURLBar.textValue, "", "location bar is empty"); + + yield typeAndSubmitAndStop(badURL); + is(gURLBar.textValue, gURLBar.trimValue(badURL), "location bar reflects stopped page in an empty tab"); + gBrowser.removeCurrentTab(); +}); + +function* typeAndSubmitAndStop(url) { + yield promiseAutocompleteResultPopup(url, window, true); + is(gURLBar.textValue, gURLBar.trimValue(url), "location bar reflects loading page"); + + let promise = waitForDocLoadAndStopIt(url, gBrowser.selectedBrowser, false); + gURLBar.handleCommand(); + yield promise; +} diff --git a/browser/base/content/test/urlbar/browser_urlbarTrimURLs.js b/browser/base/content/test/urlbar/browser_urlbarTrimURLs.js new file mode 100644 index 000000000..913e99a8e --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarTrimURLs.js @@ -0,0 +1,98 @@ +add_task(function* () { + const PREF_TRIMURLS = "browser.urlbar.trimURLs"; + + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser); + + registerCleanupFunction(function* () { + yield BrowserTestUtils.removeTab(tab); + Services.prefs.clearUserPref(PREF_TRIMURLS); + URLBarSetURI(); + }); + + Services.prefs.setBoolPref(PREF_TRIMURLS, true); + + testVal("http://mozilla.org/", "mozilla.org"); + testVal("https://mozilla.org/", "https://mozilla.org"); + testVal("http://mözilla.org/", "mözilla.org"); + testVal("http://mozilla.imaginatory/", "mozilla.imaginatory"); + testVal("http://www.mozilla.org/", "www.mozilla.org"); + testVal("http://sub.mozilla.org/", "sub.mozilla.org"); + testVal("http://sub1.sub2.sub3.mozilla.org/", "sub1.sub2.sub3.mozilla.org"); + testVal("http://mozilla.org/file.ext", "mozilla.org/file.ext"); + testVal("http://mozilla.org/sub/", "mozilla.org/sub/"); + + testVal("http://ftp.mozilla.org/", "ftp.mozilla.org"); + testVal("http://ftp1.mozilla.org/", "ftp1.mozilla.org"); + testVal("http://ftp42.mozilla.org/", "ftp42.mozilla.org"); + testVal("http://ftpx.mozilla.org/", "ftpx.mozilla.org"); + testVal("ftp://ftp.mozilla.org/", "ftp://ftp.mozilla.org"); + testVal("ftp://ftp1.mozilla.org/", "ftp://ftp1.mozilla.org"); + testVal("ftp://ftp42.mozilla.org/", "ftp://ftp42.mozilla.org"); + testVal("ftp://ftpx.mozilla.org/", "ftp://ftpx.mozilla.org"); + + testVal("https://user:pass@mozilla.org/", "https://user:pass@mozilla.org"); + testVal("https://user@mozilla.org/", "https://user@mozilla.org"); + testVal("http://user:pass@mozilla.org/", "user:pass@mozilla.org"); + testVal("http://user@mozilla.org/", "user@mozilla.org"); + testVal("http://sub.mozilla.org:666/", "sub.mozilla.org:666"); + + testVal("https://[fe80::222:19ff:fe11:8c76]/file.ext"); + testVal("http://[fe80::222:19ff:fe11:8c76]/", "[fe80::222:19ff:fe11:8c76]"); + testVal("https://user:pass@[fe80::222:19ff:fe11:8c76]:666/file.ext"); + testVal("http://user:pass@[fe80::222:19ff:fe11:8c76]:666/file.ext", "user:pass@[fe80::222:19ff:fe11:8c76]:666/file.ext"); + + testVal("mailto:admin@mozilla.org"); + testVal("gopher://mozilla.org/"); + testVal("about:config"); + testVal("jar:http://mozilla.org/example.jar!/"); + testVal("view-source:http://mozilla.org/"); + + // Behaviour for hosts with no dots depends on the whitelist: + let fixupWhitelistPref = "browser.fixup.domainwhitelist.localhost"; + Services.prefs.setBoolPref(fixupWhitelistPref, false); + testVal("http://localhost"); + Services.prefs.setBoolPref(fixupWhitelistPref, true); + testVal("http://localhost", "localhost"); + Services.prefs.clearUserPref(fixupWhitelistPref); + + testVal("http:// invalid url"); + + testVal("http://someotherhostwithnodots"); + testVal("http://localhost/ foo bar baz"); + testVal("http://localhost.localdomain/ foo bar baz", "localhost.localdomain/ foo bar baz"); + + Services.prefs.setBoolPref(PREF_TRIMURLS, false); + + testVal("http://mozilla.org/"); + + Services.prefs.setBoolPref(PREF_TRIMURLS, true); + + let promiseLoaded = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser, + false, "http://example.com/"); + gBrowser.loadURI("http://example.com/"); + yield promiseLoaded; + + yield testCopy("example.com", "http://example.com/") + + SetPageProxyState("invalid"); + gURLBar.valueIsTyped = true; + yield testCopy("example.com", "example.com"); +}); + +function testVal(originalValue, targetValue) { + gURLBar.value = originalValue; + gURLBar.valueIsTyped = false; + is(gURLBar.textValue, targetValue || originalValue, "url bar value set"); +} + +function testCopy(originalValue, targetValue) { + return new Promise((resolve, reject) => { + waitForClipboard(targetValue, function () { + is(gURLBar.textValue, originalValue, "url bar copy value set"); + + gURLBar.focus(); + gURLBar.select(); + goDoCommand("cmd_copy"); + }, resolve, reject); + }); +} diff --git a/browser/base/content/test/urlbar/browser_urlbarUpdateForDomainCompletion.js b/browser/base/content/test/urlbar/browser_urlbarUpdateForDomainCompletion.js new file mode 100644 index 000000000..c3cdf507f --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbarUpdateForDomainCompletion.js @@ -0,0 +1,17 @@ +"use strict"; + +/** + * Disable keyword.enabled (so no keyword search), and check that when you type in + * "example" and hit enter, the browser loads and the URL bar is updated accordingly. + */ +add_task(function* () { + yield new Promise(resolve => SpecialPowers.pushPrefEnv({set: [["keyword.enabled", false]]}, resolve)); + yield BrowserTestUtils.withNewTab({ gBrowser, url: "about:blank" }, function* (browser) { + gURLBar.value = "example"; + gURLBar.select(); + let loadPromise = BrowserTestUtils.browserLoaded(browser, false, url => url == "http://www.example.com/"); + EventUtils.sendKey("return"); + yield loadPromise; + is(gURLBar.textValue, "www.example.com"); + }); +}); diff --git a/browser/base/content/test/urlbar/browser_urlbar_autoFill_backspaced.js b/browser/base/content/test/urlbar/browser_urlbar_autoFill_backspaced.js new file mode 100644 index 000000000..7fefd3f77 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbar_autoFill_backspaced.js @@ -0,0 +1,146 @@ +/* This test ensures that backspacing autoFilled values still allows to + * confirm the remaining value. + */ + +function* test_autocomplete(data) { + let {desc, typed, autofilled, modified, keys, action, onAutoFill} = data; + info(desc); + + yield promiseAutocompleteResultPopup(typed); + is(gURLBar.textValue, autofilled, "autofilled value is as expected"); + if (onAutoFill) + onAutoFill() + + keys.forEach(key => EventUtils.synthesizeKey(key, {})); + + is(gURLBar.textValue, modified, "backspaced value is as expected"); + + yield promiseSearchComplete(); + + ok(gURLBar.popup.richlistbox.children.length > 0, "Should get at least 1 result"); + let result = gURLBar.popup.richlistbox.children[0]; + let type = result.getAttribute("type"); + let types = type.split(/\s+/); + ok(types.indexOf(action) >= 0, `The type attribute "${type}" includes the expected action "${action}"`); + + gURLBar.popup.hidePopup(); + yield promisePopupHidden(gURLBar.popup); + gURLBar.blur(); +} + +add_task(function* () { + registerCleanupFunction(function* () { + Services.prefs.clearUserPref("browser.urlbar.autoFill"); + gURLBar.handleRevert(); + yield PlacesTestUtils.clearHistory(); + }); + Services.prefs.setBoolPref("browser.urlbar.autoFill", true); + + // Add a typed visit, so it will be autofilled. + yield PlacesTestUtils.addVisits({ + uri: NetUtil.newURI("http://example.com/"), + transition: Ci.nsINavHistoryService.TRANSITION_TYPED + }); + + yield test_autocomplete({ desc: "DELETE the autofilled part should search", + typed: "exam", + autofilled: "example.com/", + modified: "exam", + keys: ["VK_DELETE"], + action: "searchengine" + }); + yield test_autocomplete({ desc: "DELETE the final slash should visit", + typed: "example.com", + autofilled: "example.com/", + modified: "example.com", + keys: ["VK_DELETE"], + action: "visiturl" + }); + + yield test_autocomplete({ desc: "BACK_SPACE the autofilled part should search", + typed: "exam", + autofilled: "example.com/", + modified: "exam", + keys: ["VK_BACK_SPACE"], + action: "searchengine" + }); + yield test_autocomplete({ desc: "BACK_SPACE the final slash should visit", + typed: "example.com", + autofilled: "example.com/", + modified: "example.com", + keys: ["VK_BACK_SPACE"], + action: "visiturl" + }); + + yield test_autocomplete({ desc: "DELETE the autofilled part, then BACK_SPACE, should search", + typed: "exam", + autofilled: "example.com/", + modified: "exa", + keys: ["VK_DELETE", "VK_BACK_SPACE"], + action: "searchengine" + }); + yield test_autocomplete({ desc: "DELETE the final slash, then BACK_SPACE, should search", + typed: "example.com", + autofilled: "example.com/", + modified: "example.co", + keys: ["VK_DELETE", "VK_BACK_SPACE"], + action: "visiturl" + }); + + yield test_autocomplete({ desc: "BACK_SPACE the autofilled part, then BACK_SPACE, should search", + typed: "exam", + autofilled: "example.com/", + modified: "exa", + keys: ["VK_BACK_SPACE", "VK_BACK_SPACE"], + action: "searchengine" + }); + yield test_autocomplete({ desc: "BACK_SPACE the final slash, then BACK_SPACE, should search", + typed: "example.com", + autofilled: "example.com/", + modified: "example.co", + keys: ["VK_BACK_SPACE", "VK_BACK_SPACE"], + action: "visiturl" + }); + + yield test_autocomplete({ desc: "BACK_SPACE after blur should search", + typed: "ex", + autofilled: "example.com/", + modified: "e", + keys: ["VK_BACK_SPACE"], + action: "searchengine", + onAutoFill: () => { + gURLBar.blur(); + gURLBar.focus(); + gURLBar.selectionStart = 1; + gURLBar.selectionEnd = 12; + } + }); + yield test_autocomplete({ desc: "DELETE after blur should search", + typed: "ex", + autofilled: "example.com/", + modified: "e", + keys: ["VK_DELETE"], + action: "searchengine", + onAutoFill: () => { + gURLBar.blur(); + gURLBar.focus(); + gURLBar.selectionStart = 1; + gURLBar.selectionEnd = 12; + } + }); + yield test_autocomplete({ desc: "double BACK_SPACE after blur should search", + typed: "ex", + autofilled: "example.com/", + modified: "e", + keys: ["VK_BACK_SPACE", "VK_BACK_SPACE"], + action: "searchengine", + onAutoFill: () => { + gURLBar.blur(); + gURLBar.focus(); + gURLBar.selectionStart = 2; + gURLBar.selectionEnd = 12; + } + }); + + yield PlacesTestUtils.clearHistory(); +}); diff --git a/browser/base/content/test/urlbar/browser_urlbar_blanking.js b/browser/base/content/test/urlbar/browser_urlbar_blanking.js new file mode 100644 index 000000000..13660edab --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbar_blanking.js @@ -0,0 +1,35 @@ +"use strict"; + +add_task(function*() { + for (let page of gInitialPages) { + if (page == "about:newtab") { + // New tab preloading makes this a pain to test, so skip + continue; + } + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, page); + ok(!gURLBar.value, "The URL bar should be empty if we load a plain " + page + " page."); + yield BrowserTestUtils.removeTab(tab); + } +}); + +add_task(function*() { + const URI = "http://www.example.com/browser/browser/base/content/test/urlbar/file_blank_but_not_blank.html"; + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, URI); + is(gURLBar.value, URI, "The URL bar should match the URI"); + let browserLoaded = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + ContentTask.spawn(tab.linkedBrowser, null, function() { + content.document.querySelector('a').click(); + }); + yield browserLoaded; + ok(gURLBar.value.startsWith("javascript"), "The URL bar should have the JS URI"); + // When reloading, the javascript: uri we're using will throw an exception. + // That's deliberate, so we need to tell mochitest to ignore it: + SimpleTest.expectUncaughtException(true); + yield ContentTask.spawn(tab.linkedBrowser, null, function*() { + // This is sync, so by the time we return we should have changed the URL bar. + content.location.reload(); + }); + ok(!!gURLBar.value, "URL bar should not be blank."); + yield BrowserTestUtils.removeTab(tab); + SimpleTest.expectUncaughtException(false); +}); diff --git a/browser/base/content/test/urlbar/browser_urlbar_locationchange_urlbar_edit_dos.js b/browser/base/content/test/urlbar/browser_urlbar_locationchange_urlbar_edit_dos.js new file mode 100644 index 000000000..63ed58a62 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbar_locationchange_urlbar_edit_dos.js @@ -0,0 +1,41 @@ +"use strict"; + +function* checkURLBarValueStays(browser) { + gURLBar.select(); + EventUtils.synthesizeKey("a", {}); + is(gURLBar.value, "a", "URL bar value should match after sending a key"); + yield new Promise(resolve => { + let listener = { + onLocationChange(aWebProgress, aRequest, aLocation, aFlags) { + ok(aFlags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT, + "Should only get a same document location change"); + gBrowser.selectedBrowser.removeProgressListener(filter); + filter = null; + resolve(); + }, + }; + let filter = Cc["@mozilla.org/appshell/component/browser-status-filter;1"] + .createInstance(Ci.nsIWebProgress); + filter.addProgressListener(listener, Ci.nsIWebProgress.NOTIFY_ALL); + gBrowser.selectedBrowser.addProgressListener(filter); + }); + is(gURLBar.value, "a", "URL bar should not have been changed by location changes."); +} + +add_task(function*() { + yield BrowserTestUtils.withNewTab({ + gBrowser, + url: "http://example.com/browser/browser/base/content/test/urlbar/file_urlbar_edit_dos.html" + }, function*(browser) { + yield ContentTask.spawn(browser, "", function() { + content.wrappedJSObject.dos_hash(); + }); + yield checkURLBarValueStays(browser); + yield ContentTask.spawn(browser, "", function() { + content.clearTimeout(content.wrappedJSObject.dos_timeout); + content.wrappedJSObject.dos_pushState(); + }); + yield checkURLBarValueStays(browser); + }); +}); + diff --git a/browser/base/content/test/urlbar/browser_urlbar_remoteness_switch.js b/browser/base/content/test/urlbar/browser_urlbar_remoteness_switch.js new file mode 100644 index 000000000..9a1df0505 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbar_remoteness_switch.js @@ -0,0 +1,39 @@ +"use strict"; + +/** + * Verify that when loading and going back/forward through history between URLs + * loaded in the content process, and URLs loaded in the parent process, we + * don't set the URL for the tab to about:blank inbetween the loads. + */ +add_task(function*() { + let url = "http://www.example.com/foo.html"; + yield BrowserTestUtils.withNewTab({gBrowser, url}, function*(browser) { + let wpl = { + onLocationChange(wpl, request, location, flags) { + if (location.schemeIs("about")) { + is(location.spec, "about:config", "Only about: location change should be for about:preferences"); + } else { + is(location.spec, url, "Only non-about: location change should be for the http URL we're dealing with."); + } + }, + }; + gBrowser.addProgressListener(wpl); + + let didLoad = BrowserTestUtils.browserLoaded(browser, null, function(loadedURL) { + return loadedURL == "about:config"; + }); + yield BrowserTestUtils.loadURI(browser, "about:config"); + yield didLoad; + + gBrowser.goBack(); + yield BrowserTestUtils.browserLoaded(browser, null, function(loadedURL) { + return url == loadedURL; + }); + gBrowser.goForward(); + yield BrowserTestUtils.browserLoaded(browser, null, function(loadedURL) { + return loadedURL == "about:config"; + }); + gBrowser.removeProgressListener(wpl); + }); +}); + diff --git a/browser/base/content/test/urlbar/browser_urlbar_searchsettings.js b/browser/base/content/test/urlbar/browser_urlbar_searchsettings.js new file mode 100644 index 000000000..04b1c508b --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbar_searchsettings.js @@ -0,0 +1,30 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_task(function*() { + let button = document.getElementById("urlbar-search-settings"); + if (!button) { + ok("Skipping test"); + return; + } + + yield BrowserTestUtils.withNewTab({ gBrowser, url: "about:blank" }, function* () { + let popupopened = BrowserTestUtils.waitForEvent(gURLBar.popup, "popupshown"); + + gURLBar.focus(); + EventUtils.synthesizeKey("a", {}); + yield popupopened; + + // Since the current tab is blank the preferences pane will load there + let loaded = BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser); + let popupclosed = BrowserTestUtils.waitForEvent(gURLBar.popup, "popuphidden"); + EventUtils.synthesizeMouseAtCenter(button, {}); + yield loaded; + yield popupclosed; + + is(gBrowser.selectedBrowser.currentURI.spec, "about:preferences#search", + "Should have loaded the right page"); + }); +}); diff --git a/browser/base/content/test/urlbar/browser_urlbar_stop_pending.js b/browser/base/content/test/urlbar/browser_urlbar_stop_pending.js new file mode 100644 index 000000000..6b6a10ea3 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_urlbar_stop_pending.js @@ -0,0 +1,138 @@ +"use strict"; + +const SLOW_PAGE = "http://www.example.com/browser/browser/base/content/test/urlbar/slow-page.sjs"; +const SLOW_PAGE2 = "http://mochi.test:8888/browser/browser/base/content/test/urlbar/slow-page.sjs?faster"; + +/** + * Check that if we: + * 1) have a loaded page + * 2) load a separate URL + * 3) before the URL for step 2 has finished loading, load a third URL + * we don't revert to the URL from (1). + */ +add_task(function*() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com", true, true); + + let expectedURLBarChange = SLOW_PAGE; + let sawChange = false; + let handler = e => { + sawChange = true; + is(gURLBar.value, expectedURLBarChange, "Should not change URL bar value!"); + }; + + let obs = new MutationObserver(handler); + + obs.observe(gURLBar, {attributes: true}); + gURLBar.value = SLOW_PAGE; + gURLBar.handleCommand(); + + // If this ever starts going intermittent, we've broken this. + yield new Promise(resolve => setTimeout(resolve, 200)); + expectedURLBarChange = SLOW_PAGE2; + let pageLoadPromise = BrowserTestUtils.browserLoaded(tab.linkedBrowser); + gURLBar.value = expectedURLBarChange; + gURLBar.handleCommand(); + is(gURLBar.value, expectedURLBarChange, "Should not have changed URL bar value synchronously."); + yield pageLoadPromise; + ok(sawChange, "The URL bar change handler should have been called by the time the page was loaded"); + obs.disconnect(); + obs = null; + yield BrowserTestUtils.removeTab(tab); +}); + +/** + * Check that if we: + * 1) middle-click a link to a separate page whose server doesn't respond + * 2) we switch to that tab and stop the request + * + * The URL bar continues to contain the URL of the page we wanted to visit. + */ +add_task(function*() { + let socket = Cc["@mozilla.org/network/server-socket;1"].createInstance(Ci.nsIServerSocket); + socket.init(-1, true, -1); + const PORT = socket.port; + registerCleanupFunction(() => { socket.close(); }); + + const TEST_PATH = getRootDirectory(gTestPath).replace("chrome://mochitests/content", "https://example.com"); + const BASE_PAGE = TEST_PATH + "dummy_page.html"; + const SLOW_HOST = `https://localhost:${PORT}/`; + info("Using URLs: " + SLOW_HOST); + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, BASE_PAGE); + info("opened tab"); + yield ContentTask.spawn(tab.linkedBrowser, SLOW_HOST, URL => { + let link = content.document.createElement("a"); + link.href = URL; + link.textContent = "click me to open a slow page"; + link.id = "clickme" + content.document.body.appendChild(link); + }); + info("added link"); + let newTabPromise = BrowserTestUtils.waitForEvent(gBrowser.tabContainer, "TabOpen"); + // Middle click the link: + yield BrowserTestUtils.synthesizeMouseAtCenter("#clickme", { button: 1 }, tab.linkedBrowser); + // get new tab, switch to it + let newTab = (yield newTabPromise).target; + yield BrowserTestUtils.switchTab(gBrowser, newTab); + is(gURLBar.value, SLOW_HOST, "Should have slow page in URL bar"); + let browserStoppedPromise = BrowserTestUtils.browserStopped(newTab.linkedBrowser); + BrowserStop(); + yield browserStoppedPromise; + + is(gURLBar.value, SLOW_HOST, "Should still have slow page in URL bar after stop"); + yield BrowserTestUtils.removeTab(newTab); + yield BrowserTestUtils.removeTab(tab); +}); +/** + * Check that if we: + * 1) middle-click a link to a separate page whose server doesn't respond + * 2) we alter the URL on that page to some other server that doesn't respond + * 3) we stop the request + * + * The URL bar continues to contain the second URL. + */ +add_task(function*() { + let socket = Cc["@mozilla.org/network/server-socket;1"].createInstance(Ci.nsIServerSocket); + socket.init(-1, true, -1); + const PORT1 = socket.port; + let socket2 = Cc["@mozilla.org/network/server-socket;1"].createInstance(Ci.nsIServerSocket); + socket2.init(-1, true, -1); + const PORT2 = socket2.port; + registerCleanupFunction(() => { socket.close(); socket2.close(); }); + + const TEST_PATH = getRootDirectory(gTestPath).replace("chrome://mochitests/content", "https://example.com"); + const BASE_PAGE = TEST_PATH + "dummy_page.html"; + const SLOW_HOST1 = `https://localhost:${PORT1}/`; + const SLOW_HOST2 = `https://localhost:${PORT2}/`; + info("Using URLs: " + SLOW_HOST1 + " and " + SLOW_HOST2); + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, BASE_PAGE); + info("opened tab"); + yield ContentTask.spawn(tab.linkedBrowser, SLOW_HOST1, URL => { + let link = content.document.createElement("a"); + link.href = URL; + link.textContent = "click me to open a slow page"; + link.id = "clickme" + content.document.body.appendChild(link); + }); + info("added link"); + let newTabPromise = BrowserTestUtils.waitForEvent(gBrowser.tabContainer, "TabOpen"); + // Middle click the link: + yield BrowserTestUtils.synthesizeMouseAtCenter("#clickme", { button: 1 }, tab.linkedBrowser); + // get new tab, switch to it + let newTab = (yield newTabPromise).target; + yield BrowserTestUtils.switchTab(gBrowser, newTab); + is(gURLBar.value, SLOW_HOST1, "Should have slow page in URL bar"); + let browserStoppedPromise = BrowserTestUtils.browserStopped(newTab.linkedBrowser); + gURLBar.value = SLOW_HOST2; + gURLBar.handleCommand(); + yield browserStoppedPromise; + + is(gURLBar.value, SLOW_HOST2, "Should have second slow page in URL bar"); + browserStoppedPromise = BrowserTestUtils.browserStopped(newTab.linkedBrowser); + BrowserStop(); + yield browserStoppedPromise; + + is(gURLBar.value, SLOW_HOST2, "Should still have second slow page in URL bar after stop"); + yield BrowserTestUtils.removeTab(newTab); + yield BrowserTestUtils.removeTab(tab); +}); + diff --git a/browser/base/content/test/urlbar/browser_wyciwyg_urlbarCopying.js b/browser/base/content/test/urlbar/browser_wyciwyg_urlbarCopying.js new file mode 100644 index 000000000..54b174aa8 --- /dev/null +++ b/browser/base/content/test/urlbar/browser_wyciwyg_urlbarCopying.js @@ -0,0 +1,31 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +function testURLBarCopy(targetValue) { + return new Promise((resolve, reject) => { + info("Expecting copy of: " + targetValue); + waitForClipboard(targetValue, function () { + gURLBar.focus(); + gURLBar.select(); + + goDoCommand("cmd_copy"); + }, resolve, () => { + ok(false, "Clipboard copy failed"); + reject(); + }); + }); +} + +add_task(function* () { + const url = "http://mochi.test:8888/browser/browser/base/content/test/urlbar/test_wyciwyg_copying.html"; + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, url); + + yield BrowserTestUtils.synthesizeMouseAtCenter("#btn", {}, tab.linkedBrowser); + let currentURL = gBrowser.currentURI.spec; + ok(/^wyciwyg:\/\//i.test(currentURL), currentURL + " is a wyciwyg URI"); + + yield testURLBarCopy(url); + + while (gBrowser.tabs.length > 1) + gBrowser.removeCurrentTab(); +}); diff --git a/browser/base/content/test/urlbar/dummy_page.html b/browser/base/content/test/urlbar/dummy_page.html new file mode 100644 index 000000000..1a87e2840 --- /dev/null +++ b/browser/base/content/test/urlbar/dummy_page.html @@ -0,0 +1,9 @@ +<html> +<head> +<title>Dummy test page</title> +<meta http-equiv="Content-Type" content="text/html;charset=utf-8"></meta> +</head> +<body> +<p>Dummy test page</p> +</body> +</html> diff --git a/browser/base/content/test/urlbar/file_blank_but_not_blank.html b/browser/base/content/test/urlbar/file_blank_but_not_blank.html new file mode 100644 index 000000000..1f5fea8dc --- /dev/null +++ b/browser/base/content/test/urlbar/file_blank_but_not_blank.html @@ -0,0 +1,2 @@ +<script>var q = "1";</script> +<a href="javascript:q">Click me</a> diff --git a/browser/base/content/test/urlbar/file_urlbar_edit_dos.html b/browser/base/content/test/urlbar/file_urlbar_edit_dos.html new file mode 100644 index 000000000..5a6e7d109 --- /dev/null +++ b/browser/base/content/test/urlbar/file_urlbar_edit_dos.html @@ -0,0 +1,23 @@ +<!DOCTYPE html> +<html> +<head> +<title>Try editing the URL bar</title> +<meta http-equiv="Content-Type" content="text/html;charset=utf-8"></meta> +</head> +<body> +<script> +var dos_timeout = null; +function dos_hash() { + dos_timeout = setTimeout(function() { + location.hash = "#"; + }, 50); +} + +function dos_pushState() { + dos_timeout = setTimeout(function() { + history.pushState({}, "Some title", ""); + }, 50); +} +</script> +</body> +</html> diff --git a/browser/base/content/test/urlbar/head.js b/browser/base/content/test/urlbar/head.js new file mode 100644 index 000000000..427dba080 --- /dev/null +++ b/browser/base/content/test/urlbar/head.js @@ -0,0 +1,205 @@ +Components.utils.import("resource://gre/modules/XPCOMUtils.jsm"); + +XPCOMUtils.defineLazyModuleGetter(this, "Promise", + "resource://gre/modules/Promise.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Task", + "resource://gre/modules/Task.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils", + "resource://gre/modules/PlacesUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "PlacesTestUtils", + "resource://testing-common/PlacesTestUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Preferences", + "resource://gre/modules/Preferences.jsm"); + +/** + * Waits for the next top-level document load in the current browser. The URI + * of the document is compared against aExpectedURL. The load is then stopped + * before it actually starts. + * + * @param aExpectedURL + * The URL of the document that is expected to load. + * @param aStopFromProgressListener + * Whether to cancel the load directly from the progress listener. Defaults to true. + * If you're using this method to avoid hitting the network, you want the default (true). + * However, the browser UI will behave differently for loads stopped directly from + * the progress listener (effectively in the middle of a call to loadURI) and so there + * are cases where you may want to avoid stopping the load directly from within the + * progress listener callback. + * @return promise + */ +function waitForDocLoadAndStopIt(aExpectedURL, aBrowser=gBrowser.selectedBrowser, aStopFromProgressListener=true) { + function content_script(aStopFromProgressListener) { + let { interfaces: Ci, utils: Cu } = Components; + Components.utils.import("resource://gre/modules/XPCOMUtils.jsm"); + let wp = docShell.QueryInterface(Ci.nsIWebProgress); + + function stopContent(now, uri) { + if (now) { + /* Hammer time. */ + content.stop(); + + /* Let the parent know we're done. */ + sendAsyncMessage("Test:WaitForDocLoadAndStopIt", { uri }); + } else { + setTimeout(stopContent.bind(null, true, uri), 0); + } + } + + let progressListener = { + onStateChange: function (webProgress, req, flags, status) { + dump("waitForDocLoadAndStopIt: onStateChange " + flags.toString(16) + ": " + req.name + "\n"); + + if (webProgress.isTopLevel && + flags & Ci.nsIWebProgressListener.STATE_START) { + wp.removeProgressListener(progressListener); + + let chan = req.QueryInterface(Ci.nsIChannel); + dump(`waitForDocLoadAndStopIt: Document start: ${chan.URI.spec}\n`); + + stopContent(aStopFromProgressListener, chan.originalURI.spec); + } + }, + QueryInterface: XPCOMUtils.generateQI(["nsISupportsWeakReference"]) + }; + wp.addProgressListener(progressListener, wp.NOTIFY_STATE_WINDOW); + + /** + * As |this| is undefined and we can't extend |docShell|, adding an unload + * event handler is the easiest way to ensure the weakly referenced + * progress listener is kept alive as long as necessary. + */ + addEventListener("unload", function () { + try { + wp.removeProgressListener(progressListener); + } catch (e) { /* Will most likely fail. */ } + }); + } + + return new Promise((resolve, reject) => { + function complete({ data }) { + is(data.uri, aExpectedURL, "waitForDocLoadAndStopIt: The expected URL was loaded"); + mm.removeMessageListener("Test:WaitForDocLoadAndStopIt", complete); + resolve(); + } + + let mm = aBrowser.messageManager; + mm.loadFrameScript("data:,(" + content_script.toString() + ")(" + aStopFromProgressListener + ");", true); + mm.addMessageListener("Test:WaitForDocLoadAndStopIt", complete); + info("waitForDocLoadAndStopIt: Waiting for URL: " + aExpectedURL); + }); +} + +function is_hidden(element) { + var style = element.ownerGlobal.getComputedStyle(element); + if (style.display == "none") + return true; + if (style.visibility != "visible") + return true; + if (style.display == "-moz-popup") + return ["hiding", "closed"].indexOf(element.state) != -1; + + // Hiding a parent element will hide all its children + if (element.parentNode != element.ownerDocument) + return is_hidden(element.parentNode); + + return false; +} + +function is_visible(element) { + var style = element.ownerGlobal.getComputedStyle(element); + if (style.display == "none") + return false; + if (style.visibility != "visible") + return false; + if (style.display == "-moz-popup" && element.state != "open") + return false; + + // Hiding a parent element will hide all its children + if (element.parentNode != element.ownerDocument) + return is_visible(element.parentNode); + + return true; +} + +function is_element_visible(element, msg) { + isnot(element, null, "Element should not be null, when checking visibility"); + ok(is_visible(element), msg || "Element should be visible"); +} + +function is_element_hidden(element, msg) { + isnot(element, null, "Element should not be null, when checking visibility"); + ok(is_hidden(element), msg || "Element should be hidden"); +} + +function promisePopupEvent(popup, eventSuffix) { + let endState = {shown: "open", hidden: "closed"}[eventSuffix]; + + if (popup.state == endState) + return Promise.resolve(); + + let eventType = "popup" + eventSuffix; + let deferred = Promise.defer(); + popup.addEventListener(eventType, function onPopupShown(event) { + popup.removeEventListener(eventType, onPopupShown); + deferred.resolve(); + }); + + return deferred.promise; +} + +function promisePopupShown(popup) { + return promisePopupEvent(popup, "shown"); +} + +function promisePopupHidden(popup) { + return promisePopupEvent(popup, "hidden"); +} + +function promiseSearchComplete(win = window) { + return promisePopupShown(win.gURLBar.popup).then(() => { + function searchIsComplete() { + return win.gURLBar.controller.searchStatus >= + Ci.nsIAutoCompleteController.STATUS_COMPLETE_NO_MATCH; + } + + // Wait until there are at least two matches. + return BrowserTestUtils.waitForCondition(searchIsComplete, "waiting urlbar search to complete"); + }); +} + +function promiseAutocompleteResultPopup(inputText, + win = window, + fireInputEvent = false) { + waitForFocus(() => { + win.gURLBar.focus(); + win.gURLBar.value = inputText; + if (fireInputEvent) { + // This is necessary to get the urlbar to set gBrowser.userTypedValue. + let event = document.createEvent("Events"); + event.initEvent("input", true, true); + win.gURLBar.dispatchEvent(event); + } + win.gURLBar.controller.startSearch(inputText); + }, win); + + return promiseSearchComplete(win); +} + +function promiseNewSearchEngine(basename) { + return new Promise((resolve, reject) => { + info("Waiting for engine to be added: " + basename); + let url = getRootDirectory(gTestPath) + basename; + Services.search.addEngine(url, null, "", false, { + onSuccess: function (engine) { + info("Search engine added: " + basename); + registerCleanupFunction(() => Services.search.removeEngine(engine)); + resolve(engine); + }, + onError: function (errCode) { + Assert.ok(false, "addEngine failed with error code " + errCode); + reject(); + }, + }); + }); +} + diff --git a/browser/base/content/test/urlbar/moz.png b/browser/base/content/test/urlbar/moz.png Binary files differnew file mode 100644 index 000000000..769c63634 --- /dev/null +++ b/browser/base/content/test/urlbar/moz.png diff --git a/browser/base/content/test/urlbar/print_postdata.sjs b/browser/base/content/test/urlbar/print_postdata.sjs new file mode 100644 index 000000000..4175a2480 --- /dev/null +++ b/browser/base/content/test/urlbar/print_postdata.sjs @@ -0,0 +1,22 @@ +const CC = Components.Constructor; +const BinaryInputStream = CC("@mozilla.org/binaryinputstream;1", + "nsIBinaryInputStream", + "setInputStream"); + +function handleRequest(request, response) { + response.setHeader("Content-Type", "text/plain", false); + if (request.method == "GET") { + response.write(request.queryString); + } else { + var body = new BinaryInputStream(request.bodyInputStream); + + var avail; + var bytes = []; + + while ((avail = body.available()) > 0) + Array.prototype.push.apply(bytes, body.readByteArray(avail)); + + var data = String.fromCharCode.apply(null, bytes); + response.bodyOutputStream.write(data, data.length); + } +} diff --git a/browser/base/content/test/urlbar/redirect_bug623155.sjs b/browser/base/content/test/urlbar/redirect_bug623155.sjs new file mode 100644 index 000000000..64c6f143b --- /dev/null +++ b/browser/base/content/test/urlbar/redirect_bug623155.sjs @@ -0,0 +1,16 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ + +const REDIRECT_TO = "https://www.bank1.com/"; // Bad-cert host. + +function handleRequest(aRequest, aResponse) { + // Set HTTP Status + aResponse.setStatusLine(aRequest.httpVersion, 301, "Moved Permanently"); + + // Set redirect URI, mirroring the hash value. + let hash = (/\#.+/.test(aRequest.path))? + "#" + aRequest.path.split("#")[1]: + ""; + aResponse.setHeader("Location", REDIRECT_TO + hash); +} diff --git a/browser/base/content/test/urlbar/searchSuggestionEngine.sjs b/browser/base/content/test/urlbar/searchSuggestionEngine.sjs new file mode 100644 index 000000000..1978b4f66 --- /dev/null +++ b/browser/base/content/test/urlbar/searchSuggestionEngine.sjs @@ -0,0 +1,9 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +function handleRequest(req, resp) { + let suffixes = ["foo", "bar"]; + let data = [req.queryString, suffixes.map(s => req.queryString + s)]; + resp.setHeader("Content-Type", "application/json", false); + resp.write(JSON.stringify(data)); +} diff --git a/browser/base/content/test/urlbar/searchSuggestionEngine.xml b/browser/base/content/test/urlbar/searchSuggestionEngine.xml new file mode 100644 index 000000000..a5659792e --- /dev/null +++ b/browser/base/content/test/urlbar/searchSuggestionEngine.xml @@ -0,0 +1,9 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> + +<SearchPlugin xmlns="http://www.mozilla.org/2006/browser/search/"> +<ShortName>browser_searchSuggestionEngine searchSuggestionEngine.xml</ShortName> +<Url type="application/x-suggestions+json" method="GET" template="http://mochi.test:8888/browser/browser/base/content/test/urlbar/searchSuggestionEngine.sjs?{searchTerms}"/> +<Url type="text/html" method="GET" template="http://mochi.test:8888/" rel="searchform"/> +</SearchPlugin> diff --git a/browser/base/content/test/urlbar/slow-page.sjs b/browser/base/content/test/urlbar/slow-page.sjs new file mode 100644 index 000000000..f428d66e4 --- /dev/null +++ b/browser/base/content/test/urlbar/slow-page.sjs @@ -0,0 +1,22 @@ +"use strict"; + +const Cc = Components.classes; +const Ci = Components.interfaces; + +let timer; + +const DELAY_MS = 5000; +function handleRequest(request, response) { + if (request.queryString.endsWith("faster")) { + response.setHeader("Content-Type", "text/html", false); + response.write("<body>Not so slow!</body>"); + return; + } + response.processAsync(); + timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + timer.init(() => { + response.setHeader("Content-Type", "text/html", false); + response.write("<body>This was the slow load. You should never see this.</body>"); + response.finish(); + }, DELAY_MS, Ci.nsITimer.TYPE_ONE_SHOT); +} diff --git a/browser/base/content/test/urlbar/test_wyciwyg_copying.html b/browser/base/content/test/urlbar/test_wyciwyg_copying.html new file mode 100644 index 000000000..3a8c3a150 --- /dev/null +++ b/browser/base/content/test/urlbar/test_wyciwyg_copying.html @@ -0,0 +1,13 @@ +<html> +<body> +<script> + function go() { + var w = window.open(); + w.document.open(); + w.document.write("<html><body>test document</body></html>"); + w.document.close(); + } +</script> +<button id="btn" onclick="go();">test</button> +</body> +</html> |
