firefox-main/toolkit/components/ipprotection/tests/xpcshell/test_IPPPermissionRuleProvider.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";
const { IPPPermissionRuleProvider } = ChromeUtils.importESModule(
"moz-src:///toolkit/components/ipprotection/IPPSiteRuleProviders.sys.mjs"
);
const PERM_NAME = "ipp-vpn";
const makePrincipal = origin =>
Services.scriptSecurityManager.createContentPrincipalFromOrigin(origin);
registerCleanupFunction(() => {
Services.perms.removeByType(PERM_NAME);
});
/**
* Runs body with an inited provider, and leaves no ipp-vpn permissions behind
* so the next task starts from a clean store.
*
* @param {Function} body
*/
async function withProvider(body) {
Services.perms.removeByType(PERM_NAME);
const provider = new IPPPermissionRuleProvider();
provider.init();
try {
await body(provider);
} finally {
provider.uninit();
Services.perms.removeByType(PERM_NAME);
}
}
/**
* Rules round-trip through the ipp-vpn permission type: an exclusion is a DENY
* permission, an inclusion is an ALLOW one, and DEFAULT removes the entry
* rather than storing a third state.
*/
add_task(async function test_rules_map_to_permission_capabilities() {
await withProvider(provider => {
const principal = makePrincipal("https://www.example.com");
provider.setRule(principal, IPPPrincipalRules.EXCLUDED);
Assert.equal(
provider.getPermissionObject(principal)?.capability,
Ci.nsIPermissionManager.DENY_ACTION,
"an exclusion is stored as DENY"
);
Assert.equal(
provider.getRule(principal),
IPPPrincipalRules.EXCLUDED,
"DENY reads back as EXCLUDED"
);
provider.setRule(principal, IPPPrincipalRules.INCLUDED);
Assert.equal(
provider.getPermissionObject(principal)?.capability,
Ci.nsIPermissionManager.ALLOW_ACTION,
"an inclusion is stored as ALLOW"
);
Assert.equal(
provider.getRule(principal),
IPPPrincipalRules.INCLUDED,
"ALLOW reads back as INCLUDED"
);
Assert.equal(
Services.perms.getAllByTypes([PERM_NAME]).length,
1,
"the exclusion was replaced, not stacked"
);
provider.setRule(principal, IPPPrincipalRules.DEFAULT);
Assert.ok(
!provider.getPermissionObject(principal),
"DEFAULT removes the permission"
);
Assert.equal(
provider.getRule(principal),
IPPPrincipalRules.DEFAULT,
"a site with no permission has no stored rule"
);
});
});
/**
* Rules are scoped to the exact host, not the base domain, so entering
* example.com in the preferences dialog does not silently cover
* www.example.com (see Bug 2016676).
*/
add_task(async function test_rules_are_scoped_to_the_exact_host() {
await withProvider(provider => {
const bare = makePrincipal("https://example.com");
const www = makePrincipal("https://www.example.com");
provider.setRule(bare, IPPPrincipalRules.EXCLUDED);
Assert.equal(
provider.getRule(bare),
IPPPrincipalRules.EXCLUDED,
"example.com is excluded"
);
Assert.equal(
provider.getRule(www),
IPPPrincipalRules.DEFAULT,
"www.example.com is untouched"
);
});
});
/**
* A store update tells the manager, including when a rule is cleared, so the
* UI can react to a site being removed as well as added.
*/
add_task(async function test_writes_notify() {
await withProvider(async provider => {
const principal = makePrincipal("https://notify.example.com");
let changed = waitForEvent(provider, "change");
provider.setRule(principal, IPPPrincipalRules.EXCLUDED);
await changed;
Assert.ok(true, "adding a rule notifies");
changed = waitForEvent(provider, "change");
provider.setRule(principal, IPPPrincipalRules.DEFAULT);
await changed;
Assert.ok(true, "clearing a rule notifies");
});
});
/**
* A write that would not change anything is dropped, so the UI does not get
* woken up for a no-op.
*/
add_task(async function test_redundant_write_is_dropped() {
await withProvider(provider => {
const principal = makePrincipal("https://redundant.example.com");
provider.setRule(principal, IPPPrincipalRules.EXCLUDED);
let seen = 0;
provider.addEventListener("change", () => seen++);
provider.setRule(principal, IPPPrincipalRules.EXCLUDED);
Assert.equal(seen, 0, "re-setting the same rule does not notify");
});
});
/**
* count reports each rule separately, so the UI can show how many sites the
* user has excluded without also counting the ones they included.
*/
add_task(async function test_count_is_per_rule() {
await withProvider(provider => {
Assert.equal(
provider.count(IPPPrincipalRules.INCLUDED),
0,
"no inclusions to start with"
);
provider.setRule(
makePrincipal("https://excluded.example.com"),
IPPPrincipalRules.EXCLUDED
);
const included = makePrincipal("https://included.example.com");
provider.setRule(included, IPPPrincipalRules.INCLUDED);
Assert.equal(
provider.count(IPPPrincipalRules.INCLUDED),
1,
"the inclusion is counted"
);
Assert.equal(
provider.count(IPPPrincipalRules.EXCLUDED),
1,
"the exclusion is counted separately"
);
provider.setRule(included, IPPPrincipalRules.DEFAULT);
Assert.equal(
provider.count(IPPPrincipalRules.INCLUDED),
0,
"removing the inclusion drops the count"
);
});
});
/**
* This is the writable provider, so it accepts any principal it can hang a
* permission on. Whether the write is worth making is the manager's call,
* since only the manager knows what would mask it.
*/
add_task(async function test_canSet_needs_only_a_principal() {
await withProvider(provider => {
Assert.ok(
provider.canSet(makePrincipal("https://example.com")),
"a content principal can be written"
);
Assert.ok(!provider.canSet(null), "a missing principal cannot");
});
});
/**
* uninit drops the perm-changed observer, so a torn-down provider stops
* notifying.
*/
add_task(async function test_uninit_stops_observing() {
const provider = new IPPPermissionRuleProvider();
provider.init();
provider.uninit();
let seen = 0;
provider.addEventListener("change", () => seen++);
const principal = makePrincipal("https://uninited.example.com");
provider.setRule(principal, IPPPrincipalRules.EXCLUDED);
Assert.equal(seen, 0, "an uninited provider does not notify");
Services.perms.removeByType(PERM_NAME);
});