forked from mirrors/gecko-dev
692 lines
19 KiB
JavaScript
692 lines
19 KiB
JavaScript
/**
|
|
* These tests test the ability for the PermissionUI module to open
|
|
* permission prompts to the user. It also tests to ensure that
|
|
* add-ons can introduce their own permission prompts.
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
const { PermissionUI } = ChromeUtils.importESModule(
|
|
"resource:///modules/PermissionUI.sys.mjs"
|
|
);
|
|
|
|
const { PermissionTestUtils } = ChromeUtils.importESModule(
|
|
"resource://testing-common/PermissionTestUtils.sys.mjs"
|
|
);
|
|
|
|
/**
|
|
* Tests the PermissionPromptForRequest prototype to ensure that a prompt
|
|
* can be displayed. Does not test permission handling.
|
|
*/
|
|
add_task(async function test_permission_prompt_for_request() {
|
|
await BrowserTestUtils.withNewTab(
|
|
{
|
|
gBrowser,
|
|
url: "http://example.com/",
|
|
},
|
|
async function (browser) {
|
|
const kTestNotificationID = "test-notification";
|
|
const kTestMessage = "Test message";
|
|
let mainAction = {
|
|
label: "Main",
|
|
accessKey: "M",
|
|
};
|
|
let secondaryAction = {
|
|
label: "Secondary",
|
|
accessKey: "S",
|
|
};
|
|
|
|
let mockRequest = makeMockPermissionRequest(browser);
|
|
class TestPrompt extends PermissionUI.PermissionPromptForRequest {
|
|
get request() {
|
|
return mockRequest;
|
|
}
|
|
get notificationID() {
|
|
return kTestNotificationID;
|
|
}
|
|
get message() {
|
|
return kTestMessage;
|
|
}
|
|
get promptActions() {
|
|
return [mainAction, secondaryAction];
|
|
}
|
|
}
|
|
let shownPromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popupshown"
|
|
);
|
|
new TestPrompt().prompt();
|
|
await shownPromise;
|
|
let notification = PopupNotifications.getNotification(
|
|
kTestNotificationID,
|
|
browser
|
|
);
|
|
Assert.ok(notification, "Should have gotten the notification");
|
|
|
|
Assert.equal(
|
|
notification.message,
|
|
kTestMessage,
|
|
"Should be showing the right message"
|
|
);
|
|
Assert.equal(
|
|
notification.mainAction.label,
|
|
mainAction.label,
|
|
"The main action should have the right label"
|
|
);
|
|
Assert.equal(
|
|
notification.mainAction.accessKey,
|
|
mainAction.accessKey,
|
|
"The main action should have the right access key"
|
|
);
|
|
Assert.equal(
|
|
notification.secondaryActions.length,
|
|
1,
|
|
"There should only be 1 secondary action"
|
|
);
|
|
Assert.equal(
|
|
notification.secondaryActions[0].label,
|
|
secondaryAction.label,
|
|
"The secondary action should have the right label"
|
|
);
|
|
Assert.equal(
|
|
notification.secondaryActions[0].accessKey,
|
|
secondaryAction.accessKey,
|
|
"The secondary action should have the right access key"
|
|
);
|
|
Assert.ok(
|
|
notification.options.displayURI.equals(mockRequest.principal.URI),
|
|
"Should be showing the URI of the requesting page"
|
|
);
|
|
|
|
let removePromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popuphidden"
|
|
);
|
|
notification.remove();
|
|
await removePromise;
|
|
}
|
|
);
|
|
});
|
|
|
|
/**
|
|
* Tests that if the PermissionPrompt sets displayURI to false in popupOptions,
|
|
* then there is no URI shown on the popupnotification.
|
|
*/
|
|
add_task(async function test_permission_prompt_for_popupOptions() {
|
|
await BrowserTestUtils.withNewTab(
|
|
{
|
|
gBrowser,
|
|
url: "http://example.com/",
|
|
},
|
|
async function (browser) {
|
|
const kTestNotificationID = "test-notification";
|
|
const kTestMessage = "Test message";
|
|
let mainAction = {
|
|
label: "Main",
|
|
accessKey: "M",
|
|
};
|
|
let secondaryAction = {
|
|
label: "Secondary",
|
|
accessKey: "S",
|
|
};
|
|
|
|
let mockRequest = makeMockPermissionRequest(browser);
|
|
class TestPrompt extends PermissionUI.PermissionPromptForRequest {
|
|
get request() {
|
|
return mockRequest;
|
|
}
|
|
get notificationID() {
|
|
return kTestNotificationID;
|
|
}
|
|
get message() {
|
|
return kTestMessage;
|
|
}
|
|
get promptActions() {
|
|
return [mainAction, secondaryAction];
|
|
}
|
|
get popupOptions() {
|
|
return {
|
|
displayURI: false,
|
|
};
|
|
}
|
|
}
|
|
let shownPromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popupshown"
|
|
);
|
|
new TestPrompt().prompt();
|
|
await shownPromise;
|
|
let notification = PopupNotifications.getNotification(
|
|
kTestNotificationID,
|
|
browser
|
|
);
|
|
|
|
Assert.ok(
|
|
!notification.options.displayURI,
|
|
"Should not show the URI of the requesting page"
|
|
);
|
|
|
|
let removePromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popuphidden"
|
|
);
|
|
notification.remove();
|
|
await removePromise;
|
|
}
|
|
);
|
|
});
|
|
|
|
/**
|
|
* Tests that if the PermissionPrompt has the permissionKey
|
|
* set that permissions can be set properly by the user. Also
|
|
* ensures that callbacks for promptActions are properly fired.
|
|
*/
|
|
add_task(async function test_with_permission_key() {
|
|
await BrowserTestUtils.withNewTab(
|
|
{
|
|
gBrowser,
|
|
url: "http://example.com",
|
|
},
|
|
async function (browser) {
|
|
const kTestNotificationID = "test-notification";
|
|
const kTestMessage = "Test message";
|
|
const kTestPermissionKey = "test-permission-key";
|
|
|
|
let allowed = false;
|
|
let mainAction = {
|
|
label: "Allow",
|
|
accessKey: "M",
|
|
action: SitePermissions.ALLOW,
|
|
callback() {
|
|
allowed = true;
|
|
},
|
|
};
|
|
|
|
let denied = false;
|
|
let secondaryAction = {
|
|
label: "Deny",
|
|
accessKey: "D",
|
|
action: SitePermissions.BLOCK,
|
|
callback() {
|
|
denied = true;
|
|
},
|
|
};
|
|
|
|
let mockRequest = makeMockPermissionRequest(browser);
|
|
let principal = mockRequest.principal;
|
|
registerCleanupFunction(function () {
|
|
PermissionTestUtils.remove(principal.URI, kTestPermissionKey);
|
|
});
|
|
class TestPrompt extends PermissionUI.PermissionPromptForRequest {
|
|
get request() {
|
|
return mockRequest;
|
|
}
|
|
get notificationID() {
|
|
return kTestNotificationID;
|
|
}
|
|
get permissionKey() {
|
|
return kTestPermissionKey;
|
|
}
|
|
get message() {
|
|
return kTestMessage;
|
|
}
|
|
get promptActions() {
|
|
return [mainAction, secondaryAction];
|
|
}
|
|
get popupOptions() {
|
|
return {
|
|
checkbox: {
|
|
label: "Remember this decision",
|
|
show: true,
|
|
checked: true,
|
|
},
|
|
};
|
|
}
|
|
}
|
|
let shownPromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popupshown"
|
|
);
|
|
new TestPrompt().prompt();
|
|
await shownPromise;
|
|
let notification = PopupNotifications.getNotification(
|
|
kTestNotificationID,
|
|
browser
|
|
);
|
|
Assert.ok(notification, "Should have gotten the notification");
|
|
|
|
let curPerm = SitePermissions.getForPrincipal(
|
|
principal,
|
|
kTestPermissionKey,
|
|
browser
|
|
);
|
|
Assert.equal(
|
|
curPerm.state,
|
|
SitePermissions.UNKNOWN,
|
|
"Should be no permission set to begin with."
|
|
);
|
|
|
|
// First test denying the permission request without the checkbox checked.
|
|
let popupNotification = getPopupNotificationNode();
|
|
popupNotification.checkbox.checked = false;
|
|
|
|
Assert.equal(
|
|
notification.secondaryActions.length,
|
|
1,
|
|
"There should only be 1 secondary action"
|
|
);
|
|
await clickSecondaryAction();
|
|
curPerm = SitePermissions.getForPrincipal(
|
|
principal,
|
|
kTestPermissionKey,
|
|
browser
|
|
);
|
|
Assert.deepEqual(
|
|
curPerm,
|
|
{
|
|
state: SitePermissions.BLOCK,
|
|
scope: SitePermissions.SCOPE_TEMPORARY,
|
|
},
|
|
"Should have denied the action temporarily"
|
|
);
|
|
// Try getting the permission without passing the browser object (should fail).
|
|
curPerm = PermissionTestUtils.getPermissionObject(
|
|
principal.URI,
|
|
kTestPermissionKey
|
|
);
|
|
Assert.equal(
|
|
curPerm,
|
|
null,
|
|
"Should have made no permanent permission entry"
|
|
);
|
|
Assert.ok(denied, "The secondaryAction callback should have fired");
|
|
Assert.ok(!allowed, "The mainAction callback should not have fired");
|
|
Assert.ok(
|
|
mockRequest._cancelled,
|
|
"The request should have been cancelled"
|
|
);
|
|
Assert.ok(
|
|
!mockRequest._allowed,
|
|
"The request should not have been allowed"
|
|
);
|
|
|
|
// Clear the permission and pretend we never denied
|
|
SitePermissions.removeFromPrincipal(
|
|
principal,
|
|
kTestPermissionKey,
|
|
browser
|
|
);
|
|
denied = false;
|
|
mockRequest._cancelled = false;
|
|
|
|
// Bring the PopupNotification back up now...
|
|
shownPromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popupshown"
|
|
);
|
|
new TestPrompt().prompt();
|
|
await shownPromise;
|
|
|
|
// Test denying the permission request.
|
|
Assert.equal(
|
|
notification.secondaryActions.length,
|
|
1,
|
|
"There should only be 1 secondary action"
|
|
);
|
|
await clickSecondaryAction();
|
|
curPerm = PermissionTestUtils.getPermissionObject(
|
|
principal.URI,
|
|
kTestPermissionKey
|
|
);
|
|
Assert.equal(
|
|
curPerm.capability,
|
|
Services.perms.DENY_ACTION,
|
|
"Should have denied the action"
|
|
);
|
|
Assert.equal(curPerm.expireTime, 0, "Deny should be permanent");
|
|
Assert.ok(denied, "The secondaryAction callback should have fired");
|
|
Assert.ok(!allowed, "The mainAction callback should not have fired");
|
|
Assert.ok(
|
|
mockRequest._cancelled,
|
|
"The request should have been cancelled"
|
|
);
|
|
Assert.ok(
|
|
!mockRequest._allowed,
|
|
"The request should not have been allowed"
|
|
);
|
|
|
|
// Clear the permission and pretend we never denied
|
|
PermissionTestUtils.remove(principal.URI, kTestPermissionKey);
|
|
denied = false;
|
|
mockRequest._cancelled = false;
|
|
|
|
// Bring the PopupNotification back up now...
|
|
shownPromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popupshown"
|
|
);
|
|
new TestPrompt().prompt();
|
|
await shownPromise;
|
|
|
|
// Test allowing the permission request.
|
|
await clickMainAction();
|
|
curPerm = PermissionTestUtils.getPermissionObject(
|
|
principal.URI,
|
|
kTestPermissionKey
|
|
);
|
|
Assert.equal(
|
|
curPerm.capability,
|
|
Services.perms.ALLOW_ACTION,
|
|
"Should have allowed the action"
|
|
);
|
|
Assert.equal(curPerm.expireTime, 0, "Allow should be permanent");
|
|
Assert.ok(!denied, "The secondaryAction callback should not have fired");
|
|
Assert.ok(allowed, "The mainAction callback should have fired");
|
|
Assert.ok(
|
|
!mockRequest._cancelled,
|
|
"The request should not have been cancelled"
|
|
);
|
|
Assert.ok(mockRequest._allowed, "The request should have been allowed");
|
|
}
|
|
);
|
|
});
|
|
|
|
/**
|
|
* Tests that the onBeforeShow method will be called before
|
|
* the popup appears.
|
|
*/
|
|
add_task(async function test_on_before_show() {
|
|
await BrowserTestUtils.withNewTab(
|
|
{
|
|
gBrowser,
|
|
url: "http://example.com",
|
|
},
|
|
async function (browser) {
|
|
const kTestNotificationID = "test-notification";
|
|
const kTestMessage = "Test message";
|
|
|
|
let mainAction = {
|
|
label: "Test action",
|
|
accessKey: "T",
|
|
};
|
|
|
|
let mockRequest = makeMockPermissionRequest(browser);
|
|
let beforeShown = false;
|
|
class TestPrompt extends PermissionUI.PermissionPromptForRequest {
|
|
get request() {
|
|
return mockRequest;
|
|
}
|
|
get notificationID() {
|
|
return kTestNotificationID;
|
|
}
|
|
get message() {
|
|
return kTestMessage;
|
|
}
|
|
get promptActions() {
|
|
return [mainAction];
|
|
}
|
|
get popupOptions() {
|
|
return {
|
|
checkbox: {
|
|
label: "Remember this decision",
|
|
show: true,
|
|
checked: true,
|
|
},
|
|
};
|
|
}
|
|
onBeforeShow() {
|
|
beforeShown = true;
|
|
return true;
|
|
}
|
|
}
|
|
let shownPromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popupshown"
|
|
);
|
|
new TestPrompt().prompt();
|
|
Assert.ok(beforeShown, "Should have called onBeforeShown");
|
|
await shownPromise;
|
|
let notification = PopupNotifications.getNotification(
|
|
kTestNotificationID,
|
|
browser
|
|
);
|
|
|
|
let removePromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popuphidden"
|
|
);
|
|
notification.remove();
|
|
await removePromise;
|
|
}
|
|
);
|
|
});
|
|
|
|
/**
|
|
* Tests that we can open a PermissionPrompt without wrapping a
|
|
* nsIContentPermissionRequest.
|
|
*/
|
|
add_task(async function test_no_request() {
|
|
await BrowserTestUtils.withNewTab(
|
|
{
|
|
gBrowser,
|
|
url: "http://example.com",
|
|
},
|
|
async function (browser) {
|
|
const kTestNotificationID = "test-notification";
|
|
let allowed = false;
|
|
let mainAction = {
|
|
label: "Allow",
|
|
accessKey: "M",
|
|
callback() {
|
|
allowed = true;
|
|
},
|
|
};
|
|
|
|
let denied = false;
|
|
let secondaryAction = {
|
|
label: "Deny",
|
|
accessKey: "D",
|
|
callback() {
|
|
denied = true;
|
|
},
|
|
};
|
|
|
|
const kTestMessage = "Test message with no request";
|
|
let principal = browser.contentPrincipal;
|
|
let beforeShown = false;
|
|
class TestPrompt extends PermissionUI.PermissionPromptForRequest {
|
|
get notificationID() {
|
|
return kTestNotificationID;
|
|
}
|
|
get principal() {
|
|
return principal;
|
|
}
|
|
get browser() {
|
|
return browser;
|
|
}
|
|
get message() {
|
|
return kTestMessage;
|
|
}
|
|
get promptActions() {
|
|
return [mainAction, secondaryAction];
|
|
}
|
|
onBeforeShow() {
|
|
beforeShown = true;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
let shownPromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popupshown"
|
|
);
|
|
new TestPrompt().prompt();
|
|
Assert.ok(beforeShown, "Should have called onBeforeShown");
|
|
await shownPromise;
|
|
let notification = PopupNotifications.getNotification(
|
|
kTestNotificationID,
|
|
browser
|
|
);
|
|
|
|
Assert.equal(
|
|
notification.message,
|
|
kTestMessage,
|
|
"Should be showing the right message"
|
|
);
|
|
Assert.equal(
|
|
notification.mainAction.label,
|
|
mainAction.label,
|
|
"The main action should have the right label"
|
|
);
|
|
Assert.equal(
|
|
notification.mainAction.accessKey,
|
|
mainAction.accessKey,
|
|
"The main action should have the right access key"
|
|
);
|
|
Assert.equal(
|
|
notification.secondaryActions.length,
|
|
1,
|
|
"There should only be 1 secondary action"
|
|
);
|
|
Assert.equal(
|
|
notification.secondaryActions[0].label,
|
|
secondaryAction.label,
|
|
"The secondary action should have the right label"
|
|
);
|
|
Assert.equal(
|
|
notification.secondaryActions[0].accessKey,
|
|
secondaryAction.accessKey,
|
|
"The secondary action should have the right access key"
|
|
);
|
|
Assert.ok(
|
|
notification.options.displayURI.equals(principal.URI),
|
|
"Should be showing the URI of the requesting page"
|
|
);
|
|
|
|
// First test denying the permission request.
|
|
Assert.equal(
|
|
notification.secondaryActions.length,
|
|
1,
|
|
"There should only be 1 secondary action"
|
|
);
|
|
await clickSecondaryAction();
|
|
Assert.ok(denied, "The secondaryAction callback should have fired");
|
|
Assert.ok(!allowed, "The mainAction callback should not have fired");
|
|
|
|
shownPromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popupshown"
|
|
);
|
|
new TestPrompt().prompt();
|
|
await shownPromise;
|
|
|
|
// Next test allowing the permission request.
|
|
await clickMainAction();
|
|
Assert.ok(allowed, "The mainAction callback should have fired");
|
|
}
|
|
);
|
|
});
|
|
|
|
/**
|
|
* Tests that when the tab is moved to a different window, the notification
|
|
* is transferred to the new window.
|
|
*/
|
|
add_task(async function test_window_swap() {
|
|
await BrowserTestUtils.withNewTab(
|
|
{
|
|
gBrowser,
|
|
url: "http://example.com",
|
|
},
|
|
async function (browser) {
|
|
const kTestNotificationID = "test-notification";
|
|
const kTestMessage = "Test message";
|
|
|
|
let mainAction = {
|
|
label: "Test action",
|
|
accessKey: "T",
|
|
};
|
|
let secondaryAction = {
|
|
label: "Secondary",
|
|
accessKey: "S",
|
|
};
|
|
|
|
let mockRequest = makeMockPermissionRequest(browser);
|
|
class TestPrompt extends PermissionUI.PermissionPromptForRequest {
|
|
get request() {
|
|
return mockRequest;
|
|
}
|
|
get notificationID() {
|
|
return kTestNotificationID;
|
|
}
|
|
get message() {
|
|
return kTestMessage;
|
|
}
|
|
get promptActions() {
|
|
return [mainAction, secondaryAction];
|
|
}
|
|
}
|
|
let shownPromise = BrowserTestUtils.waitForEvent(
|
|
PopupNotifications.panel,
|
|
"popupshown"
|
|
);
|
|
new TestPrompt().prompt();
|
|
await shownPromise;
|
|
|
|
let newWindowOpened = BrowserTestUtils.waitForNewWindow();
|
|
gBrowser.replaceTabWithWindow(gBrowser.selectedTab);
|
|
let newWindow = await newWindowOpened;
|
|
// We may have already opened the panel, because it was open before we moved the tab.
|
|
if (newWindow.PopupNotifications.panel.state != "open") {
|
|
shownPromise = BrowserTestUtils.waitForEvent(
|
|
newWindow.PopupNotifications.panel,
|
|
"popupshown"
|
|
);
|
|
new TestPrompt().prompt();
|
|
await shownPromise;
|
|
}
|
|
|
|
let notification = newWindow.PopupNotifications.getNotification(
|
|
kTestNotificationID,
|
|
newWindow.gBrowser.selectedBrowser
|
|
);
|
|
Assert.ok(notification, "Should have gotten the notification");
|
|
|
|
Assert.equal(
|
|
notification.message,
|
|
kTestMessage,
|
|
"Should be showing the right message"
|
|
);
|
|
Assert.equal(
|
|
notification.mainAction.label,
|
|
mainAction.label,
|
|
"The main action should have the right label"
|
|
);
|
|
Assert.equal(
|
|
notification.mainAction.accessKey,
|
|
mainAction.accessKey,
|
|
"The main action should have the right access key"
|
|
);
|
|
Assert.equal(
|
|
notification.secondaryActions.length,
|
|
1,
|
|
"There should only be 1 secondary action"
|
|
);
|
|
Assert.equal(
|
|
notification.secondaryActions[0].label,
|
|
secondaryAction.label,
|
|
"The secondary action should have the right label"
|
|
);
|
|
Assert.equal(
|
|
notification.secondaryActions[0].accessKey,
|
|
secondaryAction.accessKey,
|
|
"The secondary action should have the right access key"
|
|
);
|
|
Assert.ok(
|
|
notification.options.displayURI.equals(mockRequest.principal.URI),
|
|
"Should be showing the URI of the requesting page"
|
|
);
|
|
|
|
await BrowserTestUtils.closeWindow(newWindow);
|
|
}
|
|
);
|
|
});
|