Source code
Revision control
Copy as Markdown
Other Tools
Test Info:
/* Any copyright is dedicated to the Public Domain.
"use strict";
// We don't use the mock service from head.js as we want a little more control over when the
// callback is called. We should try to consolidate, but one yak at a time.
let gMockAlertsService;
function createMockAlertsService() {
return {
clickCallback: null,
showAlert(alert, callback) {
this.clickCallback = callback;
},
simulateClick() {
if (this.clickCallback) {
this.clickCallback(null, "alertclickcallback");
this.clickCallback = null;
}
},
};
}
function sendOpenUriNotification(uris) {
let subject = {
wrappedJSObject: {
object: uris,
},
};
Services.obs.notifyObservers(subject, "fxaccounts:commands:open-uri");
}
add_setup(async function () {
const { AccountsGlue } = ChromeUtils.importESModule(
"resource:///modules/AccountsGlue.sys.mjs"
);
gMockAlertsService = createMockAlertsService();
const wrappedService = { wrappedJSObject: gMockAlertsService };
AccountsGlue.observe(
wrappedService,
"browser-glue-test",
"mock-alerts-service"
);
});
add_task(async function test_open_single_tab() {
let uris = [
{
uri: "https://example.com/single",
sender: { id: "device1", name: "Device 1" },
},
];
let tabPromise = BrowserTestUtils.waitForNewTab(
gBrowser,
false,
true
);
sendOpenUriNotification(uris);
let tab = await tabPromise;
Assert.ok(tab, "Tab opened");
Assert.ok(
!PrivateBrowsingUtils.isBrowserPrivate(tab.linkedBrowser),
"Tab is not private"
);
BrowserTestUtils.removeTab(tab);
});
add_task(async function test_open_multiple_tabs() {
let uris = [
{
uri: "https://example.org/1",
sender: { id: "device2", name: "Device 2" },
},
{
uri: "https://example.org/2",
sender: { id: "device2", name: "Device 2" },
},
{
uri: "https://example.org/3",
sender: { id: "device2", name: "Device 2" },
},
];
let tab1Promise = BrowserTestUtils.waitForNewTab(
gBrowser,
false,
true
);
let tab2Promise = BrowserTestUtils.waitForNewTab(
gBrowser,
false,
true
);
let tab3Promise = BrowserTestUtils.waitForNewTab(
gBrowser,
false,
true
);
sendOpenUriNotification(uris);
let tab1 = await tab1Promise;
let tab2 = await tab2Promise;
let tab3 = await tab3Promise;
Assert.ok(tab1, "First tab opened");
Assert.ok(tab2, "Second tab opened");
Assert.ok(tab3, "Third tab opened");
Assert.ok(
!PrivateBrowsingUtils.isBrowserPrivate(tab1.linkedBrowser),
"First tab is not private"
);
Assert.ok(
!PrivateBrowsingUtils.isBrowserPrivate(tab2.linkedBrowser),
"Second tab is not private"
);
Assert.ok(
!PrivateBrowsingUtils.isBrowserPrivate(tab3.linkedBrowser),
"Third tab is not private"
);
BrowserTestUtils.removeTab(tab1);
BrowserTestUtils.removeTab(tab2);
BrowserTestUtils.removeTab(tab3);
});
add_task(async function test_open_private_tabs() {
let privateWin = await BrowserTestUtils.openNewBrowserWindow({
private: true,
});
let uris = [
{
uri: "https://example.com/private1",
private: true,
sender: { id: "device3", name: "Device 3" },
},
{
uri: "https://example.com/private2",
private: true,
sender: { id: "device3", name: "Device 3" },
},
];
let tab1Promise = BrowserTestUtils.waitForNewTab(
privateWin.gBrowser,
false,
true
);
let tab2Promise = BrowserTestUtils.waitForNewTab(
privateWin.gBrowser,
false,
true
);
sendOpenUriNotification(uris);
let tab1 = await tab1Promise;
let tab2 = await tab2Promise;
Assert.ok(tab1, "First private tab opened");
Assert.ok(tab2, "Second private tab opened");
Assert.ok(
PrivateBrowsingUtils.isBrowserPrivate(tab1.linkedBrowser),
"First tab is private"
);
Assert.ok(
PrivateBrowsingUtils.isBrowserPrivate(tab2.linkedBrowser),
"Second tab is private"
);
BrowserTestUtils.removeTab(tab1);
BrowserTestUtils.removeTab(tab2);
await BrowserTestUtils.closeWindow(privateWin);
});
add_task(async function test_open_mixed_private_and_non_private_tabs() {
let privateWin = await BrowserTestUtils.openNewBrowserWindow({
private: true,
});
let uris = [
{
uri: "https://example.net/mixed1",
private: false,
sender: { id: "device4", name: "Device 4" },
},
{
uri: "https://example.net/mixed2",
private: true,
sender: { id: "device4", name: "Device 4" },
},
{
uri: "https://example.net/mixed3",
private: false,
sender: { id: "device4", name: "Device 4" },
},
];
let normalTab1Promise = BrowserTestUtils.waitForNewTab(
gBrowser,
false,
true
);
let privateTabPromise = BrowserTestUtils.waitForNewTab(
privateWin.gBrowser,
false,
true
);
let normalTab2Promise = BrowserTestUtils.waitForNewTab(
gBrowser,
false,
true
);
sendOpenUriNotification(uris);
let normalTab1 = await normalTab1Promise;
let privateTab = await privateTabPromise;
let normalTab2 = await normalTab2Promise;
Assert.ok(normalTab1, "First non-private tab opened");
Assert.ok(privateTab, "Private tab opened");
Assert.ok(normalTab2, "Second non-private tab opened");
Assert.ok(
!PrivateBrowsingUtils.isBrowserPrivate(normalTab1.linkedBrowser),
"First tab is not private"
);
Assert.ok(
PrivateBrowsingUtils.isBrowserPrivate(privateTab.linkedBrowser),
"Tab is private"
);
Assert.ok(
!PrivateBrowsingUtils.isBrowserPrivate(normalTab2.linkedBrowser),
"Third tab is not private"
);
BrowserTestUtils.removeTab(normalTab1);
BrowserTestUtils.removeTab(normalTab2);
await BrowserTestUtils.closeWindow(privateWin);
});
add_task(
async function test_notification_click_focuses_non_private_tab_first() {
let privateWin = await BrowserTestUtils.openNewBrowserWindow({
private: true,
});
let uris = [
{
uri: "https://example.com/focus1",
private: false,
sender: { id: "device5", name: "Device 5" },
},
{
uri: "https://example.com/focus2",
private: true,
sender: { id: "device5", name: "Device 5" },
},
];
let normalTabPromise = BrowserTestUtils.waitForNewTab(
gBrowser,
false,
true
);
let privateTabPromise = BrowserTestUtils.waitForNewTab(
privateWin.gBrowser,
false,
true
);
sendOpenUriNotification(uris);
let normalTab = await normalTabPromise;
let privateTab = await privateTabPromise;
Assert.notEqual(
gBrowser.selectedTab,
normalTab,
"Normal tab should not be selected initially"
);
gMockAlertsService.simulateClick();
await TestUtils.waitForCondition(
() => gBrowser.selectedTab === normalTab,
"Waiting for first (non-private) tab to be selected"
);
Assert.equal(
gBrowser.selectedTab,
normalTab,
"Clicking notification should focus first tab (non-private)"
);
// XXX - there was a test that `window == Services.wm.getMostRecentBrowserWindow()`, but that
// is apparently platform specific and so failed on Linux on CI.
BrowserTestUtils.removeTab(normalTab);
BrowserTestUtils.removeTab(privateTab);
await BrowserTestUtils.closeWindow(privateWin);
}
);
add_task(async function test_notification_click_focuses_private_tab_first() {
let privateWin = await BrowserTestUtils.openNewBrowserWindow({
private: true,
});
let uris = [
{
private: true,
sender: { id: "device6", name: "Device 6" },
},
{
private: false,
sender: { id: "device6", name: "Device 6" },
},
];
let privateTabPromise = BrowserTestUtils.waitForNewTab(
privateWin.gBrowser,
false,
true
);
let normalTabPromise = BrowserTestUtils.waitForNewTab(
gBrowser,
false,
true
);
sendOpenUriNotification(uris);
let privateTab = await privateTabPromise;
let normalTab = await normalTabPromise;
Assert.notEqual(
privateWin.gBrowser.selectedTab,
privateTab,
"Private tab should not be selected initially"
);
gMockAlertsService.simulateClick();
await TestUtils.waitForCondition(
() => privateWin.gBrowser.selectedTab === privateTab,
"Waiting for first (private) tab to be selected"
);
Assert.equal(
privateWin.gBrowser.selectedTab,
privateTab,
"Clicking notification should focus first tab (private)"
);
Assert.equal(
Services.wm.getMostRecentBrowserWindow(),
privateWin,
"Private window should be focused"
);
BrowserTestUtils.removeTab(privateTab);
BrowserTestUtils.removeTab(normalTab);
await BrowserTestUtils.closeWindow(privateWin);
});