diff options
Diffstat (limited to 'comm/suite/components/tests/browser/browser_522545.js')
-rw-r--r-- | comm/suite/components/tests/browser/browser_522545.js | 280 |
1 files changed, 280 insertions, 0 deletions
diff --git a/comm/suite/components/tests/browser/browser_522545.js b/comm/suite/components/tests/browser/browser_522545.js new file mode 100644 index 0000000000..9088c88c81 --- /dev/null +++ b/comm/suite/components/tests/browser/browser_522545.js @@ -0,0 +1,280 @@ +/* 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 browserWindowsCount() { + let count = 0; + let e = Services.wm.getEnumerator("navigator:browser"); + while (e.hasMoreElements()) { + if (!e.getNext().closed) + ++count; + } + return count; +} + +function test() { + /** Test for Bug 522545 **/ + is(browserWindowsCount(), 1, "Only one browser window should be open initially"); + + waitForExplicitFinish(); + requestLongerTimeout(2); + + // This tests the following use case: + // User opens a new tab which gets focus. The user types something into the + // address bar, then crashes or quits. + function test_newTabFocused() { + let state = { + windows: [{ + tabs: [ + { entries: [{ url: "about:mozilla" }] }, + { entries: [], userTypedValue: "example.com", userTypedClear: 0 } + ], + selected: 2 + }] + }; + + waitForBrowserState(state, function() { + let browser = getBrowser().selectedBrowser; + is(browser.currentURI.spec, "about:blank", + "No history entries still sets currentURI to about:blank"); + is(browser.userTypedValue, "example.com", + "userTypedValue was correctly restored"); + is(browser.userTypedClear, 0, + "userTypeClear restored as expected"); + is(gURLBar.value, "example.com", + "Address bar's value correctly restored"); + // Change tabs to make sure address bar value gets updated + getBrowser().selectedTab = getBrowser().tabContainer.getItemAtIndex(0); + is(gURLBar.value, "about:mozilla", + "Address bar's value correctly updated"); + runNextTest(); + }); + } + + // This tests the following use case: + // User opens a new tab which gets focus. The user types something into the + // address bar, switches back to the first tab, then crashes or quits. + function test_newTabNotFocused() { + let state = { + windows: [{ + tabs: [ + { entries: [{ url: "about:mozilla" }] }, + { entries: [], userTypedValue: "example.org", userTypedClear: 0 } + ], + selected: 1 + }] + }; + + waitForBrowserState(state, function() { + let browser = getBrowser().getBrowserAtIndex(1); + is(browser.currentURI.spec, "about:blank", + "No history entries still sets currentURI to about:blank"); + is(browser.userTypedValue, "example.org", + "userTypedValue was correctly restored"); + is(browser.userTypedClear, 0, + "userTypeClear restored as expected"); + is(gURLBar.value, "about:mozilla", + "Address bar's value correctly restored"); + // Change tabs to make sure address bar value gets updated + getBrowser().selectedTab = getBrowser().tabContainer.getItemAtIndex(1); + is(gURLBar.value, "example.org", + "Address bar's value correctly updated"); + runNextTest(); + }); + } + + // This tests the following use case: + // User is in a tab with session history, then types something in the + // address bar, then crashes or quits. + function test_existingSHEnd_noClear() { + let state = { + windows: [{ + tabs: [{ + entries: [{ url: "about:mozilla" }, { url: "about:config" }], + index: 2, + userTypedValue: "example.com", + userTypedClear: 0 + }] + }] + }; + + waitForBrowserState(state, function() { + let browser = getBrowser().selectedBrowser; + is(browser.currentURI.spec, "about:config", + "browser.currentURI set to current entry in SH"); + is(browser.userTypedValue, "example.com", + "userTypedValue was correctly restored"); + is(browser.userTypedClear, 0, + "userTypeClear restored as expected"); + is(gURLBar.value, "example.com", + "Address bar's value correctly restored to userTypedValue"); + runNextTest(); + }); + } + + // This tests the following use case: + // User is in a tab with session history, presses back at some point, then + // types something in the address bar, then crashes or quits. + function test_existingSHMiddle_noClear() { + let state = { + windows: [{ + tabs: [{ + entries: [{ url: "about:mozilla" }, { url: "about:config" }], + index: 1, + userTypedValue: "example.org", + userTypedClear: 0 + }] + }] + }; + + waitForBrowserState(state, function() { + let browser = getBrowser().selectedBrowser; + is(browser.currentURI.spec, "about:mozilla", + "browser.currentURI set to current entry in SH"); + is(browser.userTypedValue, "example.org", + "userTypedValue was correctly restored"); + is(browser.userTypedClear, 0, + "userTypeClear restored as expected"); + is(gURLBar.value, "example.org", + "Address bar's value correctly restored to userTypedValue"); + runNextTest(); + }); + } + + // This test simulates lots of tabs opening at once and then quitting/crashing. + function test_getBrowserState_lotsOfTabsOpening() { + getBrowser().stop(); + + let uris = []; + for (let i = 0; i < 25; i++) + uris.push("http://example.com/" + i); + + // We're waiting for the first location change, which should indicate + // one of the tabs has loaded and the others haven't. So one should + // be in a non-userTypedValue case, while others should still have + // userTypedValue and userTypedClear set. + getBrowser().addTabsProgressListener({ + onLocationChange: function (aBrowser) { + if (uris.includes(aBrowser.currentURI.spec)) { + getBrowser().removeTabsProgressListener(this); + firstLocationChange(); + } + } + }); + + function firstLocationChange() { + let state = JSON.parse(ss.getBrowserState()); + let hasUTV = state.windows[0].tabs.some(function(aTab) { + return aTab.userTypedValue && aTab.userTypedClear && !aTab.entries.length; + }); + + ok(hasUTV, "At least one tab has a userTypedValue with userTypedClear with no loaded URL"); + + getBrowser().addEventListener("load", firstLoad, true); + } + + function firstLoad() { + getBrowser().removeEventListener("load", firstLoad, true); + + let state = JSON.parse(ss.getBrowserState()); + let hasSH = state.windows[0].tabs.some(function(aTab) { + return !("userTypedValue" in aTab) && aTab.entries[0].url; + }); + + ok(hasSH, "At least one tab has its entry in SH"); + + runNextTest(); + } + + getBrowser().loadTabs(uris); + } + + // This simulates setting a userTypedValue and ensures that just typing in the + // URL bar doesn't set userTypedClear as well. + function test_getBrowserState_userTypedValue() { + let state = { + windows: [{ + tabs: [{ entries: [] }] + }] + }; + + waitForBrowserState(state, function() { + let browser = getBrowser().selectedBrowser; + // Make sure this tab isn't loading and state is clear before we test. + is(browser.userTypedValue, null, "userTypedValue is empty to start"); + is(browser.userTypedClear, 0, "userTypedClear is 0 to start"); + + gURLBar.value = "example.org"; + let event = document.createEvent("Events"); + event.initEvent("input", true, false); + gURLBar.dispatchEvent(event); + + executeSoon(function() { + is(browser.userTypedValue, "example.org", + "userTypedValue was set when changing gURLBar.value"); + is(browser.userTypedClear, 0, + "userTypedClear was not changed when changing gURLBar.value"); + + // Now make sure ss gets these values too + let newState = JSON.parse(ss.getBrowserState()); + is(newState.windows[0].tabs[0].userTypedValue, "example.org", + "sessionstore got correct userTypedValue"); + is(newState.windows[0].tabs[0].userTypedClear, 0, + "sessionstore got correct userTypedClear"); + runNextTest(); + }); + }); + } + + // test_getBrowserState_lotsOfTabsOpening tested userTypedClear in a few cases, + // but not necessarily any that had legitimate URIs in the state of loading + // (eg, "http://example.com"), so this test will cover that case. + function test_userTypedClearLoadURI() { + let state = { + windows: [{ + tabs: [ + { entries: [], userTypedValue: "http://example.com", userTypedClear: 2 } + ] + }] + }; + + waitForBrowserState(state, function() { + let browser = gBrowser.selectedBrowser; + is(browser.currentURI.spec, "http://example.com/", + "userTypedClear=2 caused userTypedValue to be loaded"); + is(browser.userTypedValue, null, + "userTypedValue was null after loading a URI"); + is(browser.userTypedClear, 0, + "userTypeClear reset to 0"); + is(gURLBar.value, "http://example.com/", + "Address bar's value set after loading URI"); + runNextTest(); + }); + } + + + let tests = [test_newTabFocused, test_newTabNotFocused, + test_existingSHEnd_noClear, test_existingSHMiddle_noClear, + test_getBrowserState_lotsOfTabsOpening, + test_getBrowserState_userTypedValue, test_userTypedClearLoadURI]; + let originalState = ss.getBrowserState(); + let state = { + windows: [{ + tabs: [{ entries: [{ url: "about:blank" }] }] + }] + }; + function runNextTest() { + if (tests.length) { + waitForBrowserState(state, tests.shift()); + } else { + ss.setBrowserState(originalState); + executeSoon(function () { + is(browserWindowsCount(), 1, "Only one browser window should be open eventually"); + finish(); + }); + } + } + + // Run the tests! + runNextTest(); +} |