diff options
Diffstat (limited to 'toolkit/components/cookiebanners/test')
32 files changed, 7000 insertions, 0 deletions
diff --git a/toolkit/components/cookiebanners/test/browser/browser.toml b/toolkit/components/cookiebanners/test/browser/browser.toml new file mode 100644 index 0000000000..69728540d9 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser.toml @@ -0,0 +1,62 @@ +[DEFAULT] +support-files = ["head.js"] + +["browser_bannerClicking.js"] +support-files = [ + "file_banner.html", + "file_banner_b.html", + "file_delayed_banner.html", +] + +["browser_bannerClicking_domainPref.js"] + +["browser_bannerClicking_events.js"] +support-files = ["file_banner.html"] + +["browser_bannerClicking_globalRules.js"] + +["browser_bannerClicking_globalRules_telemetry.js"] + +["browser_bannerClicking_runContext.js"] +support-files = ["file_banner.html"] + +["browser_bannerClicking_slowLoad.js"] +support-files = [ + "file_delayed_banner_load.html", + "slowSubresource.sjs", +] + +["browser_bannerClicking_stopExecuteAfterSeveralAttempt.js"] + +["browser_bannerClicking_telemetry_querySelector.js"] +support-files = [ + "file_banner.html", +] + +["browser_bannerClicking_visibilityOverride.js"] +support-files = ["file_banner_invisible.html"] + +["browser_cookiebanner_telemetry.js"] +support-files = ["file_iframe_banner.html"] + +["browser_cookiebanner_webconsole.js"] +support-files = [ + "file_banner.html", +] + +["browser_cookiebannerservice.js"] + +["browser_cookiebannerservice_domainPrefs.js"] + +["browser_cookiebannerservice_getRules.js"] + +["browser_cookiebannerservice_hasRuleForBCTree.js"] + +["browser_cookiebannerservice_prefs.js"] + +["browser_cookieinjector.js"] +support-files = ["testCookieHeader.sjs"] + +["browser_cookieinjector_events.js"] + +["browser_cookieinjector_telemetry.js"] diff --git a/toolkit/components/cookiebanners/test/browser/browser_bannerClicking.js b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking.js new file mode 100644 index 0000000000..4353505ab2 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking.js @@ -0,0 +1,485 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_setup(clickTestSetup); + +/** + * Test that the banner clicking won't click banner if the service is disabled or in detect-only mode. + */ +add_task(async function test_cookie_banner_service_disabled() { + for (let [serviceMode, detectOnly] of [ + [Ci.nsICookieBannerService.MODE_DISABLED, false], + [Ci.nsICookieBannerService.MODE_DISABLED, true], + [Ci.nsICookieBannerService.MODE_REJECT, true], + [Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, true], + ]) { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", serviceMode], + ["cookiebanners.service.detectOnly", detectOnly], + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_DISABLED, + ], + ], + }); + + // Clear the executed records before testing. + if (serviceMode != Ci.nsICookieBannerService.MODE_DISABLED) { + Services.cookieBanners.removeAllExecutedRecords(false); + } + + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: true, + expected: "NoClick", + expectActorEnabled: + serviceMode != Ci.nsICookieBannerService.MODE_DISABLED, + }); + + await SpecialPowers.popPrefEnv(); + } +}); + +/** + * Test that the banner clicking won't click banner if there is no rule. + */ +add_task(async function test_no_rules() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + info("Clearing existing rules"); + Services.cookieBanners.resetRules(false); + + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: true, + expected: "NoClick", + }); + + // No click telemetry reported. + await testClickResultTelemetry({}); +}); + +/** + * Test the banner clicking with MODE_REJECT. + */ +add_task(async function test_clicking_mode_reject() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + insertTestClickRules(); + + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await testClickResultTelemetry( + { success: 1, success_dom_content_loaded: 1 }, + false + ); + + Services.cookieBanners.removeAllExecutedRecords(false); + + // No opt out rule for the example.org, the banner shouldn't be clicked. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: true, + expected: "NoClick", + }); + + // No matching rule means we don't record any telemetry for clicks. + await testClickResultTelemetry({ + success: 1, + success_dom_content_loaded: 1, + fail: 1, + fail_no_rule_for_mode: 1, + }); +}); + +/** + * Test the banner clicking with MODE_REJECT_OR_ACCEPT. + */ +add_task(async function test_clicking_mode_reject_or_accept() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ], + }); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + insertTestClickRules(); + + await testClickResultTelemetry({}); + + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await testClickResultTelemetry( + { + success: 1, + success_dom_content_loaded: 1, + }, + false + ); + + Services.cookieBanners.removeAllExecutedRecords(false); + + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: false, + expected: "OptIn", + }); + + await testClickResultTelemetry({ + success: 2, + success_dom_content_loaded: 2, + }); +}); + +/** + * Test the banner clicking with the case where the banner is added after + * page loads and with a short amount of delay. + */ +add_task(async function test_clicking_with_delayed_banner() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.bannerClicking.timeoutAfterLoad", 10000], + ], + }); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + insertTestClickRules(); + + await testClickResultTelemetry({}); + + let TEST_PAGE = + TEST_ORIGIN_A + TEST_PATH + "file_delayed_banner.html?delay=100"; + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE, + visible: false, + expected: "OptOut", + }); + + await testClickResultTelemetry({ + success: 1, + success_mutation_pre_load: 1, + }); +}); + +/** + * Test that the banner clicking in an iframe. + */ +add_task(async function test_embedded_iframe() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + insertTestClickRules(); + + await testClickResultTelemetry({}); + + await openIframeAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await testClickResultTelemetry({ + success: 1, + success_dom_content_loaded: 1, + }); +}); + +/** + * Test banner clicking with the private browsing window. + */ +add_task(async function test_pbm() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ], + }); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + insertTestClickRules(); + + await testClickResultTelemetry({}); + + let pbmWindow = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + + await openPageAndVerify({ + win: pbmWindow, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await BrowserTestUtils.closeWindow(pbmWindow); + + await testClickResultTelemetry({ + success: 1, + success_dom_content_loaded: 1, + }); +}); + +/** + * Tests service mode pref combinations for normal and private browsing. + */ +add_task(async function test_pref_pbm_pref() { + info("Enable in normal browsing but disable in private browsing."); + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_DISABLED, + ], + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + insertTestClickRules(); + + await testClickResultTelemetry({}); + + let pbmWindow = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + + await openPageAndVerify({ + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await testClickResultTelemetry( + { + success: 1, + success_dom_content_loaded: 1, + }, + false + ); + + Services.cookieBanners.removeAllExecutedRecords(false); + + await openPageAndVerify({ + win: pbmWindow, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: true, + expected: "NoClick", + }); + + await testClickResultTelemetry( + { + success: 1, + success_dom_content_loaded: 1, + }, + false + ); + + info("Disable in normal browsing but enable in private browsing."); + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_DISABLED], + ], + }); + + Services.cookieBanners.removeAllExecutedRecords(false); + + await openPageAndVerify({ + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: true, + expected: "NoClick", + }); + + await testClickResultTelemetry( + { + success: 1, + success_dom_content_loaded: 1, + }, + false + ); + + Services.cookieBanners.removeAllExecutedRecords(false); + + await openPageAndVerify({ + win: pbmWindow, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await testClickResultTelemetry( + { + success: 2, + success_dom_content_loaded: 2, + }, + false + ); + + info( + "Set normal browsing to REJECT_OR_ACCEPT and private browsing to REJECT." + ); + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ], + }); + + Services.cookieBanners.removeAllExecutedRecords(false); + + info( + "The normal browsing window accepts the banner according to the opt-in rule." + ); + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: false, + expected: "OptIn", + }); + + await testClickResultTelemetry( + { + success: 3, + success_dom_content_loaded: 3, + }, + false + ); + + Services.cookieBanners.removeAllExecutedRecords(false); + + info( + "The private browsing window should not perform any click, because there is only an opt-in rule." + ); + await openPageAndVerify({ + win: pbmWindow, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: true, + expected: "NoClick", + }); + + await BrowserTestUtils.closeWindow(pbmWindow); + + await testClickResultTelemetry({ + success: 3, + success_dom_content_loaded: 3, + fail: 1, + fail_no_rule_for_mode: 1, + }); +}); + +/** + * Test that the banner clicking in an iframe with the private browsing window. + */ +add_task(async function test_embedded_iframe_pbm() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ], + }); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + insertTestClickRules(); + + await testClickResultTelemetry({}); + + let pbmWindow = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + + await openIframeAndVerify({ + win: pbmWindow, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await BrowserTestUtils.closeWindow(pbmWindow); + + await testClickResultTelemetry({ + success: 1, + success_dom_content_loaded: 1, + }); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_domainPref.js b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_domainPref.js new file mode 100644 index 0000000000..01986eb36b --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_domainPref.js @@ -0,0 +1,368 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +let { ForgetAboutSite } = ChromeUtils.importESModule( + "resource://gre/modules/ForgetAboutSite.sys.mjs" +); + +add_setup(clickTestSetup); + +/** + * Test that domain preference takes precedence over pref settings. + */ +add_task(async function test_domain_preference() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ], + }); + + insertTestClickRules(); + + // Clear executed records before testing for private and normal browsing. + Services.cookieBanners.removeAllExecutedRecords(true); + Services.cookieBanners.removeAllExecutedRecords(false); + + for (let testPBM of [false, true]) { + let testWin = window; + if (testPBM) { + testWin = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + } + + await testClickResultTelemetry({}); + + info( + "Make sure the example.org follows the pref setting when there is no domain preference." + ); + await openPageAndVerify({ + win: testWin, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: true, + expected: "NoClick", + }); + + await testClickResultTelemetry( + { + fail: 1, + fail_no_rule_for_mode: 1, + }, + false + ); + + Services.cookieBanners.removeAllExecutedRecords(testPBM); + + info("Set the domain preference of example.org to MODE_REJECT_OR_ACCEPT"); + let uri = Services.io.newURI(TEST_ORIGIN_B); + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + testPBM + ); + + info( + "Verify if domain preference takes precedence over then the pref setting for example.org" + ); + await openPageAndVerify({ + win: testWin, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: false, + expected: "OptIn", + }); + + Services.cookieBanners.removeAllDomainPrefs(testPBM); + + if (testPBM) { + await BrowserTestUtils.closeWindow(testWin); + } + + await testClickResultTelemetry({ + fail: 1, + fail_no_rule_for_mode: 1, + success: 1, + success_dom_content_loaded: 1, + }); + } +}); + +/** + * Test that domain preference works on the top-level domain. + */ +add_task(async function test_domain_preference_iframe() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ], + }); + + insertTestClickRules(); + + // Clear executed records before testing for private and normal browsing. + Services.cookieBanners.removeAllExecutedRecords(true); + Services.cookieBanners.removeAllExecutedRecords(false); + + await testClickResultTelemetry({}); + + for (let testPBM of [false, true]) { + let testWin = window; + if (testPBM) { + testWin = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + } + + info( + "Make sure the example.org follows the pref setting when there is no domain preference for the top-level example.net." + ); + await openIframeAndVerify({ + win: testWin, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: true, + expected: "NoClick", + }); + + await testClickResultTelemetry( + { + fail: 1, + fail_no_rule_for_mode: 1, + }, + false + ); + + Services.cookieBanners.removeAllExecutedRecords(testPBM); + + info( + "Set the domain preference of the top-level domain to MODE_REJECT_OR_ACCEPT" + ); + let uri = Services.io.newURI(TEST_ORIGIN_C); + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + testPBM + ); + + info( + "Verify if domain preference takes precedence over then the pref setting for top-level example.net" + ); + await openIframeAndVerify({ + win: testWin, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: false, + expected: "OptIn", + }); + + Services.cookieBanners.removeAllDomainPrefs(testPBM); + + if (testPBM) { + await BrowserTestUtils.closeWindow(testWin); + } + + await testClickResultTelemetry({ + fail: 1, + fail_no_rule_for_mode: 1, + success: 1, + success_dom_content_loaded: 1, + }); + } +}); + +// Verify that the ForgetAboutSite clears the domain preference properly. +add_task(async function test_domain_preference_forgetAboutSite() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ], + }); + + insertTestClickRules(); + + // Clear executed records before testing for private and normal browsing. + Services.cookieBanners.removeAllExecutedRecords(true); + Services.cookieBanners.removeAllExecutedRecords(false); + + info("Set the domain preference of example.org to MODE_REJECT_OR_ACCEPT"); + let uri = Services.io.newURI(TEST_ORIGIN_B); + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + false + ); + + info( + "Verify if domain preference takes precedence over then the pref setting for example.org" + ); + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: false, + expected: "OptIn", + }); + + // Call ForgetAboutSite for the domain. + await ForgetAboutSite.removeDataFromDomain(TEST_DOMAIN_B); + + info("Ensure the domain preference is cleared."); + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: true, + expected: "NoClick", + }); +}); + +add_task(async function test_domain_preference_clearDataService() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ], + }); + + insertTestClickRules(); + + // Clear executed records before testing or private and normal browsing. + Services.cookieBanners.removeAllExecutedRecords(true); + Services.cookieBanners.removeAllExecutedRecords(false); + + info("Set the domain preference of example.org to MODE_REJECT_OR_ACCEPT"); + let uri = Services.io.newURI(TEST_ORIGIN_B); + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + false + ); + + info( + "Verify if domain preference takes precedence over then the pref setting for example.org" + ); + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: false, + expected: "OptIn", + }); + + info("Call ClearDataService.deleteDataFromBaseDomain for the domain."); + await new Promise(aResolve => { + Services.clearData.deleteDataFromBaseDomain( + TEST_DOMAIN_B, + true /* user request */, + Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXCEPTION, + aResolve + ); + }); + + info("Ensure the domain preference is cleared."); + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: true, + expected: "NoClick", + }); + + info("Set the domain preference of example.org to MODE_REJECT_OR_ACCEPT"); + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + false + ); + + info("Call ClearDataService.deleteDataFromHost for the domain."); + await new Promise(aResolve => { + Services.clearData.deleteDataFromHost( + TEST_DOMAIN_B, + true /* user request */, + Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXCEPTION, + aResolve + ); + }); + + info("Ensure the domain preference is cleared."); + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: true, + expected: "NoClick", + }); + + info("Set the domain preference of example.org to MODE_REJECT_OR_ACCEPT"); + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + false + ); + + info("Call ClearDataService.deleteDataFromPrincipal for the domain."); + let principal = + Services.scriptSecurityManager.createContentPrincipalFromOrigin( + "https://" + TEST_DOMAIN_B + ); + await new Promise(aResolve => { + Services.clearData.deleteDataFromPrincipal( + principal, + true /* user request */, + Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXCEPTION, + aResolve + ); + }); + + info("Ensure the domain preference is cleared."); + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: true, + expected: "NoClick", + }); + + info("Set the domain preference of example.org to MODE_REJECT_OR_ACCEPT"); + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + false + ); + + info("Call ClearDataService.deleteData for the domain."); + await new Promise(aResolve => { + Services.clearData.deleteData( + Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXCEPTION, + aResolve + ); + }); + + info("Ensure the domain preference is cleared."); + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: true, + expected: "NoClick", + }); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_events.js b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_events.js new file mode 100644 index 0000000000..de9a464446 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_events.js @@ -0,0 +1,98 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_setup(clickTestSetup); + +/** + * Triggers cookie banner clicking and tests the events dispatched. + * @param {*} options - Test options. + * @param {nsICookieBannerService::Modes} options.mode - The cookie banner service mode to test with. + * @param {boolean} options.detectOnly - Whether the service should be enabled + * in detection only mode, where it does not handle banners. + * @param {*} options.openPageOptions - Options to overwrite for the openPageAndVerify call. + */ +async function runTest({ mode, detectOnly = false, openPageOptions = {} }) { + if (mode == null) { + throw new Error("Invalid cookie banner service mode."); + } + let initFn = () => { + // Insert rules only if the feature is enabled. + if (Services.cookieBanners.isEnabled) { + insertTestClickRules(); + + // Clear executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + } + }; + + let shouldHandleBanner = + mode == Ci.nsICookieBannerService.MODE_REJECT && !detectOnly; + let expectActorEnabled = mode != Ci.nsICookieBannerService.MODE_DISABLED; + let testURL = openPageOptions.testURL || TEST_PAGE_A; + let triggerFn = async () => { + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL, + visible: !shouldHandleBanner, + expected: shouldHandleBanner ? "OptOut" : "NoClick", + keepTabOpen: true, + expectActorEnabled, + ...openPageOptions, // Allow test callers to override any options for this method. + }); + }; + + await runEventTest({ mode, detectOnly, initFn, triggerFn, testURL }); + + // Clean up the test tab opened by openPageAndVerify. + BrowserTestUtils.removeTab(gBrowser.selectedTab); +} + +/** + * Test the banner clicking events with MODE_REJECT. + */ +add_task(async function test_events_mode_reject() { + await runTest({ mode: Ci.nsICookieBannerService.MODE_REJECT }); +}); + +/** + * Test the banner clicking events with detect-only mode. + */ +add_task(async function test_events_mode_detect_only() { + await runTest({ + mode: Ci.nsICookieBannerService.MODE_REJECT, + detectOnly: true, + }); + await runTest({ + mode: Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + detectOnly: true, + }); +}); + +/** + * Test the banner clicking events with detect-only mode with a click rule that + * only supports opt-in. + */ +add_task(async function test_events_mode_detect_only_opt_in_rule() { + await runTest({ + mode: Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + detectOnly: true, + openPageOptions: { + // We only have an opt-in rule for DOMAIN_B. This ensures we still fire + // detection events for that case. + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + shouldHandleBanner: true, + expected: "NoClick", + }, + }); +}); + +/** + * Test the banner clicking events in disabled mode. + */ +add_task(async function test_events_mode_disabled() { + await runTest({ mode: Ci.nsICookieBannerService.MODE_DISABLED }); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_globalRules.js b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_globalRules.js new file mode 100644 index 0000000000..a23194be95 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_globalRules.js @@ -0,0 +1,234 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_setup(clickTestSetup); + +/** + * Test the banner clicking with global rules and MODE_REJECT. + */ +add_task(async function test_clicking_global_rules() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.service.enableGlobalRules", true], + ], + }); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + info("Clearing existing rules"); + Services.cookieBanners.resetRules(false); + + info("Inserting global test rules."); + + info( + "Add global ruleA which targets an existing banner (presence) with existing buttons. This rule should handle the banner." + ); + let ruleA = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleA.id = genUUID(); + ruleA.domains = []; + ruleA.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_TOP, + null, + "button#optOut", + "button#optIn" + ); + Services.cookieBanners.insertRule(ruleA); + + info( + "Add global ruleC which targets an existing banner (presence) but non-existing buttons." + ); + let ruleC = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleC.id = genUUID(); + ruleC.domains = []; + ruleC.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_TOP, + null, + "button#nonExistingOptOut", + "button#nonExistingOptIn" + ); + Services.cookieBanners.insertRule(ruleC); + + info("Add global ruleD which targets a non-existing banner (presence)."); + let ruleD = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleD.id = genUUID(); + ruleD.domains = []; + ruleD.addClickRule( + "div#nonExistingBanner", + false, + Ci.nsIClickRule.RUN_TOP, + null, + null, + "button#optIn" + ); + Services.cookieBanners.insertRule(ruleD); + + await testCMPResultTelemetry({}); + + info("The global rule ruleA should handle both test pages with div#banner."); + await openPageAndVerify({ + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await testCMPResultTelemetry( + { + success: 1, + success_dom_content_loaded: 1, + }, + false + ); + + Services.cookieBanners.removeAllExecutedRecords(false); + + await openPageAndVerify({ + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: false, + expected: "OptOut", + }); + + await testCMPResultTelemetry( + { + success: 2, + success_dom_content_loaded: 2, + }, + false + ); + + Services.cookieBanners.removeAllExecutedRecords(false); + + info("No global rule should handle TEST_PAGE_C with div#bannerB."); + await openPageAndVerify({ + domain: TEST_DOMAIN_C, + testURL: TEST_PAGE_C, + visible: true, + expected: "NoClick", + bannerId: "bannerB", + }); + + await testCMPResultTelemetry( + { + success: 2, + success_dom_content_loaded: 2, + fail: 1, + fail_banner_not_found: 1, + }, + false + ); + + await SpecialPowers.pushPrefEnv({ + set: [["cookiebanners.bannerClicking.timeoutAfterLoad", 10000]], + }); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + info("Test delayed banner handling with global rules."); + let TEST_PAGE = + TEST_ORIGIN_A + TEST_PATH + "file_delayed_banner.html?delay=100"; + await openPageAndVerify({ + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE, + visible: false, + expected: "OptOut", + }); + + await SpecialPowers.popPrefEnv(); + + await testCMPResultTelemetry({ + success: 3, + success_dom_content_loaded: 2, + fail: 1, + fail_banner_not_found: 1, + success_mutation_pre_load: 1, + }); +}); + +/** + * Test that domain-specific rules take precedence over global rules. + */ +add_task(async function test_clicking_global_rules_precedence() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ["cookiebanners.service.enableGlobalRules", true], + ], + }); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + info("Clearing existing rules"); + Services.cookieBanners.resetRules(false); + + info("Inserting global test rules."); + + info( + "Add global ruleA which targets an existing banner (presence) with existing buttons." + ); + let ruleGlobal = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleGlobal.id = genUUID(); + ruleGlobal.domains = []; + ruleGlobal.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_TOP, + null, + "button#optOut", + null + ); + Services.cookieBanners.insertRule(ruleGlobal); + + info("Add domain specific rule which also targets the existing banner."); + let ruleDomain = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleDomain.id = genUUID(); + ruleDomain.domains = [TEST_DOMAIN_A]; + ruleDomain.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_TOP, + null, + null, + "button#optIn" + ); + Services.cookieBanners.insertRule(ruleDomain); + + await testCMPResultTelemetry({}); + + info("Test that the domain-specific rule applies, not the global one."); + await openPageAndVerify({ + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + // Because of the way the rules are setup OptOut would mean the global rule + // applies, opt-in means the domain specific rule applies. + expected: "OptIn", + }); + + // Ensure we don't accidentally collect CMP result telemetry when + // domain-specific rule applies. + await testCMPResultTelemetry({}); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_globalRules_telemetry.js b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_globalRules_telemetry.js new file mode 100644 index 0000000000..6d9e96914d --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_globalRules_telemetry.js @@ -0,0 +1,223 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_setup(clickTestSetup); + +async function verifyDetectedCMPTelemetry(expected) { + // Ensure we have all data from the content process. + await Services.fog.testFlushAllChildren(); + + let LABELS = [ + "trustarcbar", + "quantcast", + "borlabs", + "consentmanagernet", + "cookiebot", + "complianz", + "onetrust", + "didomi", + "sourcepoint", + ]; + + let testMetricState = doAssert => { + for (let label of LABELS) { + let expectedValue = expected[label] ?? null; + if (doAssert) { + is( + Glean.cookieBannersCmp.detectedCmp[label].testGetValue(), + expectedValue, + `Counter for label '${label}' has correct state.` + ); + } else if ( + Glean.cookieBannersCmp.detectedCmp[label].testGetValue() !== + expectedValue + ) { + return false; + } + } + + return true; + }; + + // Wait for the labeled counter to match the expected state. Returns greedy on + // mismatch. + try { + await TestUtils.waitForCondition( + testMetricState, + "Waiting for cookieBannersClick.result metric to match." + ); + } finally { + // Test again but this time with assertions and test all labels. + testMetricState(true); + } +} + +async function verifyRatioTelemetry(expected) { + // Ensure we have all data from the content process. + await Services.fog.testFlushAllChildren(); + + let cmpMetric = Glean.cookieBannersCmp.ratioHandledByCmpRule; + + let testMetricState = doAssert => { + let cmpValue = cmpMetric.testGetValue(); + + if (!cmpValue) { + return false; + } + + if (!doAssert) { + return ( + cmpValue.numerator == expected.cmp.numerator && + cmpValue.denominator == expected.cmp.denominator + ); + } + + is( + cmpValue.numerator, + expected.cmp.numerator, + "The numerator of rateHandledByCmpRule is expected" + ); + is( + cmpValue.denominator, + expected.cmp.denominator, + "The denominator of rateHandledByCmpRule is expected" + ); + + return true; + }; + + // Wait for matching the expected state. + try { + await TestUtils.waitForCondition( + testMetricState, + "Waiting for metric to match." + ); + } finally { + // Test again but this time with assertions and test all labels. + testMetricState(true); + } +} + +add_task(async function test_cmp_telemetry() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.service.enableGlobalRules", true], + ["cookiebanners.bannerClicking.maxTriesPerSiteAndSession", 0], + ], + }); + + info("Clearing existing rules"); + Services.cookieBanners.resetRules(false); + + info("Inserting global test rules."); + + info( + "Add global ruleA with a predefined identifier. This rule will handle the banner." + ); + let ruleA = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleA.id = "trustarcbar"; + ruleA.domains = []; + ruleA.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_TOP, + null, + "button#optOut", + "button#optIn" + ); + Services.cookieBanners.insertRule(ruleA); + + info("Add global ruleC with another predefined identifier."); + let ruleC = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleC.id = "quantcast"; + ruleC.domains = []; + ruleC.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_TOP, + null, + "button#nonExistingOptOut", + "button#nonExistingOptIn" + ); + Services.cookieBanners.insertRule(ruleC); + + info("Open a test page and verify the telemetry"); + await openPageAndVerify({ + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await verifyRatioTelemetry({ + cmp: { numerator: 1, denominator: 1 }, + }); + await verifyDetectedCMPTelemetry({ + trustarcbar: 1, + quantcast: 1, + }); + + info("Open the test page again and verify if the telemetry gets updated"); + await openPageAndVerify({ + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await verifyRatioTelemetry({ + cmp: { numerator: 2, denominator: 2 }, + }); + await verifyDetectedCMPTelemetry({ + trustarcbar: 2, + quantcast: 2, + }); + + info("Add domain specific rule which also targets the existing banner."); + let ruleDomain = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleDomain.id = genUUID(); + ruleDomain.domains = [TEST_DOMAIN_A]; + ruleDomain.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_TOP, + null, + "button#optOut", + "button#optIn" + ); + Services.cookieBanners.insertRule(ruleDomain); + + info("Open the test page and now the site-specific rule will handle it"); + await openPageAndVerify({ + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + info("Verify that the CMP telemetry doesn't get updated."); + await verifyDetectedCMPTelemetry({ + trustarcbar: 2, + quantcast: 2, + }); + + info( + "Verify the handled ratio telemetry for site-specific rule gets updated." + ); + await verifyRatioTelemetry({ + cmp: { numerator: 2, denominator: 3 }, + }); + + // Clear Telemetry + await Services.fog.testFlushAllChildren(); + Services.fog.testResetFOG(); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_runContext.js b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_runContext.js new file mode 100644 index 0000000000..e6bfad4765 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_runContext.js @@ -0,0 +1,115 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_setup(clickTestSetup); + +/** + * Insert a test rule with the specified runContext. + * @param {RunContext} - The runContext to set for the rule. See nsIClickRule + * for documentation. + */ +function insertTestRules({ runContext }) { + info("Clearing existing rules"); + Services.cookieBanners.resetRules(false); + + info("Inserting test rules. " + JSON.stringify({ runContext })); + + info("Add opt-out click rule for DOMAIN_A."); + let ruleA = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleA.id = genUUID(); + ruleA.domains = [TEST_DOMAIN_A]; + + ruleA.addClickRule( + "div#banner", + false, + runContext, + null, + "button#optOut", + "button#optIn" + ); + Services.cookieBanners.insertRule(ruleA); +} + +/** + * Test that banner clicking only runs if the context matches the runContext + * specified in the click rule. + */ +add_task(async function test_embedded_iframe() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + insertTestRules({ runContext: Ci.nsIClickRule.RUN_TOP }); + + // Clear executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + await openIframeAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: true, + expected: "NoClick", + }); + + Services.cookieBanners.removeAllExecutedRecords(false); + + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + Services.cookieBanners.removeAllExecutedRecords(false); + + insertTestRules({ runContext: Ci.nsIClickRule.RUN_CHILD }); + + await openIframeAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + Services.cookieBanners.removeAllExecutedRecords(false); + + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: true, + expected: "NoClick", + }); + + Services.cookieBanners.removeAllExecutedRecords(false); + + insertTestRules({ runContext: Ci.nsIClickRule.RUN_ALL }); + await openIframeAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + Services.cookieBanners.removeAllExecutedRecords(false); + + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + Services.cookieBanners.removeAllExecutedRecords(false); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_slowLoad.js b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_slowLoad.js new file mode 100644 index 0000000000..d0d06f3324 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_slowLoad.js @@ -0,0 +1,37 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_setup(clickTestSetup); + +/** + * Test the banner clicking with the case where the banner is added shortly after + * page load, but the page load itself is delayed. + */ +add_task(async function test_clicking_with_delayed_banner() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + insertTestClickRules(); + + await testClickResultTelemetry({}); + + // A test page that has a delayed load event. + let TEST_PAGE = TEST_ORIGIN_A + TEST_PATH + "file_delayed_banner_load.html"; + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE, + visible: false, + expected: "OptOut", + }); + + await testClickResultTelemetry({ + success: 1, + success_mutation_post_load: 1, + }); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_stopExecuteAfterSeveralAttempt.js b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_stopExecuteAfterSeveralAttempt.js new file mode 100644 index 0000000000..6e3a6f19fe --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_stopExecuteAfterSeveralAttempt.js @@ -0,0 +1,352 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +let { ForgetAboutSite } = ChromeUtils.importESModule( + "resource://gre/modules/ForgetAboutSite.sys.mjs" +); + +add_setup(async function () { + await clickTestSetup(); + + // Set the pref to enable stopping executing cookie banner handling after + // several tries. + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.bannerClicking.maxTriesPerSiteAndSession", 1], + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + // Clean the records. + Services.cookieBanners.removeAllExecutedRecords(false); + Services.cookieBanners.removeAllExecutedRecords(true); +}); + +// Ensure the banner clicking doesn't execute at the second load if the +// stopExecuteAfterAttempt feature is enabled. +add_task(async function testStopExecuteAfterOneAttempt() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ["cookiebanners.bannerClicking.maxTriesPerSiteAndSession", 1], + ], + }); + + insertTestClickRules(); + + // Open the domain and ensure the banner is clicked. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Open the domain again and the banner shouldn't be hidden nor the banner is + // clicked. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: true, + expected: "NoClick", + }); + + // Clear the record for the normal window. + Services.cookieBanners.removeAllExecutedRecords(false); + + // Open the domain again after clearing the record and ensure the banner is + // clicked. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Test in the private browsing mode. + let pbmWindow = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + + // Open the domain in PBM and ensure the banner is clicked. + await openPageAndVerify({ + win: pbmWindow, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Open the domain in PBM again and the banner shouldn't be hidden nor the + // banner is clicked. + await openPageAndVerify({ + win: pbmWindow, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: true, + expected: "NoClick", + }); + + // Clear the record for the private window. + Services.cookieBanners.removeAllExecutedRecords(true); + + // Open the domain again in PBM after clearing the record, and ensure the + // banner is clicked. + await openPageAndVerify({ + win: pbmWindow, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await BrowserTestUtils.closeWindow(pbmWindow); + + // Clean the records. + Services.cookieBanners.removeAllExecutedRecords(false); + Services.cookieBanners.removeAllExecutedRecords(true); +}); + +// Ensure the banner clicking doesn't execute after several attempts if the +// stopExecuteAfterAttempt feature is enabled. +add_task(async function testStopExecuteAfterSeveralAttempts() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ["cookiebanners.bannerClicking.maxTriesPerSiteAndSession", 2], + ], + }); + + insertTestClickRules(); + + // Open the domain and ensure the banner is clicked. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Open the domain in the second time and the banner should be clicked, + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Open the domain in the third time, the the banner shouldn't be hidden nor + // the banner is clicked. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: true, + expected: "NoClick", + }); + + // Test in the private browsing mode. + let pbmWindow = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + + // Open the domain in PBM and ensure the banner is clicked. + await openPageAndVerify({ + win: pbmWindow, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Open the domain in the second time and the banner should be clicked, + await openPageAndVerify({ + win: pbmWindow, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Open the domain in PBM third time and the banner shouldn't be hidden nor + // the banner is clicked. + await openPageAndVerify({ + win: pbmWindow, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: true, + expected: "NoClick", + }); + + await BrowserTestUtils.closeWindow(pbmWindow); + + // Clean the records. + Services.cookieBanners.removeAllExecutedRecords(false); + Services.cookieBanners.removeAllExecutedRecords(true); +}); + +// Ensure that ForgetAboutSite clears the handled record properly. +add_task(async function testForgetAboutSiteWithStopExecuteAfterOneAttempt() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.bannerClicking.maxTriesPerSiteAndSession", 1], + ], + }); + + insertTestClickRules(); + + // Open the domain and ensure the banner is clicked. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Open the domain again and the banner shouldn't be hidden nor the banner is + // clicked. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: true, + expected: "NoClick", + }); + + // Call ForgetAboutSite for the domain. + await ForgetAboutSite.removeDataFromDomain(TEST_DOMAIN_A); + + // Open the domain again after ForgetAboutSite and the clicking should work + // again. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Clean the records. + Services.cookieBanners.removeAllExecutedRecords(false); + Services.cookieBanners.removeAllExecutedRecords(true); +}); + +// Ensure the ClearDataService clears the handled record properly. +add_task(async function testClearDataServiceWithStopExecuteAfterOneAttempt() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.bannerClicking.maxTriesPerSiteAndSession", 1], + ], + }); + + insertTestClickRules(); + + // Open the domain initially and ensure the banner is clicked. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Invoke deleteDataFromBaseDomain. + await new Promise(aResolve => { + Services.clearData.deleteDataFromBaseDomain( + TEST_DOMAIN_A, + true /* user request */, + Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD, + aResolve + ); + }); + + // Ensure the record is cleared. The banner clicking should work after clean. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Invoke deleteDataFromHost. + await new Promise(aResolve => { + Services.clearData.deleteDataFromHost( + TEST_DOMAIN_A, + true /* user request */, + Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD, + aResolve + ); + }); + + // Ensure the record is cleared. The banner clicking should work after clean. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Invoke deleteDataFromPrincipal. + let principal = + Services.scriptSecurityManager.createContentPrincipalFromOrigin( + "https://" + TEST_DOMAIN_A + ); + await new Promise(aResolve => { + Services.clearData.deleteDataFromPrincipal( + principal, + true /* user request */, + Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD, + aResolve + ); + }); + + // Ensure the record is cleared. The banner clicking should work after clean. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Invoke deleteData. + await new Promise(aResolve => { + Services.clearData.deleteData( + Ci.nsIClearDataService.CLEAR_COOKIE_BANNER_EXECUTED_RECORD, + aResolve + ); + }); + + // Ensure the record is cleared. The banner clicking should work after clean. + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + // Clean the records. + Services.cookieBanners.removeAllExecutedRecords(false); + Services.cookieBanners.removeAllExecutedRecords(true); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_telemetry_querySelector.js b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_telemetry_querySelector.js new file mode 100644 index 0000000000..0778c736a4 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_telemetry_querySelector.js @@ -0,0 +1,169 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +/** + * Wait for the result of checkFn to equal expectedValue and run an assertion + * once the value matches. + * @param {function} checkFn - Function which returns value to compare to + * expectedValue. + * @param {*} expectedValue - Value to compare against checkFn return value. + * @param {string} message - Assertion / test message. + */ +async function waitForAndAssertEqual(checkFn, expectedValue, message) { + let checkFnResult; + await BrowserTestUtils.waitForCondition(() => { + checkFnResult = checkFn(); + return checkFnResult == expectedValue; + }, message); + Assert.equal(checkFnResult, expectedValue, message); +} + +/** + * Test that query selector histogram data is set / unset. + * @param {*} options + * @param {boolean} options.hasTopLevelData - Whether there should be telemetry + * data for top level windows. + * @param {boolean} options.hasFrameData = Whether there should be telemetry + * data for sub-frames. + */ +async function assertQuerySelectorTelemetry({ hasTopLevelData, hasFrameData }) { + // Ensure we have all data from the content process. + await Services.fog.testFlushAllChildren(); + + let runDurationTopLevel = () => + Glean.cookieBannersClick.querySelectorRunDurationPerWindowTopLevel.testGetValue() != + null; + let runDurationFrame = () => + Glean.cookieBannersClick.querySelectorRunDurationPerWindowFrame.testGetValue() != + null; + + let runCountTopLevel = () => + Glean.cookieBannersClick.querySelectorRunCountPerWindowTopLevel.testGetValue() != + null; + let runCountFrame = () => + Glean.cookieBannersClick.querySelectorRunCountPerWindowFrame.testGetValue() != + null; + + let messagePrefix = hasData => `Should${hasData ? "" : " not"} have`; + + await waitForAndAssertEqual( + runCountTopLevel, + hasTopLevelData, + `${messagePrefix(hasTopLevelData)} top-level run count data.` + ); + await waitForAndAssertEqual( + runDurationTopLevel, + hasTopLevelData, + `${messagePrefix(hasTopLevelData)} top-level run duration data.` + ); + + await waitForAndAssertEqual( + runDurationFrame, + hasFrameData, + `${messagePrefix(hasFrameData)} sub-frame run duration data.` + ); + await waitForAndAssertEqual( + runCountFrame, + hasFrameData, + `${messagePrefix(hasFrameData)} sub-frame run count data.` + ); +} + +add_setup(clickTestSetup); + +/** + * Tests that, when performing cookie banner clicking, query selector + * performance telemetry is collected. + */ +add_task(async function test_click_query_selector_telemetry() { + // Clear telemetry. + Services.fog.testResetFOG(); + + // Enable cookie banner handling. + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + insertTestClickRules(); + + info("No telemetry recorded initially."); + await assertQuerySelectorTelemetry({ + hasFrameData: false, + hasTopLevelData: false, + }); + + // No opt out rule for the example.org, the banner shouldn't be clicked. + info("Top level cookie banner with no matching rule."); + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_B, + testURL: TEST_PAGE_B, + visible: true, + expected: "NoClick", + }); + await assertQuerySelectorTelemetry({ + hasFrameData: false, + hasTopLevelData: true, + }); + + Services.cookieBanners.removeAllExecutedRecords(false); + + info("Top level cookie banner with matching rule."); + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + await assertQuerySelectorTelemetry({ + hasFrameData: false, + hasTopLevelData: true, + }); + + Services.cookieBanners.removeAllExecutedRecords(false); + + info("Iframe cookie banner with matching rule."); + await openIframeAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + await assertQuerySelectorTelemetry({ + hasFrameData: true, + hasTopLevelData: true, + }); + + Services.cookieBanners.removeAllExecutedRecords(false); + + // Reset test rules and insert only site-specific rules so we can ensure the + // clicking mechanism is only running for the iframe, not the top level. + info("Insert test rules without global rules."); + insertTestClickRules(false); + + // Clear telemetry. + info("Clear telemetry."); + Services.fog.testResetFOG(); + + info("Iframe cookie banner with matching rule."); + await openIframeAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + await assertQuerySelectorTelemetry({ + hasFrameData: true, + hasTopLevelData: false, + }); + + // Clear telemetry. + Services.fog.testResetFOG(); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_visibilityOverride.js b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_visibilityOverride.js new file mode 100644 index 0000000000..0846f92620 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_bannerClicking_visibilityOverride.js @@ -0,0 +1,84 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +// A test page that has an invisible cookie banner. This simulates sites where +// the banner is invisible whenever we test for it. See Bug 1793803. +const TEST_PAGE = TEST_ORIGIN_A + TEST_PATH + "file_banner_invisible.html"; + +add_setup(clickTestSetup); + +/** + * Insert a test rule with or without the skipPresenceVisibilityCheck flag. + * @param {boolean} skipPresenceVisibilityCheck - Whether to set the flag for + * the test rule. + */ +function insertVisibilityTestRules(skipPresenceVisibilityCheck) { + info("Clearing existing rules"); + Services.cookieBanners.resetRules(false); + + info( + "Inserting test rules. " + JSON.stringify({ skipPresenceVisibilityCheck }) + ); + + info("Add opt-out click rule for DOMAIN_A."); + let ruleA = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleA.id = genUUID(); + ruleA.domains = [TEST_DOMAIN_A]; + + ruleA.addClickRule( + "div#banner", + skipPresenceVisibilityCheck, + Ci.nsIClickRule.RUN_TOP, + null, + "button#optOut", + "button#optIn" + ); + Services.cookieBanners.insertRule(ruleA); +} + +/** + * Test that we click on an invisible banner element if + * skipPresenceVisibilityCheck is set. + */ +add_task(async function test_clicking_with_delayed_banner() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + for (let skipPresenceVisibilityCheck of [false, true]) { + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + insertVisibilityTestRules(skipPresenceVisibilityCheck); + + await testClickResultTelemetry({}); + + await openPageAndVerify({ + win: window, + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE, + visible: false, + expected: skipPresenceVisibilityCheck ? "OptOut" : "NoClick", + }); + + let expectedTelemetry; + if (skipPresenceVisibilityCheck) { + expectedTelemetry = { + success: 1, + success_dom_content_loaded: 1, + }; + } else { + expectedTelemetry = { + fail: 1, + fail_banner_not_visible: 1, + }; + } + await testClickResultTelemetry(expectedTelemetry); + } +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_cookiebanner_telemetry.js b/toolkit/components/cookiebanners/test/browser/browser_cookiebanner_telemetry.js new file mode 100644 index 0000000000..7366ae2ab6 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_cookiebanner_telemetry.js @@ -0,0 +1,781 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { SiteDataTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/SiteDataTestUtils.sys.mjs" +); + +const { MODE_DISABLED, MODE_REJECT, MODE_REJECT_OR_ACCEPT, MODE_UNSET } = + Ci.nsICookieBannerService; + +const TEST_MODES = [ + MODE_DISABLED, + MODE_REJECT, + MODE_REJECT_OR_ACCEPT, + MODE_UNSET, // Should be recorded as invalid. + 99, // Invalid + -1, // Invalid +]; + +function convertModeToTelemetryString(mode) { + switch (mode) { + case MODE_DISABLED: + return "disabled"; + case MODE_REJECT: + return "reject"; + case MODE_REJECT_OR_ACCEPT: + return "reject_or_accept"; + } + + return "invalid"; +} + +/** + * A helper function to verify the cookie rule look up telemetry. + * + * @param {String} probe The telemetry probe that we want to verify + * @param {Array} expected An array of objects that describe the expected value. + */ +function verifyLookUpTelemetry(probe, expected) { + for (let telemetry of expected) { + Assert.equal( + telemetry.count, + Glean.cookieBanners[probe][telemetry.label].testGetValue() + ); + } +} + +/** + * A helper function to verify the reload telemetry. + * + * @param {Number} length The expected length of the telemetry array. + * @param {Number} idx The index of the telemetry to be verified. + * @param {Object} expected An object that describe the expected value. + */ +function verifyReloadTelemetry(length, idx, expected) { + let events = Glean.cookieBanners.reload.testGetValue(); + + is(events.length, length, "There is a expected number of reload events."); + + let event = events[idx]; + + let { noRule, hasCookieRule, hasClickRule } = expected; + is(event.name, "reload", "The reload event has the correct name"); + is(event.extra.no_rule, noRule, "The extra field 'no_rule' is expected"); + is( + event.extra.has_cookie_rule, + hasCookieRule, + "The extra field 'has_cookie_rule' is expected" + ); + is( + event.extra.has_click_rule, + hasClickRule, + "The extra field 'has_click_rule' is expected" + ); +} + +/** + * A helper function to reload the browser and wait until it loads. + * + * @param {Browser} browser The browser object. + * @param {String} url The URL to be loaded. + */ +async function reloadBrowser(browser, url) { + let reloaded = BrowserTestUtils.browserLoaded(browser, false, url); + + // Reload as a user. + window.BrowserReload(); + + await reloaded; +} +/** + * A helper function to open the testing page for look up telemetry. + * + * @param {browser} browser The browser element + * @param {boolean} testInTop To indicate the page should be opened in top level + * @param {String} page The url of the testing page + * @param {String} domain The domain of the testing page + */ +async function openLookUpTelemetryTestPage(browser, testInTop, page, domain) { + let clickFinishPromise = promiseBannerClickingFinish(domain); + + if (testInTop) { + BrowserTestUtils.startLoadingURIString(browser, page); + } else { + BrowserTestUtils.startLoadingURIString(browser, TEST_ORIGIN_C); + await BrowserTestUtils.browserLoaded(browser); + + await SpecialPowers.spawn(browser, [page], async testURL => { + let iframe = content.document.createElement("iframe"); + iframe.src = testURL; + content.document.body.appendChild(iframe); + await ContentTaskUtils.waitForEvent(iframe, "load"); + }); + } + + await clickFinishPromise; +} + +add_setup(async function () { + // Clear telemetry before starting telemetry test. + Services.fog.testResetFOG(); + + registerCleanupFunction(async () => { + Services.prefs.clearUserPref("cookiebanners.service.mode"); + Services.prefs.clearUserPref("cookiebanners.service.mode.privateBrowsing"); + if ( + Services.prefs.getIntPref("cookiebanners.service.mode") != + Ci.nsICookieBannerService.MODE_DISABLED || + Services.prefs.getIntPref("cookiebanners.service.mode.privateBrowsing") != + Ci.nsICookieBannerService.MODE_DISABLED + ) { + // Restore original rules. + Services.cookieBanners.resetRules(true); + } + + // Clear cookies that have been set during testing. + await SiteDataTestUtils.clear(); + }); + + await clickTestSetup(); +}); + +add_task(async function test_service_mode_telemetry() { + let service = Cc["@mozilla.org/cookie-banner-service;1"].getService( + Ci.nsIObserver + ); + + for (let mode of TEST_MODES) { + for (let modePBM of TEST_MODES) { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", mode], + ["cookiebanners.service.mode.privateBrowsing", modePBM], + ], + }); + + // Trigger the idle-daily on the cookie banner service. + service.observe(null, "idle-daily", null); + + // Verify the telemetry value. + for (let label of ["disabled", "reject", "reject_or_accept", "invalid"]) { + let expected = convertModeToTelemetryString(mode) == label; + let expectedPBM = convertModeToTelemetryString(modePBM) == label; + + is( + Glean.cookieBanners.normalWindowServiceMode[label].testGetValue(), + expected, + `Has set label ${label} to ${expected} for mode ${mode}.` + ); + is( + Glean.cookieBanners.privateWindowServiceMode[label].testGetValue(), + expectedPBM, + `Has set label '${label}' to ${expected} for mode ${modePBM}.` + ); + } + + await SpecialPowers.popPrefEnv(); + } + } +}); + +add_task(async function test_rule_lookup_telemetry_no_rule() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ], + }); + + // Clear out all rules. + Services.cookieBanners.resetRules(false); + + // Open a tab for testing. + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + + for (let context of ["top", "iframe"]) { + let isTop = context === "top"; + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + // Open a test domain. We should record a rule miss because there is no rule + // right now + info("Open a test domain."); + await openLookUpTelemetryTestPage( + tab.linkedBrowser, + isTop, + TEST_ORIGIN_A, + TEST_DOMAIN_A + ); + + let expectedTelemetryOnce = [ + { + label: `${context}_miss`, + count: 1, + }, + { + label: `${context}_cookie_miss`, + count: 1, + }, + { + label: `${context}_click_miss`, + count: 1, + }, + ]; + verifyLookUpTelemetry("ruleLookupByLoad", expectedTelemetryOnce); + verifyLookUpTelemetry("ruleLookupByDomain", expectedTelemetryOnce); + + Services.cookieBanners.removeAllExecutedRecords(false); + + info("Open the same domain again."); + // Load the same domain again, verify that the telemetry counts increases for + // load telemetry not not for domain telemetry. + await openLookUpTelemetryTestPage( + tab.linkedBrowser, + isTop, + TEST_ORIGIN_A, + TEST_DOMAIN_A + ); + + let expectedTelemetryTwice = [ + { + label: `${context}_miss`, + count: 2, + }, + { + label: `${context}_cookie_miss`, + count: 2, + }, + { + label: `${context}_click_miss`, + count: 2, + }, + ]; + verifyLookUpTelemetry("ruleLookupByLoad", expectedTelemetryTwice); + verifyLookUpTelemetry("ruleLookupByDomain", expectedTelemetryOnce); + } + + Services.fog.testResetFOG(); + Services.cookieBanners.resetDomainTelemetryRecord(); + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_rule_lookup_telemetry() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ], + }); + insertTestClickRules(); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + // Open a tab for testing. + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser); + + for (let type of ["click", "cookie"]) { + info(`Running the test for lookup telemetry for ${type} rules.`); + // Clear out all rules. + Services.cookieBanners.resetRules(false); + + info("Insert rules."); + if (type === "click") { + insertTestClickRules(); + } else { + let ruleA = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleA.domains = [TEST_DOMAIN_A]; + + Services.cookieBanners.insertRule(ruleA); + ruleA.addCookie( + true, + `cookieConsent_${TEST_DOMAIN_A}_1`, + "optOut1", + null, + "/", + 3600, + "", + false, + false, + false, + 0, + 0 + ); + ruleA.addCookie( + false, + `cookieConsent_${TEST_DOMAIN_A}_2`, + "optIn2", + null, + "/", + 3600, + "", + false, + false, + false, + 0, + 0 + ); + + let ruleB = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleB.domains = [TEST_DOMAIN_B]; + + Services.cookieBanners.insertRule(ruleB); + ruleB.addCookie( + false, + `cookieConsent_${TEST_DOMAIN_B}_1`, + "optIn1", + null, + "/", + 3600, + "UNSET", + false, + false, + true, + 0, + 0 + ); + } + + for (let context of ["top", "iframe"]) { + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + info(`Test in a ${context} context.`); + let isTop = context === "top"; + + info("Load a domain with opt-in and opt-out clicking rules."); + await openLookUpTelemetryTestPage( + tab.linkedBrowser, + isTop, + TEST_ORIGIN_A, + TEST_DOMAIN_A + ); + + let expectedTelemetry = [ + { + label: `${context}_hit`, + count: 1, + }, + { + label: `${context}_hit_opt_in`, + count: 1, + }, + { + label: `${context}_hit_opt_out`, + count: 1, + }, + { + label: `${context}_${type}_hit`, + count: 1, + }, + { + label: `${context}_${type}_hit_opt_in`, + count: 1, + }, + { + label: `${context}_${type}_hit_opt_out`, + count: 1, + }, + ]; + verifyLookUpTelemetry("ruleLookupByLoad", expectedTelemetry); + verifyLookUpTelemetry("ruleLookupByDomain", expectedTelemetry); + + Services.cookieBanners.removeAllExecutedRecords(false); + + info("Load a domain with only opt-in clicking rules"); + await openLookUpTelemetryTestPage( + tab.linkedBrowser, + isTop, + TEST_ORIGIN_B, + TEST_DOMAIN_B + ); + + expectedTelemetry = [ + { + label: `${context}_hit`, + count: 2, + }, + { + label: `${context}_hit_opt_in`, + count: 2, + }, + { + label: `${context}_hit_opt_out`, + count: 1, + }, + { + label: `${context}_${type}_hit`, + count: 2, + }, + { + label: `${context}_${type}_hit_opt_in`, + count: 2, + }, + { + label: `${context}_${type}_hit_opt_out`, + count: 1, + }, + ]; + + verifyLookUpTelemetry("ruleLookupByLoad", expectedTelemetry); + verifyLookUpTelemetry("ruleLookupByDomain", expectedTelemetry); + + Services.cookieBanners.removeAllExecutedRecords(false); + + info( + "Load a domain again to verify that we don't collect domain telemetry for this time." + ); + await openLookUpTelemetryTestPage( + tab.linkedBrowser, + isTop, + TEST_ORIGIN_A, + TEST_DOMAIN_A + ); + + // The domain telemetry should't be changed. + verifyLookUpTelemetry("ruleLookupByDomain", expectedTelemetry); + + expectedTelemetry = [ + { + label: `${context}_hit`, + count: 3, + }, + { + label: `${context}_hit_opt_in`, + count: 3, + }, + { + label: `${context}_hit_opt_out`, + count: 2, + }, + { + label: `${context}_${type}_hit`, + count: 3, + }, + { + label: `${context}_${type}_hit_opt_in`, + count: 3, + }, + { + label: `${context}_${type}_hit_opt_out`, + count: 2, + }, + ]; + + // Verify that the load telemetry still increases. + verifyLookUpTelemetry("ruleLookupByLoad", expectedTelemetry); + } + + Services.fog.testResetFOG(); + Services.cookieBanners.resetDomainTelemetryRecord(); + } + + BrowserTestUtils.removeTab(tab); +}); + +add_task(async function test_reload_telemetry_no_rule() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ], + }); + + // Clear out all rules. + Services.cookieBanners.resetRules(false); + + // Open a tab for testing. + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + TEST_ORIGIN_A + ); + + // Make sure there is no reload event at the beginning. + let events = Glean.cookieBanners.reload.testGetValue(); + ok(!events, "No reload event at the beginning."); + + // Trigger the reload + await reloadBrowser(tab.linkedBrowser, TEST_ORIGIN_A + "/"); + + // Check the telemetry + verifyReloadTelemetry(1, 0, { + noRule: "true", + hasCookieRule: "false", + hasClickRule: "false", + }); + + BrowserTestUtils.removeTab(tab); + Services.fog.testResetFOG(); +}); + +add_task(async function test_reload_telemetry() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ], + }); + insertTestClickRules(); + + // Open a tab for testing. + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + TEST_ORIGIN_A + ); + + // Make sure there is no reload event at the beginning. + let events = Glean.cookieBanners.reload.testGetValue(); + ok(!events, "No reload event at the beginning."); + + // Trigger the reload + await reloadBrowser(tab.linkedBrowser, TEST_ORIGIN_A + "/"); + + // Check the telemetry + verifyReloadTelemetry(1, 0, { + noRule: "false", + hasCookieRule: "false", + hasClickRule: "true", + }); + + // Add a both click rule and cookie rule for another domain. + let cookieRule = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + cookieRule.domains = [TEST_DOMAIN_B]; + + Services.cookieBanners.insertRule(cookieRule); + cookieRule.addCookie( + false, + `cookieConsent_${TEST_DOMAIN_B}_1`, + "optIn1", + null, + "/", + 3600, + "UNSET", + false, + false, + true, + 0, + 0 + ); + cookieRule.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_ALL, + null, + null, + "button#optIn" + ); + + // Load the page with another origin. + BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, TEST_ORIGIN_B); + await BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + // Trigger the reload + await reloadBrowser(tab.linkedBrowser, TEST_ORIGIN_B + "/"); + + // Check the telemetry + verifyReloadTelemetry(2, 1, { + noRule: "false", + hasCookieRule: "true", + hasClickRule: "true", + }); + + BrowserTestUtils.removeTab(tab); + Services.fog.testResetFOG(); +}); + +add_task(async function test_reload_telemetry_mode_disabled() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ], + }); + insertTestClickRules(); + + // Disable the cookie banner service in normal browsing. + // Keep it enabled in PBM so the service stays alive and can still collect telemetry. + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_DISABLED], + ], + }); + + // Open a tab for testing. + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + TEST_ORIGIN_A + ); + + // Trigger the reload + await reloadBrowser(tab.linkedBrowser, TEST_ORIGIN_A + "/"); + + // Check the telemetry. The reload telemetry should report no rule given that + // the service is disabled. + verifyReloadTelemetry(1, 0, { + noRule: "true", + hasCookieRule: "false", + hasClickRule: "false", + }); + + BrowserTestUtils.removeTab(tab); + Services.fog.testResetFOG(); +}); + +add_task(async function test_reload_telemetry_mode_reject() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + insertTestClickRules(); + + // Open a tab for testing. + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + TEST_ORIGIN_A + ); + + // Trigger the reload + await reloadBrowser(tab.linkedBrowser, TEST_ORIGIN_A + "/"); + + // Check the telemetry. The reload telemetry should report there is click rule + // for the domain has opt-out rule. + verifyReloadTelemetry(1, 0, { + noRule: "false", + hasCookieRule: "false", + hasClickRule: "true", + }); + + // Load the page with the domain only has opt-in click rule. + BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, TEST_ORIGIN_B); + await BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + // Trigger the reload + await reloadBrowser(tab.linkedBrowser, TEST_ORIGIN_B + "/"); + + // Check the telemetry. It should report there is no rule because the domain + // only has an opt-in click rule. + verifyReloadTelemetry(2, 1, { + noRule: "true", + hasCookieRule: "false", + hasClickRule: "false", + }); + + BrowserTestUtils.removeTab(tab); + Services.fog.testResetFOG(); +}); + +add_task(async function test_reload_telemetry_iframe() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ], + }); + + // Clear out all rules. + Services.cookieBanners.resetRules(false); + + // Insert a click rule for an iframe case. And add a cookie rule for the same + // domain. We shouldn't report there is a cookie rule for iframe because + // cookie rules are top-level only. + let cookieRule = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + cookieRule.domains = [TEST_DOMAIN_A]; + Services.cookieBanners.insertRule(cookieRule); + + cookieRule.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_CHILD, + null, + null, + "button#optIn" + ); + cookieRule.addCookie( + false, + `cookieConsent_${TEST_DOMAIN_A}_1`, + "optIn1", + null, + "/", + 3600, + "UNSET", + false, + false, + true, + 0, + 0 + ); + + // Open a tab for testing. + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + TEST_ORIGIN_C + TEST_PATH + "file_iframe_banner.html" + ); + + // Trigger the reload + await reloadBrowser( + tab.linkedBrowser, + TEST_ORIGIN_C + TEST_PATH + "file_iframe_banner.html" + ); + + // Check the telemetry + verifyReloadTelemetry(1, 0, { + noRule: "false", + hasCookieRule: "false", + hasClickRule: "true", + }); + + BrowserTestUtils.removeTab(tab); + Services.fog.testResetFOG(); +}); + +add_task(async function test_service_detectOnly_telemetry() { + let service = Cc["@mozilla.org/cookie-banner-service;1"].getService( + Ci.nsIObserver + ); + + for (let detectOnly of [true, false, true]) { + await SpecialPowers.pushPrefEnv({ + set: [["cookiebanners.service.detectOnly", detectOnly]], + }); + + // Trigger the idle-daily on the cookie banner service. + service.observe(null, "idle-daily", null); + + is( + Glean.cookieBanners.serviceDetectOnly.testGetValue(), + detectOnly, + `Has set detect-only metric to ${detectOnly}.` + ); + + await SpecialPowers.popPrefEnv(); + } +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_cookiebanner_webconsole.js b/toolkit/components/cookiebanners/test/browser/browser_cookiebanner_webconsole.js new file mode 100644 index 0000000000..20b1d490a8 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_cookiebanner_webconsole.js @@ -0,0 +1,101 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { SiteDataTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/SiteDataTestUtils.sys.mjs" +); + +/** + * Registers a console listener and waits for the cookie banner handled message + * to be logged. + * @returns {Promise} - Promise which resolves once the message has been logged. + */ +async function waitForCookieBannerHandledConsoleMsg() { + let msg; + let checkFn = msg => + msg && msg.match(/handled a cookie banner on behalf of the user./); + await new Promise(resolve => { + SpecialPowers.registerConsoleListener(consoleMsg => { + msg = consoleMsg.message; + if (checkFn(msg)) { + resolve(); + } + }); + }); + SpecialPowers.postConsoleSentinel(); + + ok(checkFn(msg), "Observed cookie banner handled console message."); +} + +add_setup(clickTestSetup); + +/** + * Tests that when we handle a banner via clicking a message is logged to the + * website console. + */ +add_task(async function test_banner_clicking_log_web_console() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ], + }); + + insertTestClickRules(); + + let consoleMsgPromise = waitForCookieBannerHandledConsoleMsg(); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + info("Handle the banner via click and wait for console message to appear."); + await openPageAndVerify({ + domain: TEST_DOMAIN_A, + testURL: TEST_PAGE_A, + visible: false, + expected: "OptOut", + }); + + await consoleMsgPromise; +}); + +/** + * Tests that when we handle a banner via cookie injection a message is logged + * to the website console. + */ +add_task(async function test_cookie_injection_log_web_console() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + + insertTestCookieRules(); + + let consoleMsgPromise = waitForCookieBannerHandledConsoleMsg(); + + // Clear the executed records before testing. + Services.cookieBanners.removeAllExecutedRecords(false); + + info( + "Handle the banner via cookie injection and wait for console message to appear." + ); + let tab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + TEST_ORIGIN_A + ); + BrowserTestUtils.removeTab(tab); + + await consoleMsgPromise; + + // Clear injected cookies. + await SiteDataTestUtils.clear(); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice.js b/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice.js new file mode 100644 index 0000000000..361d6cb189 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice.js @@ -0,0 +1,635 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_setup(async function () { + registerCleanupFunction(() => { + Services.prefs.clearUserPref("cookiebanners.service.mode"); + Services.prefs.clearUserPref("cookiebanners.service.mode.privateBrowsing"); + if ( + Services.prefs.getIntPref("cookiebanners.service.mode") != + Ci.nsICookieBannerService.MODE_DISABLED || + Services.prefs.getIntPref("cookiebanners.service.mode.privateBrowsing") != + Ci.nsICookieBannerService.MODE_DISABLED + ) { + // Restore original rules. + Services.cookieBanners.resetRules(true); + } + }); +}); + +add_task(async function test_insertAndGetRule() { + info("Enabling cookie banner service with MODE_REJECT"); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + info("Clear any preexisting rules"); + Services.cookieBanners.resetRules(false); + + is( + Services.cookieBanners.rules.length, + 0, + "Cookie banner service has no rules initially." + ); + + info("Test that we can't import rules with empty domain field."); + let ruleInvalid = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + Assert.throws( + () => { + Services.cookieBanners.insertRule(ruleInvalid); + }, + /NS_ERROR_FAILURE/, + "Inserting an invalid rule missing a domain should throw." + ); + + let rule = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + rule.domains = ["example.com"]; + + Services.cookieBanners.insertRule(rule); + + is( + rule.cookiesOptOut.length, + 0, + "Should not have any opt-out cookies initially" + ); + is( + rule.cookiesOptIn.length, + 0, + "Should not have any opt-in cookies initially" + ); + + info("Clearing preexisting cookies rules for example.com."); + rule.clearCookies(); + + info("Adding cookies to the rule for example.com."); + rule.addCookie( + true, + "foo", + "bar", + "example.com", + "/", + 3600, + "", + false, + false, + false, + 0, + 0 + ); + rule.addCookie( + true, + "foobar", + "barfoo", + "example.com", + "/", + 3600, + "", + false, + false, + false, + 0, + 0 + ); + rule.addCookie( + false, + "foo", + "bar", + "foo.example.com", + "/myPath", + 3600, + "", + false, + false, + true, + 0, + 0 + ); + + info("Adding a click rule to the rule for example.com."); + rule.addClickRule( + "div#presence", + false, + Ci.nsIClickRule.RUN_TOP, + "div#hide", + "div#optOut", + "div#optIn" + ); + + is(rule.cookiesOptOut.length, 2, "Should have two opt-out cookies."); + is(rule.cookiesOptIn.length, 1, "Should have one opt-in cookie."); + + is( + Services.cookieBanners.rules.length, + 1, + "Cookie Banner Service has one rule." + ); + + let rule2 = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + rule2.domains = ["example.org"]; + + Services.cookieBanners.insertRule(rule2); + info("Clearing preexisting cookies rules for example.org."); + rule2.clearCookies(); + + info("Adding a cookie to the rule for example.org."); + rule2.addCookie( + false, + "foo2", + "bar2", + "example.org", + "/", + 0, + "", + false, + false, + false, + 0, + 0 + ); + + info("Adding a click rule to the rule for example.org."); + rule2.addClickRule( + "div#presence", + false, + Ci.nsIClickRule.RUN_TOP, + null, + null, + "div#optIn" + ); + + is( + Services.cookieBanners.rules.length, + 2, + "Cookie Banner Service has two rules." + ); + + info("Getting cookies by URI for example.com."); + let ruleArray = Services.cookieBanners.getCookiesForURI( + Services.io.newURI("http://example.com"), + false + ); + ok( + ruleArray && Array.isArray(ruleArray), + "getCookiesForURI should return a rule array." + ); + is(ruleArray.length, 2, "rule array should contain 2 rules."); + ruleArray.every(rule => { + ok(rule instanceof Ci.nsICookieRule, "Rule should have correct type."); + is(rule.cookie.host, "example.com", "Rule should have correct host."); + }); + + info("Clearing cookies of rule."); + rule.clearCookies(); + is(rule.cookiesOptOut.length, 0, "Should have no opt-out cookies."); + is(rule.cookiesOptIn.length, 0, "Should have no opt-in cookies."); + + info("Getting the click rule for example.com."); + let clickRules = Services.cookieBanners.getClickRulesForDomain( + "example.com", + true + ); + is( + clickRules.length, + 1, + "There should be one domain-specific click rule for example.com" + ); + let [clickRule] = clickRules; + + is( + clickRule.presence, + "div#presence", + "Should have the correct presence selector." + ); + is(clickRule.hide, "div#hide", "Should have the correct hide selector."); + is( + clickRule.optOut, + "div#optOut", + "Should have the correct optOut selector." + ); + is(clickRule.optIn, "div#optIn", "Should have the correct optIn selector."); + + info("Getting cookies by URI for example.org."); + let ruleArray2 = Services.cookieBanners.getCookiesForURI( + Services.io.newURI("http://example.org"), + false + ); + ok( + ruleArray2 && Array.isArray(ruleArray2), + "getCookiesForURI should return a rule array." + ); + is( + ruleArray2.length, + 0, + "rule array should contain no rules in MODE_REJECT (opt-out only)" + ); + + info("Getting the click rule for example.org."); + let clickRules2 = Services.cookieBanners.getClickRulesForDomain( + "example.org", + true + ); + is( + clickRules2.length, + 1, + "There should be one domain-specific click rule for example.org" + ); + let [clickRule2] = clickRules2; + is( + clickRule2.presence, + "div#presence", + "Should have the correct presence selector." + ); + ok(!clickRule2.hide, "Should have no hide selector."); + ok(!clickRule2.optOut, "Should have no target selector."); + is(clickRule.optIn, "div#optIn", "Should have the correct optIn selector."); + + info("Switching cookiebanners.service.mode to MODE_REJECT_OR_ACCEPT."); + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ], + }); + + ruleArray2 = Services.cookieBanners.getCookiesForURI( + Services.io.newURI("http://example.org"), + false + ); + ok( + ruleArray2 && Array.isArray(ruleArray2), + "getCookiesForURI should return a rule array." + ); + is( + ruleArray2.length, + 1, + "rule array should contain one rule in mode MODE_REJECT_OR_ACCEPT (opt-out or opt-in)" + ); + + info("Calling getCookiesForURI for unknown domain."); + let ruleArrayUnknown = Services.cookieBanners.getCookiesForURI( + Services.io.newURI("http://example.net"), + false + ); + ok( + ruleArrayUnknown && Array.isArray(ruleArrayUnknown), + "getCookiesForURI should return a rule array." + ); + is(ruleArrayUnknown.length, 0, "rule array should contain no rules."); + + // Cleanup. + Services.cookieBanners.resetRules(false); +}); + +add_task(async function test_removeRule() { + info("Enabling cookie banner service with MODE_REJECT"); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + info("Clear any preexisting rules"); + Services.cookieBanners.resetRules(false); + + is( + Services.cookieBanners.rules.length, + 0, + "Cookie banner service has no rules initially." + ); + + let rule = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + rule.id = genUUID(); + rule.domains = ["example.com"]; + + Services.cookieBanners.insertRule(rule); + + let rule2 = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + rule2.id = genUUID(); + rule2.domains = ["example.org"]; + + Services.cookieBanners.insertRule(rule2); + + is( + Services.cookieBanners.rules.length, + 2, + "Cookie banner service two rules after insert." + ); + + info("Removing rule for non existent example.net"); + let ruleExampleNet = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleExampleNet.id = genUUID(); + ruleExampleNet.domains = ["example.net"]; + Services.cookieBanners.removeRule(ruleExampleNet); + + is( + Services.cookieBanners.rules.length, + 2, + "Cookie banner service still has two rules." + ); + + info("Removing rule for non existent global rule."); + let ruleGlobal = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleGlobal.id = genUUID(); + ruleGlobal.domains = []; + Services.cookieBanners.removeRule(ruleGlobal); + + is( + Services.cookieBanners.rules.length, + 2, + "Cookie banner service still has two rules." + ); + + info("Removing rule for example.com"); + Services.cookieBanners.removeRule(rule); + + is( + Services.cookieBanners.rules.length, + 1, + "Cookie banner service should have one rule left after remove." + ); + + is( + Services.cookieBanners.rules[0].domains[0], + "example.org", + "It should be the example.org rule." + ); + + // Cleanup. + Services.cookieBanners.resetRules(false); +}); + +add_task(async function test_overwriteRule() { + info("Enabling cookie banner service with MODE_REJECT"); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + info("Clear any preexisting rules"); + Services.cookieBanners.resetRules(false); + + is( + Services.cookieBanners.rules.length, + 0, + "Cookie banner service has no rules initially." + ); + + let rule = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + rule.domains = ["example.com"]; + + info("Adding a cookie so we can detect if the rule updates."); + rule.addCookie( + true, + "foo", + "original", + "example.com", + "/", + 3600, + "", + false, + false, + false, + 0, + 0 + ); + + info("Adding a click rule so we can detect if the rule updates."); + rule.addClickRule("div#original"); + + Services.cookieBanners.insertRule(rule); + + let { cookie } = Services.cookieBanners.rules[0].cookiesOptOut[0]; + + is(cookie.name, "foo", "Should have set the correct cookie name."); + is(cookie.value, "original", "Should have set the correct cookie value."); + + info("Add a new rule with the same domain. It should be overwritten."); + + let ruleNew = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleNew.domains = ["example.com"]; + + ruleNew.addCookie( + true, + "foo", + "new", + "example.com", + "/", + 3600, + "", + false, + false, + false, + 0, + 0 + ); + + ruleNew.addClickRule("div#new"); + + Services.cookieBanners.insertRule(ruleNew); + + let { cookie: cookieNew } = Services.cookieBanners.rules[0].cookiesOptOut[0]; + is(cookieNew.name, "foo", "Should have set the original cookie name."); + is(cookieNew.value, "new", "Should have set the updated cookie value."); + + let { presence: presenceNew } = Services.cookieBanners.rules[0].clickRule; + is(presenceNew, "div#new", "Should have set the updated presence value"); + + // Cleanup. + Services.cookieBanners.resetRules(false); +}); + +add_task(async function test_globalRules() { + info("Enabling cookie banner service with MODE_REJECT"); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.service.enableGlobalRules", true], + ], + }); + + info("Clear any preexisting rules"); + Services.cookieBanners.resetRules(false); + + is( + Services.cookieBanners.rules.length, + 0, + "Cookie banner service has no rules initially." + ); + + info("Insert a site-specific rule for example.com"); + let rule = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + rule.id = genUUID(); + rule.domains = ["example.com"]; + rule.addCookie( + true, + "foo", + "new", + "example.com", + "/", + 3600, + "", + false, + false, + false, + 0, + 0 + ); + rule.addClickRule( + "#cookieBannerExample", + false, + Ci.nsIClickRule.RUN_TOP, + "#btnOptOut", + "#btnOptIn" + ); + Services.cookieBanners.insertRule(rule); + + info( + "Insert a global rule with a cookie and a click rule. The cookie rule shouldn't be used." + ); + let ruleGlobalA = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleGlobalA.id = genUUID(); + ruleGlobalA.domains = []; + ruleGlobalA.addCookie( + true, + "foo", + "new", + "example.net", + "/", + 3600, + "", + false, + false, + false, + 0, + 0 + ); + ruleGlobalA.addClickRule( + "#globalCookieBanner", + false, + Ci.nsIClickRule.RUN_TOP, + "#btnOptOut", + "#btnOptIn" + ); + Services.cookieBanners.insertRule(ruleGlobalA); + + info("Insert a second global rule"); + let ruleGlobalB = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleGlobalB.id = genUUID(); + ruleGlobalB.domains = []; + ruleGlobalB.addClickRule( + "#globalCookieBannerB", + false, + Ci.nsIClickRule.RUN_TOP, + "#btnOptOutB", + "#btnOptIn" + ); + Services.cookieBanners.insertRule(ruleGlobalB); + + is( + Services.cookieBanners.rules.length, + 3, + "Cookie Banner Service has three rules." + ); + + is( + Services.cookieBanners.getCookiesForURI( + Services.io.newURI("http://example.com"), + false + ).length, + 1, + "There should be a cookie rule for example.com" + ); + + is( + Services.cookieBanners.getClickRulesForDomain("example.com", true).length, + 1, + "There should be a a click rule for example.com" + ); + + is( + Services.cookieBanners.getCookiesForURI( + Services.io.newURI("http://thishasnorule.com"), + false + ).length, + 0, + "There should be no cookie rule for thishasnorule.com" + ); + + let clickRules = Services.cookieBanners.getClickRulesForDomain( + "thishasnorule.com", + true + ); + is( + clickRules.length, + 2, + "There should be two click rules for thishasnorule.com" + ); + ok( + clickRules.every(rule => rule.presence.startsWith("#globalCookieBanner")), + "The returned click rules should be global rules." + ); + + info("Disabling global rules"); + await SpecialPowers.pushPrefEnv({ + set: [["cookiebanners.service.enableGlobalRules", false]], + }); + + is( + Services.cookieBanners.rules.length, + 1, + "Cookie Banner Service has 1 rule." + ); + + is( + Services.cookieBanners.rules[0].id, + rule.id, + "It should be the domain specific rule" + ); + + is( + Services.cookieBanners.getCookiesForURI( + Services.io.newURI("http://thishasnorule.com"), + false + ).length, + 0, + "There should be no cookie rule for thishasnorule.com" + ); + + is( + Services.cookieBanners.getClickRulesForDomain("thishasnorule.com", true) + .length, + 0, + "There should be no click rules for thishasnorule.com since global rules are disabled" + ); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_domainPrefs.js b/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_domainPrefs.js new file mode 100644 index 0000000000..700155ada3 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_domainPrefs.js @@ -0,0 +1,403 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_setup(async function () { + registerCleanupFunction(() => { + Services.prefs.clearUserPref("cookiebanners.service.mode"); + Services.prefs.clearUserPref("cookiebanners.service.mode.privateBrowsing"); + if ( + Services.prefs.getIntPref("cookiebanners.service.mode") != + Ci.nsICookieBannerService.MODE_DISABLED || + Services.prefs.getIntPref("cookiebanners.service.mode.privateBrowsing") != + Ci.nsICookieBannerService.MODE_DISABLED + ) { + // Restore original rules. + Services.cookieBanners.resetRules(true); + } + }); +}); + +add_task(async function test_domain_preference() { + info("Enabling cookie banner service with MODE_REJECT"); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + let uri = Services.io.newURI("http://example.com"); + + // Check no site preference at the beginning + is( + Services.cookieBanners.getDomainPref(uri, false), + Ci.nsICookieBannerService.MODE_UNSET, + "There should be no per site preference at the beginning." + ); + + // Check setting and getting a site preference. + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT, + false + ); + + is( + Services.cookieBanners.getDomainPref(uri, false), + Ci.nsICookieBannerService.MODE_REJECT, + "Can get site preference for example.com with the correct value." + ); + + // Check site preference is shared between http and https. + let uriHttps = Services.io.newURI("https://example.com"); + is( + Services.cookieBanners.getDomainPref(uriHttps, false), + Ci.nsICookieBannerService.MODE_REJECT, + "Can get site preference for example.com in secure context." + ); + + // Check site preference in the other domain, example.org. + let uriOther = Services.io.newURI("https://example.org"); + is( + Services.cookieBanners.getDomainPref(uriOther, false), + Ci.nsICookieBannerService.MODE_UNSET, + "There should be no domain preference for example.org." + ); + + // Check setting site preference won't affect the other domain. + Services.cookieBanners.setDomainPref( + uriOther, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + false + ); + + is( + Services.cookieBanners.getDomainPref(uriOther, false), + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + "Can get domain preference for example.org with the correct value." + ); + is( + Services.cookieBanners.getDomainPref(uri, false), + Ci.nsICookieBannerService.MODE_REJECT, + "Can get site preference for example.com" + ); + + // Check nsICookieBannerService.setDomainPrefAndPersistInPrivateBrowsing(). + Services.cookieBanners.setDomainPrefAndPersistInPrivateBrowsing( + uri, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT + ); + is( + Services.cookieBanners.getDomainPref(uri, true), + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + "Can get site preference for example.com" + ); + + // Check removing the site preference. + Services.cookieBanners.removeDomainPref(uri, false); + is( + Services.cookieBanners.getDomainPref(uri, false), + Ci.nsICookieBannerService.MODE_UNSET, + "There should be no site preference for example.com." + ); + + // Check remove all site preferences. + Services.cookieBanners.removeAllDomainPrefs(false); + is( + Services.cookieBanners.getDomainPref(uri, false), + Ci.nsICookieBannerService.MODE_UNSET, + "There should be no site preference for example.com." + ); + is( + Services.cookieBanners.getDomainPref(uriOther, false), + Ci.nsICookieBannerService.MODE_UNSET, + "There should be no site preference for example.org." + ); +}); + +add_task(async function test_domain_preference_dont_override_disable_pref() { + info("Enabling cookie banner service with MODE_REJECT"); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + info("Adding a domain preference for example.com"); + let uri = Services.io.newURI("https://example.com"); + + // Set a domain preference. + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT, + false + ); + + info("Disabling the cookie banner service."); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_DISABLED], + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_DISABLED, + ], + ], + }); + + info("Verifying if the cookie banner service is disabled."); + Assert.throws( + () => { + Services.cookieBanners.getDomainPref(uri, false); + }, + /NS_ERROR_NOT_AVAILABLE/, + "Should have thrown NS_ERROR_NOT_AVAILABLE for getDomainPref." + ); + + info("Enable the service again in order to clear the domain prefs."); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + Services.cookieBanners.removeAllDomainPrefs(false); +}); + +/** + * Test that domain preference is properly cleared when private browsing session + * ends. + */ +add_task(async function test_domain_preference_cleared_PBM_ends() { + info("Enabling cookie banner service with MODE_REJECT"); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + info("Adding a domain preference for example.com in PBM"); + let uri = Services.io.newURI("https://example.com"); + + info("Open a private browsing window."); + let PBMWin = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + + // Set a domain preference for PBM. + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_DISABLED, + true + ); + + info("Verifying if the cookie banner domain pref is set for PBM."); + is( + Services.cookieBanners.getDomainPref(uri, true), + Ci.nsICookieBannerService.MODE_DISABLED, + "The domain pref is properly set for PBM." + ); + + info("Trigger an ending of a private browsing window session"); + let PBMSessionEndsObserved = TestUtils.topicObserved( + "last-pb-context-exited" + ); + + // Close the PBM window and wait until it finishes. + await BrowserTestUtils.closeWindow(PBMWin); + await PBMSessionEndsObserved; + + info("Verify if the private domain pref is cleared."); + is( + Services.cookieBanners.getDomainPref(uri, true), + Ci.nsICookieBannerService.MODE_UNSET, + "The domain pref is properly set for PBM." + ); +}); + +/** + * Test that the persistent domain preference won't be cleared when private + * browsing session ends. + */ +add_task(async function test_persistent_domain_preference_remain_PBM_ends() { + info("Enabling cookie banner service with MODE_REJECT"); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + info("Adding a domain preference for example.com in PBM"); + let uri = Services.io.newURI("https://example.com"); + + info("Open a private browsing window."); + let PBMWin = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + + // Set a domain preference for PBM. + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_DISABLED, + true + ); + + info("Verifying if the cookie banner domain pref is set for PBM."); + is( + Services.cookieBanners.getDomainPref(uri, true), + Ci.nsICookieBannerService.MODE_DISABLED, + "The domain pref is properly set for PBM." + ); + + info("Adding a persistent domain preference for example.org in PBM"); + let uriPersistent = Services.io.newURI("https://example.org"); + + // Set a persistent domain preference for PBM. + Services.cookieBanners.setDomainPrefAndPersistInPrivateBrowsing( + uriPersistent, + Ci.nsICookieBannerService.MODE_DISABLED + ); + + info("Trigger an ending of a private browsing window session"); + let PBMSessionEndsObserved = TestUtils.topicObserved( + "last-pb-context-exited" + ); + + // Close the PBM window and wait until it finishes. + await BrowserTestUtils.closeWindow(PBMWin); + await PBMSessionEndsObserved; + + info("Verify if the private domain pref is cleared."); + is( + Services.cookieBanners.getDomainPref(uri, true), + Ci.nsICookieBannerService.MODE_UNSET, + "The domain pref is properly set for PBM." + ); + + info("Verify if the persistent private domain pref remains."); + is( + Services.cookieBanners.getDomainPref(uriPersistent, true), + Ci.nsICookieBannerService.MODE_DISABLED, + "The persistent domain pref remains for PBM after private session ends." + ); +}); + +add_task(async function test_remove_persistent_domain_pref_in_PBM() { + info("Enabling cookie banner service with MODE_REJECT"); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + info("Adding a domain preference for example.com in PBM"); + let uri = Services.io.newURI("https://example.com"); + + info("Open a private browsing window."); + let PBMWin = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + + // Set a persistent domain preference for PBM. + Services.cookieBanners.setDomainPrefAndPersistInPrivateBrowsing( + uri, + Ci.nsICookieBannerService.MODE_DISABLED + ); + + info("Verifying if the cookie banner domain pref is set for PBM."); + is( + Services.cookieBanners.getDomainPref(uri, true), + Ci.nsICookieBannerService.MODE_DISABLED, + "The domain pref is properly set for PBM." + ); + + info("Remove the persistent domain pref."); + Services.cookieBanners.removeDomainPref(uri, true); + + info("Trigger an ending of a private browsing window session"); + let PBMSessionEndsObserved = TestUtils.topicObserved( + "last-pb-context-exited" + ); + + // Close the PBM window and wait until it finishes. + await BrowserTestUtils.closeWindow(PBMWin); + await PBMSessionEndsObserved; + + info( + "Verify if the private domain pref is no longer persistent and cleared." + ); + is( + Services.cookieBanners.getDomainPref(uri, true), + Ci.nsICookieBannerService.MODE_UNSET, + "The domain pref is properly set for PBM." + ); +}); + +/** + * Test that the persistent state of a domain pref in PMB can be override by new + * call without persistent state. + */ +add_task(async function test_override_persistent_state_in_PBM() { + info("Enabling cookie banner service with MODE_REJECT"); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + info("Adding a domain preference for example.com in PBM"); + let uri = Services.io.newURI("https://example.com"); + + info("Open a private browsing window."); + let PBMWin = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + + // Set a persistent domain preference for PBM. + Services.cookieBanners.setDomainPrefAndPersistInPrivateBrowsing( + uri, + Ci.nsICookieBannerService.MODE_DISABLED + ); + + info("Trigger an ending of a private browsing window session"); + let PBMSessionEndsObserved = TestUtils.topicObserved( + "last-pb-context-exited" + ); + + // Close the PBM window and wait until it finishes. + await BrowserTestUtils.closeWindow(PBMWin); + await PBMSessionEndsObserved; + + info("Verify if the persistent private domain pref remains."); + is( + Services.cookieBanners.getDomainPref(uri, true), + Ci.nsICookieBannerService.MODE_DISABLED, + "The persistent domain pref remains for PBM after private session ends." + ); + + info("Open a private browsing window again."); + PBMWin = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + + info("Override the persistent domain pref with non-persistent domain pref."); + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_DISABLED, + true + ); + + info("Trigger an ending of a private browsing window session again"); + PBMSessionEndsObserved = TestUtils.topicObserved("last-pb-context-exited"); + + // Close the PBM window and wait until it finishes. + await BrowserTestUtils.closeWindow(PBMWin); + await PBMSessionEndsObserved; + + info("Verify if the private domain pref is cleared."); + is( + Services.cookieBanners.getDomainPref(uri, true), + Ci.nsICookieBannerService.MODE_UNSET, + "The domain pref is properly set for PBM." + ); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_getRules.js b/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_getRules.js new file mode 100644 index 0000000000..fcc6078e28 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_getRules.js @@ -0,0 +1,88 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +let testRules = [ + // Cookie rule with multiple domains. + { + id: "0e4cdbb8-b688-47e0-9c8b-4db620398dbd", + click: {}, + cookies: { + optIn: [ + { + name: "foo", + value: "bar", + }, + ], + }, + domains: [TEST_DOMAIN_A, TEST_DOMAIN_B], + }, + // Click rule with single domain. + { + id: "0560e02c-a50f-4e7b-86e0-d6b7d258eb5f", + click: { + optOut: "#optOutBtn", + presence: "#cookieBanner", + }, + cookies: {}, + domains: [TEST_DOMAIN_C], + }, +]; + +add_setup(async function () { + // Enable the service and insert the test rules. + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ["cookiebanners.listService.testSkipRemoteSettings", true], + ["cookiebanners.listService.testRules", JSON.stringify(testRules)], + ["cookiebanners.listService.logLevel", "Debug"], + ], + }); + + Services.cookieBanners.resetRules(true); +}); + +function ruleCountForDomain(domain) { + return Services.cookieBanners.rules.filter(rule => + rule.domains.includes(domain) + ).length; +} + +/** + * Tests that the rules getter does not return duplicate rules for rules with + * multiple domains. + */ +add_task(async function test_rules_getter_no_duplicates() { + // The rule import is async because it needs to fetch rules from + // RemoteSettings. Wait for the test rules to be applied. + // See CookieBannerListService#importAllRules. + await BrowserTestUtils.waitForCondition( + () => Services.cookieBanners.rules.length, + "Waiting for test rules to be imported." + ); + is( + Services.cookieBanners.rules.length, + 2, + "Rules getter should only return the two test rules." + ); + is( + ruleCountForDomain(TEST_DOMAIN_A), + 1, + "There should only be one rule with TEST_DOMAIN_A." + ); + is( + ruleCountForDomain(TEST_DOMAIN_B), + 1, + "There should only be one rule with TEST_DOMAIN_B." + ); + is( + ruleCountForDomain(TEST_DOMAIN_C), + 1, + "There should only be one rule with TEST_DOMAIN_C." + ); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_hasRuleForBCTree.js b/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_hasRuleForBCTree.js new file mode 100644 index 0000000000..815fd115e9 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_hasRuleForBCTree.js @@ -0,0 +1,293 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { SiteDataTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/SiteDataTestUtils.sys.mjs" +); + +let testRules = [ + // Top-level cookie rule. + { + id: "87815b2d-a840-4155-8713-f8a26d1f483a", + click: {}, + cookies: { + optIn: [ + { + name: "foo", + value: "bar", + }, + ], + }, + domains: [TEST_DOMAIN_B], + }, + // Child click rule. + { + id: "d42bbaee-f96e-47e7-8e81-efc642518e97", + click: { + optOut: "#optOutBtn", + presence: "#cookieBanner", + runContext: "child", + }, + cookies: {}, + domains: [TEST_DOMAIN_C], + }, + // Top level click rule. + { + id: "19dd1f52-f3e6-4a24-a926-d77f553d1b15", + click: { + optOut: "#optOutBtn", + presence: "#cookieBanner", + }, + cookies: {}, + domains: [TEST_DOMAIN_A], + }, +]; + +/** + * Insert an iframe and wait for it to load. + * @param {BrowsingContext} parentBC - The BC the frame to insert under. + * @param {string} uri - The URI to load in the frame. + * @returns {Promise} - A Promise which resolves once the frame has loaded. + */ +function insertIframe(parentBC, uri) { + return SpecialPowers.spawn(parentBC, [uri], async testURL => { + let iframe = content.document.createElement("iframe"); + iframe.src = testURL; + content.document.body.appendChild(iframe); + await ContentTaskUtils.waitForEvent(iframe, "load"); + return iframe.browsingContext; + }); +} + +add_setup(async function () { + // Enable the service and insert the test rules. We only test + // MODE_REJECT_OR_ACCEPT here as the other modes are covered by other tests + // already and hasRuleForBrowsingContextTree mostly shares logic with other + // service getters. + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ["cookiebanners.listService.testSkipRemoteSettings", true], + ["cookiebanners.listService.testRules", JSON.stringify(testRules)], + ], + }); + + // Ensure the test rules have been applied before the first test starts. + Services.cookieBanners.resetRules(); + + // Visiting sites in this test can set cookies. Clean them up on test exit. + registerCleanupFunction(async () => { + await SiteDataTestUtils.clear(); + }); +}); + +add_task(async function test_unsupported() { + let unsupportedURIs = { + "about:preferences": /NS_ERROR_FAILURE/, + "about:blank": false, + }; + + for (let [key, value] of Object.entries(unsupportedURIs)) { + await BrowserTestUtils.withNewTab(key, async browser => { + if (typeof value == "object") { + // It's an error code. + Assert.throws( + () => { + Services.cookieBanners.hasRuleForBrowsingContextTree( + browser.browsingContext + ); + }, + value, + `Should throw ${value} for hasRuleForBrowsingContextTree call for '${key}'.` + ); + } else { + is( + Services.cookieBanners.hasRuleForBrowsingContextTree( + browser.browsingContext + ), + value, + `Should return expected value for hasRuleForBrowsingContextTree for '${key}'` + ); + } + }); + } +}); + +add_task(async function test_hasRuleForBCTree() { + info("Test with top level A"); + await BrowserTestUtils.withNewTab(TEST_ORIGIN_A, async browser => { + let bcTop = browser.browsingContext; + + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should have rule when called with top BC for A" + ); + + info("inserting frame with TEST_ORIGIN_A"); + let bcChildA = await insertIframe(bcTop, TEST_ORIGIN_A); + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should still have rule when called with top BC for A." + ); + ok( + !Services.cookieBanners.hasRuleForBrowsingContextTree(bcChildA), + "Should not have rule when called with child BC for A, because A has no child click-rule." + ); + }); + + info("Test with top level C"); + await BrowserTestUtils.withNewTab(TEST_ORIGIN_C, async browser => { + let bcTop = browser.browsingContext; + + ok( + !Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should have no rule when called with top BC for C, because C only has a child click rule." + ); + + info("inserting frame with TEST_ORIGIN_C"); + let bcChildC = await insertIframe(bcTop, TEST_ORIGIN_C); + + info("inserting unrelated frames"); + await insertIframe(bcTop, "https://itisatracker.org"); + await insertIframe(bcChildC, "https://itisatracker.org"); + + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should have rule when called with top BC for C, because frame C has a child click rule." + ); + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcChildC), + "Should have rule when called with child BC for C, because it has a child click rule." + ); + }); + + info("Test with unrelated top level"); + await BrowserTestUtils.withNewTab("http://mochi.test:8888", async browser => { + let bcTop = browser.browsingContext; + + ok( + !Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should not have rule for unrelated site." + ); + + info("inserting frame with TEST_ORIGIN_A"); + let bcChildA = await insertIframe(bcTop, TEST_ORIGIN_A); + ok( + !Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should still have no rule when called with top BC for A, because click rule for A only applies top-level." + ); + ok( + !Services.cookieBanners.hasRuleForBrowsingContextTree(bcChildA), + "Should have no rule when called with child BC for A." + ); + + info("inserting frame with TEST_ORIGIN_B"); + let bcChildB = await insertIframe(bcTop, TEST_ORIGIN_B); + ok( + !Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should still have no rule when called with top BC for A, because cookie rule for B only applies top-level." + ); + ok( + !Services.cookieBanners.hasRuleForBrowsingContextTree(bcChildA), + "Should have no rule when called with child BC for A." + ); + ok( + !Services.cookieBanners.hasRuleForBrowsingContextTree(bcChildB), + "Should have no rule when called with child BC for B." + ); + + info("inserting nested frame with TEST_ORIGIN_C"); + let bcChildC = await insertIframe(bcChildB, TEST_ORIGIN_C); + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should have rule when called with top level BC because rule for nested iframe C applies." + ); + ok( + !Services.cookieBanners.hasRuleForBrowsingContextTree(bcChildA), + "Should have no rule when called with child BC for A." + ); + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcChildB), + "Should have rule when called with child BC for B, because C rule for nested iframe C applies." + ); + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcChildC), + "Should have rule when called with child BC for C, because C rule for nested iframe C applies." + ); + }); +}); + +/** + * Tests that domain prefs are not considered when evaluating whether the + * service has an applicable rule for the given BrowsingContext. + */ +add_task(async function test_hasRuleForBCTree_ignoreDomainPrefs() { + info("Test with top level A"); + await BrowserTestUtils.withNewTab(TEST_ORIGIN_A, async browser => { + let bcTop = browser.browsingContext; + + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should have rule when called with top BC for A" + ); + + // Disable for current site per domain pref. + Services.cookieBanners.setDomainPref( + browser.currentURI, + Ci.nsICookieBannerService.MODE_DISABLED, + false + ); + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should have rule when called with top BC for A, even if mechanism is disabled for A." + ); + + // Change mode via domain pref. + Services.cookieBanners.setDomainPref( + browser.currentURI, + Ci.nsICookieBannerService.MODE_REJECT, + false + ); + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should still have rule when called with top BC for A, even with custom mode for A" + ); + + // Cleanup. + Services.cookieBanners.removeAllDomainPrefs(false); + }); + + info("Test with top level B"); + await BrowserTestUtils.withNewTab(TEST_ORIGIN_B, async browser => { + let bcTop = browser.browsingContext; + + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should have rule when called with top BC for B" + ); + + // Change mode via domain pref. + Services.cookieBanners.setDomainPref( + browser.currentURI, + Ci.nsICookieBannerService.MODE_REJECT, + false + ); + // Rule for B has no opt-out option. Since the mode is overridden to + // MODE_REJECT for B we don't have any applicable rule for it. This should + // however not be considered for the hasRule getter, it should ignore + // per-domain preferences and evaluate based on the global service mode + // instead. + ok( + Services.cookieBanners.hasRuleForBrowsingContextTree(bcTop), + "Should still have rule when called with top BC for B, even with custom mode for B" + ); + + // Cleanup. + Services.cookieBanners.removeAllDomainPrefs(false); + }); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_prefs.js b/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_prefs.js new file mode 100644 index 0000000000..6e9197281c --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_cookiebannerservice_prefs.js @@ -0,0 +1,213 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_setup(async function () { + registerCleanupFunction(() => { + Services.prefs.clearUserPref("cookiebanners.service.mode"); + Services.prefs.clearUserPref("cookiebanners.service.mode.privateBrowsing"); + if ( + Services.prefs.getIntPref("cookiebanners.service.mode") != + Ci.nsICookieBannerService.MODE_DISABLED || + Services.prefs.getIntPref("cookiebanners.service.mode.privateBrowsing") != + Ci.nsICookieBannerService.MODE_DISABLED + ) { + // Restore original rules. + Services.cookieBanners.resetRules(true); + } + }); +}); + +add_task(async function test_enabled_pref() { + info("Disabling cookie banner service."); + + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_DISABLED], + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_DISABLED, + ], + ], + }); + + ok(Services.cookieBanners, "Services.cookieBanners is defined."); + ok( + Services.cookieBanners instanceof Ci.nsICookieBannerService, + "Services.cookieBanners is nsICookieBannerService" + ); + + info( + "Testing that methods throw NS_ERROR_NOT_AVAILABLE if the service is disabled." + ); + + Assert.throws( + () => { + Services.cookieBanners.rules; + }, + /NS_ERROR_NOT_AVAILABLE/, + "Should have thrown NS_ERROR_NOT_AVAILABLE for rules getter." + ); + + // Create a test rule to attempt to insert. + let rule = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + rule.id = genUUID(); + rule.domains = ["example.com"]; + + Assert.throws( + () => { + Services.cookieBanners.insertRule(rule); + }, + /NS_ERROR_NOT_AVAILABLE/, + "Should have thrown NS_ERROR_NOT_AVAILABLE for insertRule." + ); + + Assert.throws( + () => { + Services.cookieBanners.removeRule(rule); + }, + /NS_ERROR_NOT_AVAILABLE/, + "Should have thrown NS_ERROR_NOT_AVAILABLE for removeRule." + ); + + Assert.throws( + () => { + Services.cookieBanners.getCookiesForURI( + Services.io.newURI("https://example.com"), + false + ); + }, + /NS_ERROR_NOT_AVAILABLE/, + "Should have thrown NS_ERROR_NOT_AVAILABLE for rules getCookiesForURI." + ); + Assert.throws( + () => { + Services.cookieBanners.getClickRulesForDomain("example.com", true); + }, + /NS_ERROR_NOT_AVAILABLE/, + "Should have thrown NS_ERROR_NOT_AVAILABLE for rules getClickRuleForDomain." + ); + let uri = Services.io.newURI("https://example.com"); + Assert.throws( + () => { + Services.cookieBanners.getDomainPref(uri, false); + }, + /NS_ERROR_NOT_AVAILABLE/, + "Should have thrown NS_ERROR_NOT_AVAILABLE for getDomainPref." + ); + Assert.throws( + () => { + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT, + false + ); + }, + /NS_ERROR_NOT_AVAILABLE/, + "Should have thrown NS_ERROR_NOT_AVAILABLE for setDomainPref." + ); + Assert.throws( + () => { + Services.cookieBanners.setDomainPrefAndPersistInPrivateBrowsing( + uri, + Ci.nsICookieBannerService.MODE_REJECT + ); + }, + /NS_ERROR_NOT_AVAILABLE/, + "Should have thrown NS_ERROR_NOT_AVAILABLE for setDomainPrefAndPersistInPrivateBrowsing." + ); + Assert.throws( + () => { + Services.cookieBanners.removeDomainPref(uri, false); + }, + /NS_ERROR_NOT_AVAILABLE/, + "Should have thrown NS_ERROR_NOT_AVAILABLE for removeDomainPref." + ); + Assert.throws( + () => { + Services.cookieBanners.removeAllDomainPrefs(false); + }, + /NS_ERROR_NOT_AVAILABLE/, + "Should have thrown NS_ERROR_NOT_AVAILABLE for removeAllSitePref." + ); + + info("Enabling cookie banner service. MODE_REJECT"); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + let rules = Services.cookieBanners.rules; + ok( + Array.isArray(rules), + "Rules getter should not throw but return an array." + ); + + info("Enabling cookie banner service. MODE_REJECT_OR_ACCEPT"); + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ], + }); + + rules = Services.cookieBanners.rules; + ok( + Array.isArray(rules), + "Rules getter should not throw but return an array." + ); +}); + +/** + * Test both service mode pref combinations to ensure the cookie banner service + * is (un-)initialized correctly. + */ +add_task(async function test_enabled_pref_pbm_combinations() { + const MODES = [ + Ci.nsICookieBannerService.MODE_DISABLED, + Ci.nsICookieBannerService.MODE_REJECT, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ]; + + // Test all pref combinations + MODES.forEach(modeNormal => { + MODES.forEach(modePrivate => { + info( + `cookiebanners.service.mode=${modeNormal}; cookiebanners.service.mode.privateBrowsing=${modePrivate}` + ); + Services.prefs.setIntPref("cookiebanners.service.mode", modeNormal); + Services.prefs.setIntPref( + "cookiebanners.service.mode.privateBrowsing", + modePrivate + ); + + if ( + modeNormal == Ci.nsICookieBannerService.MODE_DISABLED && + modePrivate == Ci.nsICookieBannerService.MODE_DISABLED + ) { + Assert.throws( + () => { + Services.cookieBanners.rules; + }, + /NS_ERROR_NOT_AVAILABLE/, + "Cookie banner service should be disabled. Should throw NS_ERROR_NOT_AVAILABLE for rules getter." + ); + } else { + ok( + Services.cookieBanners.rules, + "Cookie banner service should be enabled, rules getter should not throw." + ); + } + }); + }); + + // Cleanup. + Services.prefs.clearUserPref("cookiebanners.service.mode"); + Services.prefs.clearUserPref("cookiebanners.service.mode.privateBrowsing"); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_cookieinjector.js b/toolkit/components/cookiebanners/test/browser/browser_cookieinjector.js new file mode 100644 index 0000000000..d341355f20 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_cookieinjector.js @@ -0,0 +1,625 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { SiteDataTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/SiteDataTestUtils.sys.mjs" +); + +const DOMAIN_A = "example.com"; +const DOMAIN_B = "example.org"; +const DOMAIN_C = "example.net"; + +const ORIGIN_A = "https://" + DOMAIN_A; +const ORIGIN_A_SUB = `https://test1.${DOMAIN_A}`; +const ORIGIN_B = "https://" + DOMAIN_B; +const ORIGIN_C = "https://" + DOMAIN_C; + +const TEST_COOKIE_HEADER_URL = + getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "https://example.com" + ) + "testCookieHeader.sjs"; + +/** + * Tests that the test domains have no cookies set. + */ +function assertNoCookies() { + ok( + !SiteDataTestUtils.hasCookies(ORIGIN_A), + "Should not set any cookies for ORIGIN_A" + ); + ok( + !SiteDataTestUtils.hasCookies(ORIGIN_B), + "Should not set any cookies for ORIGIN_B" + ); + ok( + !SiteDataTestUtils.hasCookies(ORIGIN_C), + "Should not set any cookies for ORIGIN_C" + ); +} + +/** + * Loads a list of urls consecutively from the same tab. + * @param {string[]} urls - List of urls to load. + */ +async function visitTestSites(urls = [ORIGIN_A, ORIGIN_B, ORIGIN_C]) { + let tab = BrowserTestUtils.addTab(gBrowser, "about:blank"); + + for (let url of urls) { + BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, url); + await BrowserTestUtils.browserLoaded(tab.linkedBrowser); + } + + BrowserTestUtils.removeTab(tab); +} + +add_setup(cookieInjectorTestSetup); + +/** + * Tests that no cookies are set if the cookie injection component is disabled + * by pref, but the cookie banner service is enabled. + */ +add_task(async function test_cookie_injector_disabled() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.cookieInjector.enabled", false], + ], + }); + + insertTestCookieRules(); + + await visitTestSites(); + assertNoCookies(); + + await SiteDataTestUtils.clear(); +}); + +/** + * Tests that no cookies are set if the cookie injection component is enabled + * by pref, but the cookie banner service is disabled or in detect-only mode. + */ +add_task(async function test_cookie_banner_service_disabled() { + // Enable in PBM so the service is always initialized. + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ], + }); + + for (let [serviceMode, detectOnly] of [ + [Ci.nsICookieBannerService.MODE_DISABLED, false], + [Ci.nsICookieBannerService.MODE_DISABLED, true], + [Ci.nsICookieBannerService.MODE_REJECT, true], + [Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, true], + ]) { + info(`Testing with serviceMode=${serviceMode}; detectOnly=${detectOnly}`); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", serviceMode], + ["cookiebanners.cookieInjector.enabled", true], + ["cookiebanners.service.detectOnly", detectOnly], + ], + }); + + await visitTestSites(); + assertNoCookies(); + + await SiteDataTestUtils.clear(); + await SpecialPowers.popPrefEnv(); + } +}); + +/** + * Tests that we don't inject cookies if there are no matching rules. + */ +add_task(async function test_no_rules() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + + info("Clearing existing rules"); + Services.cookieBanners.resetRules(false); + + await visitTestSites(); + assertNoCookies(); + + await SiteDataTestUtils.clear(); +}); + +/** + * Tests that inject the correct cookies for matching rules and MODE_REJECT. + */ +add_task(async function test_mode_reject() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + + insertTestCookieRules(); + + await visitTestSites(); + + ok( + SiteDataTestUtils.hasCookies(ORIGIN_A, [ + { + key: `cookieConsent_${DOMAIN_A}_1`, + value: "optOut1", + }, + { + key: `cookieConsent_${DOMAIN_A}_2`, + value: "optOut2", + }, + ]), + "Should set opt-out cookies for ORIGIN_A" + ); + ok( + !SiteDataTestUtils.hasCookies(ORIGIN_B), + "Should not set any cookies for ORIGIN_B" + ); + // RULE_A also includes DOMAIN_C. + ok( + SiteDataTestUtils.hasCookies(ORIGIN_C, [ + { + key: `cookieConsent_${DOMAIN_A}_1`, + value: "optOut1", + }, + { + key: `cookieConsent_${DOMAIN_A}_2`, + value: "optOut2", + }, + ]), + "Should set opt-out cookies for ORIGIN_C" + ); + + await SiteDataTestUtils.clear(); +}); + +/** + * Tests that inject the correct cookies for matching rules and + * MODE_REJECT_OR_ACCEPT. + */ +add_task(async function test_mode_reject_or_accept() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + + insertTestCookieRules(); + + await visitTestSites(); + + ok( + SiteDataTestUtils.hasCookies(ORIGIN_A, [ + { + key: `cookieConsent_${DOMAIN_A}_1`, + value: "optOut1", + }, + { + key: `cookieConsent_${DOMAIN_A}_2`, + value: "optOut2", + }, + ]), + "Should set opt-out cookies for ORIGIN_A" + ); + ok( + SiteDataTestUtils.hasCookies(ORIGIN_B, [ + { + key: `cookieConsent_${DOMAIN_B}_1`, + value: "optIn1", + }, + ]), + "Should set opt-in cookies for ORIGIN_B" + ); + // Rule a also includes DOMAIN_C + ok( + SiteDataTestUtils.hasCookies(ORIGIN_C, [ + { + key: `cookieConsent_${DOMAIN_A}_1`, + value: "optOut1", + }, + { + key: `cookieConsent_${DOMAIN_A}_2`, + value: "optOut2", + }, + ]), + "Should set opt-out cookies for ORIGIN_C" + ); + + await SiteDataTestUtils.clear(); +}); + +/** + * Test that embedded third-parties do not trigger cookie injection. + */ +add_task(async function test_embedded_third_party() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + + insertTestCookieRules(); + + info("Loading example.com with an iframe for example.org."); + await BrowserTestUtils.withNewTab("https://example.com", async browser => { + await SpecialPowers.spawn(browser, [], async () => { + let iframe = content.document.createElement("iframe"); + iframe.src = "https://example.org"; + content.document.body.appendChild(iframe); + await ContentTaskUtils.waitForEvent(iframe, "load"); + }); + }); + + ok( + SiteDataTestUtils.hasCookies(ORIGIN_A, [ + { + key: `cookieConsent_${DOMAIN_A}_1`, + value: "optOut1", + }, + { + key: `cookieConsent_${DOMAIN_A}_2`, + value: "optOut2", + }, + ]), + "Should set opt-out cookies for top-level ORIGIN_A" + ); + ok( + !SiteDataTestUtils.hasCookies(ORIGIN_B), + "Should not set any cookies for embedded ORIGIN_B" + ); + + await SiteDataTestUtils.clear(); +}); + +/** + * Test that the injected cookies are present in the cookie header for the + * initial top level document request. + */ +add_task(async function test_cookie_header_and_document() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + insertTestCookieRules(); + + await BrowserTestUtils.withNewTab(TEST_COOKIE_HEADER_URL, async browser => { + await SpecialPowers.spawn(browser, [], async () => { + const EXPECTED_COOKIE_STR = + "cookieConsent_example.com_1=optOut1; cookieConsent_example.com_2=optOut2"; + is( + content.document.body.innerText, + EXPECTED_COOKIE_STR, + "Sent the correct cookie header." + ); + is( + content.document.cookie, + EXPECTED_COOKIE_STR, + "document.cookie has the correct cookie string." + ); + }); + }); + + await SiteDataTestUtils.clear(); +}); + +/** + * Test that cookies get properly injected for private browsing mode. + */ +add_task(async function test_pbm() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + insertTestCookieRules(); + + let pbmWindow = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + let tab = BrowserTestUtils.addTab(pbmWindow.gBrowser, "about:blank"); + BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, ORIGIN_A); + await BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + ok( + SiteDataTestUtils.hasCookies( + tab.linkedBrowser.contentPrincipal.origin, + [ + { + key: `cookieConsent_${DOMAIN_A}_1`, + value: "optOut1", + }, + { + key: `cookieConsent_${DOMAIN_A}_2`, + value: "optOut2", + }, + ], + true + ), + "Should set opt-out cookies for top-level ORIGIN_A in private browsing." + ); + + ok( + !SiteDataTestUtils.hasCookies(ORIGIN_A), + "Should not set any cookies for ORIGIN_A without PBM origin attribute." + ); + ok( + !SiteDataTestUtils.hasCookies(ORIGIN_B), + "Should not set any cookies for ORIGIN_B" + ); + + await BrowserTestUtils.closeWindow(pbmWindow); + await SiteDataTestUtils.clear(); +}); + +/** + * Test that cookies get properly injected for container tabs. + */ +add_task(async function test_container_tab() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + insertTestCookieRules(); + + info("Loading ORIGIN_B in a container tab."); + let tab = BrowserTestUtils.addTab(gBrowser, ORIGIN_B, { + userContextId: 1, + }); + BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, ORIGIN_B); + await BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + ok( + !SiteDataTestUtils.hasCookies(ORIGIN_A), + "Should not set any cookies for ORIGIN_A" + ); + ok( + SiteDataTestUtils.hasCookies(tab.linkedBrowser.contentPrincipal.origin, [ + { + key: `cookieConsent_${DOMAIN_B}_1`, + value: "optIn1", + }, + ]), + "Should set opt-out cookies for top-level ORIGIN_B in user context 1." + ); + ok( + !SiteDataTestUtils.hasCookies(ORIGIN_B), + "Should not set any cookies for ORIGIN_B in default user context" + ); + + BrowserTestUtils.removeTab(tab); + await SiteDataTestUtils.clear(); +}); + +/** + * Test that if there is already a cookie with the given key, we don't overwrite + * it. If the rule sets the unsetValue field, this cookie may be overwritten if + * the value matches. + */ +add_task(async function test_no_overwrite() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode", + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + ], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + + insertTestCookieRules(); + + info("Pre-setting a cookie that should not be overwritten."); + SiteDataTestUtils.addToCookies({ + origin: ORIGIN_A, + host: `.${DOMAIN_A}`, + path: "/", + name: `cookieConsent_${DOMAIN_A}_1`, + value: "KEEPME", + }); + + info("Pre-setting a cookie that should be overwritten, based on its value"); + SiteDataTestUtils.addToCookies({ + origin: ORIGIN_B, + host: `.${DOMAIN_B}`, + path: "/", + name: `cookieConsent_${DOMAIN_B}_1`, + value: "UNSET", + }); + + await visitTestSites(); + + ok( + SiteDataTestUtils.hasCookies(ORIGIN_A, [ + { + key: `cookieConsent_${DOMAIN_A}_1`, + value: "KEEPME", + }, + { + key: `cookieConsent_${DOMAIN_A}_2`, + value: "optOut2", + }, + ]), + "Should retain pre-set opt-in cookies for ORIGIN_A, but write new secondary cookie from rules." + ); + ok( + SiteDataTestUtils.hasCookies(ORIGIN_B, [ + { + key: `cookieConsent_${DOMAIN_B}_1`, + value: "optIn1", + }, + ]), + "Should have overwritten cookie for ORIGIN_B, based on its value and the unsetValue rule property." + ); + + await SiteDataTestUtils.clear(); +}); + +/** + * Tests that cookies are injected for the base domain when visiting a + * subdomain. + */ +add_task(async function test_subdomain() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + + insertTestCookieRules(); + + await visitTestSites([ORIGIN_A_SUB, ORIGIN_B]); + + ok( + SiteDataTestUtils.hasCookies(ORIGIN_A, [ + { + key: `cookieConsent_${DOMAIN_A}_1`, + value: "optOut1", + }, + { + key: `cookieConsent_${DOMAIN_A}_2`, + value: "optOut2", + }, + ]), + "Should set opt-out cookies for ORIGIN_A when visiting subdomain." + ); + ok( + !SiteDataTestUtils.hasCookies(ORIGIN_B), + "Should not set any cookies for ORIGIN_B" + ); + + await SiteDataTestUtils.clear(); +}); + +add_task(async function test_site_preference() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + + insertTestCookieRules(); + + await visitTestSites(); + + ok( + !SiteDataTestUtils.hasCookies(ORIGIN_B), + "Should not set any cookies for ORIGIN_B" + ); + + info("Set the site preference of example.org to MODE_REJECT_OR_ACCEPT."); + let uri = Services.io.newURI(ORIGIN_B); + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + false + ); + + await visitTestSites(); + ok( + SiteDataTestUtils.hasCookies(ORIGIN_B, [ + { + key: `cookieConsent_${DOMAIN_B}_1`, + value: "optIn1", + }, + ]), + "Should set opt-in cookies for ORIGIN_B" + ); + + Services.cookieBanners.removeAllDomainPrefs(false); + await SiteDataTestUtils.clear(); +}); + +add_task(async function test_site_preference_pbm() { + await SpecialPowers.pushPrefEnv({ + set: [ + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_REJECT, + ], + ["cookiebanners.cookieInjector.enabled", true], + ], + }); + + insertTestCookieRules(); + + let pbmWindow = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + let tab = BrowserTestUtils.addTab(pbmWindow.gBrowser, "about:blank"); + BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, ORIGIN_B); + await BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + ok( + !SiteDataTestUtils.hasCookies( + tab.linkedBrowser.contentPrincipal.origin, + null, + true + ), + "Should not set any cookies for ORIGIN_B in the private window" + ); + + info( + "Set the site preference of example.org to MODE_REJECT_OR_ACCEPT. in the private window." + ); + let uri = Services.io.newURI(ORIGIN_B); + Services.cookieBanners.setDomainPref( + uri, + Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT, + true + ); + + BrowserTestUtils.startLoadingURIString(tab.linkedBrowser, ORIGIN_B); + await BrowserTestUtils.browserLoaded(tab.linkedBrowser); + + ok( + SiteDataTestUtils.hasCookies( + tab.linkedBrowser.contentPrincipal.origin, + [ + { + key: `cookieConsent_${DOMAIN_B}_1`, + value: "optIn1", + }, + ], + true + ), + "Should set opt-in cookies for ORIGIN_B" + ); + + Services.cookieBanners.removeAllDomainPrefs(true); + BrowserTestUtils.removeTab(tab); + await BrowserTestUtils.closeWindow(pbmWindow); + await SiteDataTestUtils.clear(); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_cookieinjector_events.js b/toolkit/components/cookiebanners/test/browser/browser_cookieinjector_events.js new file mode 100644 index 0000000000..0459731a46 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_cookieinjector_events.js @@ -0,0 +1,56 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { SiteDataTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/SiteDataTestUtils.sys.mjs" +); + +add_setup(cookieInjectorTestSetup); + +/** + * Tests that we dispatch cookiebannerhandled and cookiebannerdetected events + * for cookie injection. + */ +add_task(async function test_events() { + let tab; + + let triggerFn = async () => { + tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_ORIGIN_A); + }; + + await runEventTest({ + mode: Ci.nsICookieBannerService.MODE_REJECT, + initFn: insertTestCookieRules, + triggerFn, + testURL: `${TEST_ORIGIN_A}/`, + }); + + // Clean up the test tab opened by triggerFn. + BrowserTestUtils.removeTab(tab); + + ok( + SiteDataTestUtils.hasCookies(TEST_ORIGIN_A, [ + { + key: `cookieConsent_${TEST_DOMAIN_A}_1`, + value: "optOut1", + }, + { + key: `cookieConsent_${TEST_DOMAIN_A}_2`, + value: "optOut2", + }, + ]), + "Should set opt-out cookies for ORIGIN_A" + ); + ok( + !SiteDataTestUtils.hasCookies(TEST_ORIGIN_B), + "Should not set any cookies for ORIGIN_B" + ); + ok( + !SiteDataTestUtils.hasCookies(TEST_ORIGIN_C), + "Should not set any cookies for ORIGIN_C" + ); + + await SiteDataTestUtils.clear(); +}); diff --git a/toolkit/components/cookiebanners/test/browser/browser_cookieinjector_telemetry.js b/toolkit/components/cookiebanners/test/browser/browser_cookieinjector_telemetry.js new file mode 100644 index 0000000000..89a882814f --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/browser_cookieinjector_telemetry.js @@ -0,0 +1,88 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { SiteDataTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/SiteDataTestUtils.sys.mjs" +); + +add_setup(async function () { + await cookieInjectorTestSetup(); + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.bannerClicking.logLevel", "Debug"], + ["cookiebanners.bannerClicking.testing", true], + ], + }); +}); + +add_task(async function testCookieInjectionFailTelemetry() { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", Ci.nsICookieBannerService.MODE_REJECT], + ], + }); + + info("Clearing existing rules"); + Services.cookieBanners.resetRules(false); + + info("Creating a rule contains both cookie and click rules."); + let rule = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + rule.id = genUUID(); + rule.domains = [TEST_DOMAIN_A]; + + rule.addCookie( + true, + `cookieConsent_${TEST_DOMAIN_A}_1`, + "optOut1", + null, // empty host to fall back to .<domain> + "/", + 3600, + "", + false, + false, + false, + 0, + 0 + ); + + rule.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_ALL, + null, + "button#optOut", + "button#optIn" + ); + Services.cookieBanners.insertRule(rule); + + Services.cookieBanners.removeAllExecutedRecords(false); + + // Open the test page with the banner to trigger the cookie injection failure. + let promise = promiseBannerClickingFinish(TEST_DOMAIN_A); + let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, TEST_PAGE_A); + await promise; + + await Services.fog.testFlushAllChildren(); + + BrowserTestUtils.removeTab(tab); + + await TestUtils.waitForCondition(_ => { + return Glean.cookieBanners.cookieInjectionFail.testGetValue() != null; + }, "Waiting for metric to be ready."); + + is( + Glean.cookieBanners.cookieInjectionFail.testGetValue(), + 1, + "Counter for cookie_injection_fail has correct state" + ); + + // Clear Telemetry + await Services.fog.testFlushAllChildren(); + Services.fog.testResetFOG(); + + await SiteDataTestUtils.clear(); +}); diff --git a/toolkit/components/cookiebanners/test/browser/file_banner.html b/toolkit/components/cookiebanners/test/browser/file_banner.html new file mode 100644 index 0000000000..d2af994f39 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/file_banner.html @@ -0,0 +1,28 @@ +<html> +<head> + <title>A top-level page with cookie banner</title> + <script> + function hideBanner() { + document.getElementById("banner").style.display = "none"; + } + + function clickOptOut() { + document.getElementById("result").textContent = "OptOut"; + hideBanner(); + } + + function clickOptIn() { + document.getElementById("result").textContent = "OptIn"; + hideBanner(); + } + </script> +</head> +<body> + <h1>This is the top-level page</h1> + <div id="banner"> + <button id="optOut" onclick="clickOptOut()">OptOut</button> + <button id="optIn" onclick="clickOptIn()">OptIn</button> + </div> + <p id="result">NoClick</p> +</body> +</html> diff --git a/toolkit/components/cookiebanners/test/browser/file_banner_b.html b/toolkit/components/cookiebanners/test/browser/file_banner_b.html new file mode 100644 index 0000000000..b71faa0ab4 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/file_banner_b.html @@ -0,0 +1,28 @@ +<html> +<head> + <title>A top-level page with cookie banner</title> + <script> + function hideBanner() { + document.getElementById("banner").style.display = "none"; + } + + function clickOptOut() { + document.getElementById("result").textContent = "OptOut"; + hideBanner(); + } + + function clickOptIn() { + document.getElementById("result").textContent = "OptIn"; + hideBanner(); + } + </script> +</head> +<body> + <h1>This is the top-level page</h1> + <div id="bannerB"> + <button id="optOut" onclick="clickOptOut()">OptOut</button> + <button id="optIn" onclick="clickOptIn()">OptIn</button> + </div> + <p id="result">NoClick</p> +</body> +</html> diff --git a/toolkit/components/cookiebanners/test/browser/file_banner_invisible.html b/toolkit/components/cookiebanners/test/browser/file_banner_invisible.html new file mode 100644 index 0000000000..9bde593b4d --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/file_banner_invisible.html @@ -0,0 +1,28 @@ +<html> +<head> + <title>A top-level page with cookie banner</title> + <script> + function hideBanner() { + document.getElementById("banner").style.display = "none"; + } + + function clickOptOut() { + document.getElementById("result").textContent = "OptOut"; + hideBanner(); + } + + function clickOptIn() { + document.getElementById("result").textContent = "OptIn"; + hideBanner(); + } + </script> +</head> +<body> + <h1>This is the top-level page</h1> + <div id="banner" style="display: none;"> + <button id="optOut" onclick="clickOptOut()">OptOut</button> + <button id="optIn" onclick="clickOptIn()">OptIn</button> + </div> + <p id="result">NoClick</p> +</body> +</html> diff --git a/toolkit/components/cookiebanners/test/browser/file_delayed_banner.html b/toolkit/components/cookiebanners/test/browser/file_delayed_banner.html new file mode 100644 index 0000000000..e528064434 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/file_delayed_banner.html @@ -0,0 +1,54 @@ +<html> +<head> + <title>A top-level page with delayed cookie banner</title> + <script> + function hideBanner() { + document.getElementById("banner").style.display = "none"; + } + + function clickOptOut() { + document.getElementById("result").textContent = "OptOut"; + hideBanner(); + } + + function clickOptIn() { + document.getElementById("result").textContent = "OptIn"; + hideBanner(); + } + + function generateBanner() { + let banner = document.createElement("div"); + banner.id = "banner"; + + let buttonOptOut = document.createElement("button"); + buttonOptOut.id = "OptOut"; + buttonOptOut.onclick = () => {clickOptOut();}; + + let buttonOptIn = document.createElement("button"); + buttonOptIn.id = "OptIn"; + buttonOptIn.onclick = () => {clickOptIn();}; + + banner.appendChild(buttonOptOut); + banner.appendChild(buttonOptIn); + document.body.appendChild(banner); + } + + window.onload = () => { + const params = (new URL(document.location)).searchParams; + let delay = 0; + + if (params.has("delay")) { + delay = parseInt(params.get("delay")); + } + + window.setTimeout(() => { + generateBanner(); + }, delay); + }; + </script> +</head> +<body> + <h1>This is the top-level page</h1> + <p id="result">NoClick</p> +</body> +</html> diff --git a/toolkit/components/cookiebanners/test/browser/file_delayed_banner_load.html b/toolkit/components/cookiebanners/test/browser/file_delayed_banner_load.html new file mode 100644 index 0000000000..0209ad76cd --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/file_delayed_banner_load.html @@ -0,0 +1,49 @@ +<html> +<head> + <title>A top-level page with delayed cookie banner</title> + <script> + function hideBanner() { + document.getElementById("banner").style.display = "none"; + } + + function clickOptOut() { + document.getElementById("result").textContent = "OptOut"; + hideBanner(); + } + + function clickOptIn() { + document.getElementById("result").textContent = "OptIn"; + hideBanner(); + } + + function generateBanner() { + let banner = document.createElement("div"); + banner.id = "banner"; + + let buttonOptOut = document.createElement("button"); + buttonOptOut.id = "OptOut"; + buttonOptOut.onclick = () => {clickOptOut();}; + + let buttonOptIn = document.createElement("button"); + buttonOptIn.id = "OptIn"; + buttonOptIn.onclick = () => {clickOptIn();}; + + banner.appendChild(buttonOptOut); + banner.appendChild(buttonOptIn); + document.body.appendChild(banner); + } + + window.onload = () => { + generateBanner(); + }; + </script> + <!-- This will cause DOMContentLoaded and load to be further apart which is + required for certain test cases. slowSubresource.sjs will delay the page load + event.--> + <link rel="stylesheet" href="slowSubresource.sjs"> +</head> +<body> + <h1>This is the top-level page</h1> + <p id="result">NoClick</p> +</body> +</html> diff --git a/toolkit/components/cookiebanners/test/browser/file_iframe_banner.html b/toolkit/components/cookiebanners/test/browser/file_iframe_banner.html new file mode 100644 index 0000000000..8bf81a9222 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/file_iframe_banner.html @@ -0,0 +1,8 @@ +<html> +<head> + <title>A top-level page with iframe cookie banner</title> +</head> +<body> +<iframe src="https://example.com/browser/toolkit/components/cookiebanners/test/browser/file_banner.html"></iframe> +</body> +</html> diff --git a/toolkit/components/cookiebanners/test/browser/head.js b/toolkit/components/cookiebanners/test/browser/head.js new file mode 100644 index 0000000000..e67ac49b9f --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/head.js @@ -0,0 +1,658 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const TEST_DOMAIN_A = "example.com"; +const TEST_DOMAIN_B = "example.org"; +const TEST_DOMAIN_C = "example.net"; + +const TEST_ORIGIN_A = "https://" + TEST_DOMAIN_A; +const TEST_ORIGIN_B = "https://" + TEST_DOMAIN_B; +const TEST_ORIGIN_C = "https://" + TEST_DOMAIN_C; + +const TEST_PATH = getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "" +); + +const TEST_PAGE_A = TEST_ORIGIN_A + TEST_PATH + "file_banner.html"; +const TEST_PAGE_B = TEST_ORIGIN_B + TEST_PATH + "file_banner.html"; +// Page C has a different banner element ID than A and B. +const TEST_PAGE_C = TEST_ORIGIN_C + TEST_PATH + "file_banner_b.html"; + +function genUUID() { + return Services.uuid.generateUUID().number.slice(1, -1); +} + +/** + * Common setup function for cookie banner handling tests. + */ +async function testSetup() { + await SpecialPowers.pushPrefEnv({ + set: [ + // Enable debug logging. + ["cookiebanners.listService.logLevel", "Debug"], + // Avoid importing rules from RemoteSettings. They may interfere with test + // rules / assertions. + ["cookiebanners.listService.testSkipRemoteSettings", true], + ], + }); + + // Reset GLEAN (FOG) telemetry to avoid data bleeding over from other tests. + await Services.fog.testFlushAllChildren(); + Services.fog.testResetFOG(); + + registerCleanupFunction(() => { + Services.prefs.clearUserPref("cookiebanners.service.mode"); + Services.prefs.clearUserPref("cookiebanners.service.mode.privateBrowsing"); + if (Services.cookieBanners.isEnabled) { + // Restore original rules. + Services.cookieBanners.resetRules(true); + + // Clear executed records. + Services.cookieBanners.removeAllExecutedRecords(false); + Services.cookieBanners.removeAllExecutedRecords(true); + } + }); +} + +/** + * Setup function for click tests. + */ +async function clickTestSetup() { + await testSetup(); + + await SpecialPowers.pushPrefEnv({ + set: [ + // Enable debug logging. + ["cookiebanners.bannerClicking.logLevel", "Debug"], + ["cookiebanners.bannerClicking.testing", true], + ["cookiebanners.bannerClicking.timeoutAfterLoad", 500], + ["cookiebanners.bannerClicking.enabled", true], + ["cookiebanners.cookieInjector.enabled", false], + ], + }); +} + +/** + * Setup function for cookie injector tests. + */ +async function cookieInjectorTestSetup() { + await testSetup(); + + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.cookieInjector.enabled", true], + // Required to dispatch cookiebanner events. + ["cookiebanners.bannerClicking.enabled", true], + ], + }); +} + +/** + * A helper function returns a promise which resolves when the banner clicking + * is finished for the given domain. + * + * @param {String} domain the domain that should run the banner clicking. + */ +function promiseBannerClickingFinish(domain) { + return new Promise(resolve => { + Services.obs.addObserver(function observer(subject, topic, data) { + if (data != domain) { + return; + } + + Services.obs.removeObserver( + observer, + "cookie-banner-test-clicking-finish" + ); + resolve(); + }, "cookie-banner-test-clicking-finish"); + }); +} + +/** + * A helper function to verify the banner state of the given browsingContext. + * + * @param {BrowsingContext} bc - the browsing context + * @param {boolean} visible - if the banner should be visible. + * @param {boolean} expected - the expected banner click state. + * @param {string} [bannerId] - id of the cookie banner element. + */ +async function verifyBannerState(bc, visible, expected, bannerId = "banner") { + info("Verify the cookie banner state."); + + await SpecialPowers.spawn( + bc, + [visible, expected, bannerId], + (visible, expected, bannerId) => { + let banner = content.document.getElementById(bannerId); + + is( + banner.checkVisibility({ + checkOpacity: true, + checkVisibilityCSS: true, + }), + visible, + `The banner element should be ${visible ? "visible" : "hidden"}` + ); + + let result = content.document.getElementById("result"); + + is(result.textContent, expected, "The build click state is correct."); + } + ); +} + +/** + * A helper function to open the test page and verify the banner state. + * + * @param {Window} [win] - the chrome window object. + * @param {String} domain - the domain of the testing page. + * @param {String} testURL - the url of the testing page. + * @param {boolean} visible - if the banner should be visible. + * @param {boolean} expected - the expected banner click state. + * @param {string} [bannerId] - id of the cookie banner element. + * @param {boolean} [keepTabOpen] - whether to leave the tab open after the test + * function completed. + */ +async function openPageAndVerify({ + win = window, + domain, + testURL, + visible, + expected, + bannerId = "banner", + keepTabOpen = false, + expectActorEnabled = true, +}) { + info(`Opening ${testURL}`); + + // If the actor isn't enabled there won't be a "finished" observer message. + let promise = expectActorEnabled + ? promiseBannerClickingFinish(domain) + : new Promise(resolve => setTimeout(resolve, 0)); + + let tab = await BrowserTestUtils.openNewForegroundTab(win.gBrowser, testURL); + + await promise; + + await verifyBannerState(tab.linkedBrowser, visible, expected, bannerId); + + if (!keepTabOpen) { + BrowserTestUtils.removeTab(tab); + } +} + +/** + * A helper function to open the test page in an iframe and verify the banner + * state in the iframe. + * + * @param {Window} win - the chrome window object. + * @param {String} domain - the domain of the testing iframe page. + * @param {String} testURL - the url of the testing iframe page. + * @param {boolean} visible - if the banner should be visible. + * @param {boolean} expected - the expected banner click state. + */ +async function openIframeAndVerify({ + win, + domain, + testURL, + visible, + expected, +}) { + let tab = await BrowserTestUtils.openNewForegroundTab( + win.gBrowser, + TEST_ORIGIN_C + ); + + let promise = promiseBannerClickingFinish(domain); + + let iframeBC = await SpecialPowers.spawn( + tab.linkedBrowser, + [testURL], + async testURL => { + let iframe = content.document.createElement("iframe"); + iframe.src = testURL; + content.document.body.appendChild(iframe); + await ContentTaskUtils.waitForEvent(iframe, "load"); + + return iframe.browsingContext; + } + ); + + await promise; + await verifyBannerState(iframeBC, visible, expected); + + BrowserTestUtils.removeTab(tab); +} + +/** + * A helper function to insert testing rules. + */ +function insertTestClickRules(insertGlobalRules = true) { + info("Clearing existing rules"); + Services.cookieBanners.resetRules(false); + + info("Inserting test rules."); + + info("Add opt-out click rule for DOMAIN_A."); + let ruleA = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleA.id = genUUID(); + ruleA.domains = [TEST_DOMAIN_A]; + + ruleA.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_ALL, + null, + "button#optOut", + "button#optIn" + ); + Services.cookieBanners.insertRule(ruleA); + + info("Add opt-in click rule for DOMAIN_B."); + let ruleB = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleB.id = genUUID(); + ruleB.domains = [TEST_DOMAIN_B]; + + ruleB.addClickRule( + "div#banner", + false, + Ci.nsIClickRule.RUN_ALL, + null, + null, + "button#optIn" + ); + Services.cookieBanners.insertRule(ruleB); + + if (insertGlobalRules) { + info("Add global ruleC which targets a non-existing banner (presence)."); + let ruleC = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleC.id = genUUID(); + ruleC.domains = []; + ruleC.addClickRule( + "div#nonExistingBanner", + false, + Ci.nsIClickRule.RUN_ALL, + null, + null, + "button#optIn" + ); + Services.cookieBanners.insertRule(ruleC); + + info("Add global ruleD which targets a non-existing banner (presence)."); + let ruleD = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleD.id = genUUID(); + ruleD.domains = []; + ruleD.addClickRule( + "div#nonExistingBanner2", + false, + Ci.nsIClickRule.RUN_ALL, + null, + "button#optOut", + "button#optIn" + ); + Services.cookieBanners.insertRule(ruleD); + } +} + +/** + * Inserts cookie injection test rules for TEST_DOMAIN_A and TEST_DOMAIN_B. + */ +function insertTestCookieRules() { + info("Clearing existing rules"); + Services.cookieBanners.resetRules(false); + + info("Inserting test rules."); + + let ruleA = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleA.domains = [TEST_DOMAIN_A, TEST_DOMAIN_C]; + + Services.cookieBanners.insertRule(ruleA); + ruleA.addCookie( + true, + `cookieConsent_${TEST_DOMAIN_A}_1`, + "optOut1", + null, // empty host to fall back to .<domain> + "/", + 3600, + "", + false, + false, + false, + 0, + 0 + ); + ruleA.addCookie( + true, + `cookieConsent_${TEST_DOMAIN_A}_2`, + "optOut2", + null, + "/", + 3600, + "", + false, + false, + false, + 0, + 0 + ); + + // An opt-in cookie rule for DOMAIN_B. + let ruleB = Cc["@mozilla.org/cookie-banner-rule;1"].createInstance( + Ci.nsICookieBannerRule + ); + ruleB.domains = [TEST_DOMAIN_B]; + + Services.cookieBanners.insertRule(ruleB); + ruleB.addCookie( + false, + `cookieConsent_${TEST_DOMAIN_B}_1`, + "optIn1", + TEST_DOMAIN_B, + "/", + 3600, + "UNSET", + false, + false, + true, + 0, + 0 + ); +} + +/** + * Test the Glean.cookieBannersClick.result metric. + * + * @param {*} expected - Object mapping labels to counters. Omitted labels are + * asserted to be in initial state (undefined =^ 0) + * @param {boolean} [resetFOG] - Whether to reset all FOG telemetry after the + * method has finished. + */ +function testClickResultTelemetry(expected, resetFOG = true) { + return testClickResultTelemetryInternal( + Glean.cookieBannersClick.result, + expected, + resetFOG + ); +} + +/** + * Test the Glean.cookieBannersCmp.result metric. + * + * @param {*} expected - Object mapping labels to counters. Omitted labels are + * asserted to be in initial state (undefined =^ 0) + * @param {boolean} [resetFOG] - Whether to reset all FOG telemetry after the + * method has finished. + */ +function testCMPResultTelemetry(expected, resetFOG = true) { + return testClickResultTelemetryInternal( + Glean.cookieBannersCmp.result, + expected, + resetFOG + ); +} + +/** + * Test the result metric. + * + * @param {Object} targetTelemetry - The target glean interface to run the + * checks + * @param {*} expected - Object mapping labels to counters. Omitted labels are + * asserted to be in initial state (undefined =^ 0) + * @param {boolean} [resetFOG] - Whether to reset all FOG telemetry after the + * method has finished. + */ +async function testClickResultTelemetryInternal( + targetTelemetry, + expected, + resetFOG +) { + // TODO: Bug 1805653: Enable tests for Linux. + if (AppConstants.platform == "linux") { + ok(true, "Skip click telemetry tests on linux."); + return; + } + + // Ensure we have all data from the content process. + await Services.fog.testFlushAllChildren(); + + let labels = [ + "success", + "success_cookie_injected", + "success_dom_content_loaded", + "success_mutation_pre_load", + "success_mutation_post_load", + "fail", + "fail_banner_not_found", + "fail_banner_not_visible", + "fail_button_not_found", + "fail_no_rule_for_mode", + "fail_actor_destroyed", + ]; + + let testMetricState = doAssert => { + for (let label of labels) { + let expectedValue = expected[label] ?? null; + if (doAssert) { + is( + targetTelemetry[label].testGetValue(), + expectedValue, + `Counter for label '${label}' has correct state.` + ); + } else if (targetTelemetry[label].testGetValue() !== expectedValue) { + return false; + } + } + + return true; + }; + + // Wait for the labeled counter to match the expected state. Returns greedy on + // mismatch. + try { + await TestUtils.waitForCondition( + testMetricState, + "Waiting for cookieBannersClick.result metric to match." + ); + } finally { + // Test again but this time with assertions and test all labels. + testMetricState(true); + + // Reset telemetry, even if the test condition above throws. This is to + // avoid failing subsequent tests in case of a test failure. + if (resetFOG) { + await Services.fog.testFlushAllChildren(); + Services.fog.testResetFOG(); + } + } +} + +/** + * Triggers a cookie banner handling feature and tests the events dispatched. + * @param {*} options - Test options. + * @param {nsICookieBannerService::Modes} options.mode - The cookie banner + * service mode to test with. + * @param {boolean} options.detectOnly - Whether the service should be enabled + * in detection only mode, where it does not handle banners. + * @param {function} options.initFn - Function to call for test initialization. + * @param {function} options.triggerFn - Function to call to trigger the banner + * handling feature. + * @param {string} options.testURL - URL where the test will trigger the banner + * handling feature. + * @returns {Promise} Resolves when the test completes, after cookie banner + * events. + */ +async function runEventTest({ mode, detectOnly, initFn, triggerFn, testURL }) { + await SpecialPowers.pushPrefEnv({ + set: [ + ["cookiebanners.service.mode", mode], + [ + "cookiebanners.service.mode.privateBrowsing", + Ci.nsICookieBannerService.MODE_DISABLED, + ], + ["cookiebanners.service.detectOnly", detectOnly], + ], + }); + + await initFn(); + + let expectEventDetected = mode != Ci.nsICookieBannerService.MODE_DISABLED; + let expectEventHandled = + !detectOnly && + (mode == Ci.nsICookieBannerService.MODE_REJECT || + mode == Ci.nsICookieBannerService.MODE_REJECT_OR_ACCEPT); + + let eventObservedDetected = false; + let eventObservedHandled = false; + + // This is a bit hacky, we use side effects caused by the checkFn we pass into + // waitForEvent to keep track of whether an event fired. + let promiseEventDetected = BrowserTestUtils.waitForEvent( + window, + "cookiebannerdetected", + false, + () => { + eventObservedDetected = true; + return true; + } + ); + let promiseEventHandled = BrowserTestUtils.waitForEvent( + window, + "cookiebannerhandled", + false, + () => { + eventObservedHandled = true; + return true; + } + ); + + // If we expect any events check which one comes first. + let firstEventPromise; + if (expectEventDetected || expectEventHandled) { + firstEventPromise = Promise.race([ + promiseEventHandled, + promiseEventDetected, + ]); + } + + await triggerFn(); + + let eventDetected; + if (expectEventDetected) { + eventDetected = await promiseEventDetected; + + is( + eventDetected.type, + "cookiebannerdetected", + "Should dispatch cookiebannerdetected event." + ); + } + + let eventHandled; + if (expectEventHandled) { + eventHandled = await promiseEventHandled; + is( + eventHandled.type, + "cookiebannerhandled", + "Should dispatch cookiebannerhandled event." + ); + } + + // For MODE_DISABLED this array will be empty, because we don't expect any + // events to be dispatched. + let eventsToTest = [eventDetected, eventHandled].filter(event => !!event); + + for (let event of eventsToTest) { + info(`Testing properties of event ${event.type}`); + + let { windowContext } = event.detail; + ok( + windowContext, + `Event ${event.type} detail should contain a WindowContext` + ); + + let browser = windowContext.browsingContext.top.embedderElement; + ok( + browser, + "WindowContext should have an associated top embedder element." + ); + is( + browser.tagName, + "browser", + "The top embedder element should be a browser" + ); + let chromeWin = browser.ownerGlobal; + is( + chromeWin, + window, + "The chrome window associated with the browser should match the window where the cookie banner was handled." + ); + is( + chromeWin.gBrowser.selectedBrowser, + browser, + "The browser associated with the event should be the selected browser." + ); + is( + browser.currentURI.spec, + testURL, + "The browser's URI spec should match the cookie banner test page." + ); + } + + let firstEvent = await firstEventPromise; + is( + expectEventDetected || expectEventHandled, + !!firstEvent, + "Should have observed the first event if banner clicking is enabled." + ); + + if (expectEventDetected || expectEventHandled) { + is( + firstEvent.type, + "cookiebannerdetected", + "Detected event should be dispatched first" + ); + } + + is( + eventObservedDetected, + expectEventDetected, + `Should ${ + expectEventDetected ? "" : "not " + }have observed 'cookiebannerdetected' event for mode ${mode}` + ); + is( + eventObservedHandled, + expectEventHandled, + `Should ${ + expectEventHandled ? "" : "not " + }have observed 'cookiebannerhandled' event for mode ${mode}` + ); + + // Clean up pending promises by dispatching artificial cookiebanner events. + // Otherwise the test fails because of pending event listeners which + // BrowserTestUtils.waitForEvent registered. + for (let eventType of ["cookiebannerdetected", "cookiebannerhandled"]) { + let event = new CustomEvent(eventType, { + bubbles: true, + cancelable: false, + }); + window.windowUtils.dispatchEventToChromeOnly(window, event); + } + + await promiseEventDetected; + await promiseEventHandled; +} diff --git a/toolkit/components/cookiebanners/test/browser/slowSubresource.sjs b/toolkit/components/cookiebanners/test/browser/slowSubresource.sjs new file mode 100644 index 0000000000..1f14c2e9cf --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/slowSubresource.sjs @@ -0,0 +1,18 @@ +"use strict"; + +let timer; + +const DELAY_MS = 5000; +function handleRequest(request, response) { + response.processAsync(); + timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + timer.init( + () => { + response.setHeader("Content-Type", "text/css ", false); + response.write("body { background-color: red; }"); + response.finish(); + }, + DELAY_MS, + Ci.nsITimer.TYPE_ONE_SHOT + ); +} diff --git a/toolkit/components/cookiebanners/test/browser/testCookieHeader.sjs b/toolkit/components/cookiebanners/test/browser/testCookieHeader.sjs new file mode 100644 index 0000000000..2d7cac5e45 --- /dev/null +++ b/toolkit/components/cookiebanners/test/browser/testCookieHeader.sjs @@ -0,0 +1,5 @@ +function handleRequest(request, response) { + response.setStatusLine(request.httpVersion, 200); + // Write the cookie header value to the body for the test to inspect. + response.write(request.getHeader("Cookie")); +} diff --git a/toolkit/components/cookiebanners/test/unit/test_cookiebannerlistservice.js b/toolkit/components/cookiebanners/test/unit/test_cookiebannerlistservice.js new file mode 100644 index 0000000000..bc69a49d0f --- /dev/null +++ b/toolkit/components/cookiebanners/test/unit/test_cookiebannerlistservice.js @@ -0,0 +1,611 @@ +/* Any copyright is dedicated to the Public Domain. +http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { RemoteSettings } = ChromeUtils.importESModule( + "resource://services-settings/remote-settings.sys.mjs" +); + +let { sinon } = ChromeUtils.importESModule( + "resource://testing-common/Sinon.sys.mjs" +); + +// Name of the RemoteSettings collection containing the rules. +const COLLECTION_NAME = "cookie-banner-rules-list"; + +// Name of pref used to import test rules. +const PREF_TEST_RULES = "cookiebanners.listService.testRules"; + +let rulesInserted = []; +let rulesRemoved = []; +let insertCallback = null; + +function genUUID() { + return Services.uuid.generateUUID().number.slice(1, -1); +} + +const RULE_A_ORIGINAL = { + id: genUUID(), + click: { + optOut: "#fooOut", + presence: "#foobar", + }, + domains: ["example.com"], + cookies: { + optOut: [ + { + name: "doOptOut", + value: "true", + isSecure: true, + isSession: false, + }, + ], + }, +}; + +const RULE_B = { + id: genUUID(), + click: { + optOut: "#fooOutB", + presence: "#foobarB", + }, + domains: ["example.org"], + cookies: { + optOut: [ + { + name: "doOptOutB", + value: "true", + isSecure: true, + }, + ], + }, +}; + +const RULE_C = { + id: genUUID(), + click: { + optOut: "#fooOutC", + presence: "#foobarC", + }, + domains: ["example.net"], + cookies: { + optIn: [ + { + name: "gdpr", + value: "1", + path: "/myPath", + host: "foo.example.net", + }, + ], + }, +}; + +const RULE_A_UPDATED = { + id: RULE_A_ORIGINAL.id, + click: { + optOut: "#fooOut", + optIn: "#barIn", + presence: "#foobar", + }, + domains: ["example.com"], + cookies: { + optOut: [ + { + name: "doOptOutUpdated", + value: "true", + isSecure: true, + }, + { + name: "hideBanner", + value: "1", + }, + ], + }, +}; + +const INVALID_RULE_CLICK = { + id: genUUID(), + domains: ["foobar.com"], + click: { + presence: 1, + optIn: "#foo", + }, +}; + +const INVALID_RULE_EMPTY = {}; + +const RULE_D_GLOBAL = { + id: genUUID(), + click: { + optOut: "#globalOptOutD", + presence: "#globalBannerD", + }, + domains: [], + cookies: {}, +}; + +const RULE_E_GLOBAL = { + id: genUUID(), + click: { + optOut: "#globalOptOutE", + presence: "#globalBannerE", + }, + domains: [], + cookies: {}, +}; + +const RULE_F_EMPTY_CLICK = { + id: genUUID(), + click: {}, + domains: ["example.com"], + cookies: { + optOut: [ + { + name: "doOptOut", + value: "true", + isSecure: true, + }, + { + name: "hideBanner", + value: "1", + }, + ], + }, +}; + +// Testing with RemoteSettings requires a profile. +do_get_profile(); + +add_setup(async () => { + // Enable debug logging. + Services.prefs.setStringPref("cookiebanners.listService.logLevel", "Debug"); + + // Stub some nsICookieBannerService methods for easy testing. + let removeRule = sinon.stub().callsFake(rule => { + rulesRemoved.push(rule); + }); + + let insertRule = sinon.stub().callsFake(rule => { + rulesInserted.push(rule); + insertCallback?.(); + }); + + let oldCookieBanners = Services.cookieBanners; + Services.cookieBanners = { + isEnabled: true, + insertRule, + removeRule, + resetRules() {}, + resetDomainTelemetryRecord() {}, + }; + + // Remove stubs on test end. + registerCleanupFunction(() => { + Services.cookieBanners = oldCookieBanners; + Services.prefs.clearUserPref("cookiebanners.listService.logLevel"); + }); +}); + +/** + * Promise wrapper to listen for Services.cookieBanners.insertRule calls from + * the CookieBannerListService. + * @param {function} checkFn - Function which returns true or false to indicate + * if this is the insert the caller is looking for. + * @returns {Promise} - Promise which resolves when checkFn matches after + * insertRule call. + */ +function waitForInsert(checkFn) { + return new Promise(resolve => { + insertCallback = () => { + if (checkFn()) { + insertCallback = null; + resolve(); + } + }; + }); +} + +/** + * Tests that the cookie banner list service imports all rules on init. + */ +add_task(async function test_initial_import() { + info("Initializing RemoteSettings collection " + COLLECTION_NAME); + + let db = RemoteSettings(COLLECTION_NAME).db; + db.clear(); + await db.create(RULE_A_ORIGINAL); + await db.create(RULE_C); + await db.importChanges({}, Date.now()); + + Assert.equal(rulesInserted.length, 0, "No inserted rules initially."); + Assert.equal(rulesRemoved.length, 0, "No removed rules initially."); + + let insertPromise = waitForInsert(() => rulesInserted.length >= 2); + + info( + "Initializing the cookie banner list service which triggers a collection get call" + ); + let cookieBannerListService = Cc[ + "@mozilla.org/cookie-banner-list-service;1" + ].getService(Ci.nsICookieBannerListService); + await cookieBannerListService.initForTest(); + + await insertPromise; + + Assert.equal(rulesInserted.length, 2, "Two inserted rules after init."); + Assert.equal(rulesRemoved.length, 0, "No removed rules after init."); + + let ruleA = rulesInserted.find(rule => rule.id == RULE_A_UPDATED.id); + let cookieRuleA = ruleA.cookiesOptOut[0].cookie; + let ruleC = rulesInserted.find(rule => rule.id == RULE_C.id); + let cookieRuleC = ruleC.cookiesOptIn[0].cookie; + + Assert.ok(ruleA, "Has rule A."); + Assert.deepEqual( + ruleA.domains, + RULE_A_UPDATED.domains, + "Domains for ruleA should match." + ); + // Test the defaults which CookieBannerListService sets when the rule does + // not. + Assert.equal( + cookieRuleA.isSession, + false, + "Cookie for rule A should not be a session cookie." + ); + Assert.equal( + cookieRuleA.host, + null, + "Cookie host for rule A should be default." + ); + Assert.equal( + cookieRuleA.path, + "/", + "Cookie path for rule A should be default." + ); + + Assert.ok(ruleC, "Has rule C."); + Assert.deepEqual( + ruleC.domains, + RULE_C.domains, + "Domains for ruleA should match." + ); + Assert.equal( + ruleC.cookiesOptIn[0].cookie.isSession, + true, + "Cookie for rule C should should be a session cookie." + ); + Assert.equal( + cookieRuleC.host, + "foo.example.net", + "Cookie host for rule C should be custom." + ); + Assert.equal( + cookieRuleC.path, + "/myPath", + "Cookie path for rule C should be custom." + ); + + // Cleanup + cookieBannerListService.shutdown(); + rulesInserted = []; + rulesRemoved = []; + + db.clear(); + await db.importChanges({}, Date.now()); +}); + +/** + * Tests that the cookie banner list service updates rules on sync. + */ +add_task(async function test_remotesettings_sync() { + // Initialize the cookie banner list service so it subscribes to + // RemoteSettings updates. + let cookieBannerListService = Cc[ + "@mozilla.org/cookie-banner-list-service;1" + ].getService(Ci.nsICookieBannerListService); + await cookieBannerListService.initForTest(); + + const payload = { + current: [RULE_A_ORIGINAL, RULE_C, RULE_D_GLOBAL], + created: [RULE_B, RULE_E_GLOBAL], + updated: [{ old: RULE_A_ORIGINAL, new: RULE_A_UPDATED }], + deleted: [RULE_C, RULE_D_GLOBAL], + }; + + Assert.equal(rulesInserted.length, 0, "No inserted rules initially."); + Assert.equal(rulesRemoved.length, 0, "No removed rules initially."); + + info("Dispatching artificial RemoteSettings sync event"); + await RemoteSettings(COLLECTION_NAME).emit("sync", { data: payload }); + + Assert.equal(rulesInserted.length, 3, "Three inserted rules after sync."); + Assert.equal(rulesRemoved.length, 2, "Two removed rules after sync."); + + let ruleA = rulesInserted.find(rule => rule.id == RULE_A_UPDATED.id); + let ruleB = rulesInserted.find(rule => rule.id == RULE_B.id); + let ruleE = rulesInserted.find(rule => rule.id == RULE_E_GLOBAL.id); + let ruleC = rulesRemoved[0]; + + info("Testing that service inserted updated version of RULE_A."); + Assert.deepEqual( + ruleA.domains, + RULE_A_UPDATED.domains, + "Domains should match RULE_A." + ); + Assert.equal( + ruleA.cookiesOptOut.length, + RULE_A_UPDATED.cookies.optOut.length, + "cookiesOptOut length should match RULE_A." + ); + + info("Testing opt-out cookies of RULE_A"); + for (let i = 0; i < RULE_A_UPDATED.cookies.optOut.length; i += 1) { + Assert.equal( + ruleA.cookiesOptOut[i].cookie.name, + RULE_A_UPDATED.cookies.optOut[i].name, + "cookiesOptOut cookie name should match RULE_A." + ); + Assert.equal( + ruleA.cookiesOptOut[i].cookie.value, + RULE_A_UPDATED.cookies.optOut[i].value, + "cookiesOptOut cookie value should match RULE_A." + ); + } + + Assert.equal(ruleB.id, RULE_B.id, "Should have inserted RULE_B"); + Assert.equal(ruleC.id, RULE_C.id, "Should have removed RULE_C"); + Assert.equal( + ruleE.id, + RULE_E_GLOBAL.id, + "Should have inserted RULE_E_GLOBAL" + ); + + // Cleanup + cookieBannerListService.shutdown(); + rulesInserted = []; + rulesRemoved = []; + + let { db } = RemoteSettings(COLLECTION_NAME); + db.clear(); + await db.importChanges({}, Date.now()); +}); + +/** + * Tests the cookie banner rule test pref. + */ +add_task(async function test_rule_test_pref() { + Services.prefs.setStringPref( + PREF_TEST_RULES, + JSON.stringify([RULE_A_ORIGINAL, RULE_B]) + ); + + Assert.equal(rulesInserted.length, 0, "No inserted rules initially."); + Assert.equal(rulesRemoved.length, 0, "No removed rules initially."); + + let insertPromise = waitForInsert(() => rulesInserted.length >= 2); + + // Initialize the cookie banner list service so it imports test rules and listens for pref changes. + let cookieBannerListService = Cc[ + "@mozilla.org/cookie-banner-list-service;1" + ].getService(Ci.nsICookieBannerListService); + await cookieBannerListService.initForTest(); + + info("Wait for rules to be inserted"); + await insertPromise; + + Assert.equal(rulesInserted.length, 2, "Should have inserted two rules."); + Assert.equal(rulesRemoved.length, 0, "Should not have removed any rules."); + + Assert.ok( + rulesInserted.some(rule => rule.id == RULE_A_ORIGINAL.id), + "Should have inserted RULE_A" + ); + Assert.ok( + rulesInserted.some(rule => rule.id == RULE_B.id), + "Should have inserted RULE_B" + ); + + rulesInserted = []; + rulesRemoved = []; + + let insertPromise2 = waitForInsert(() => rulesInserted.length >= 3); + + info( + "Updating test rules via pref. The list service should detect the pref change." + ); + // This includes some invalid rules, they should be skipped. + Services.prefs.setStringPref( + PREF_TEST_RULES, + JSON.stringify([ + RULE_A_ORIGINAL, + RULE_B, + INVALID_RULE_EMPTY, + RULE_C, + INVALID_RULE_CLICK, + ]) + ); + + info("Wait for rules to be inserted"); + await insertPromise2; + + Assert.equal(rulesInserted.length, 3, "Should have inserted three rules."); + Assert.equal(rulesRemoved.length, 0, "Should not have removed any rules."); + + Assert.ok( + rulesInserted.some(rule => rule.id == RULE_A_ORIGINAL.id), + "Should have inserted RULE_A" + ); + Assert.ok( + rulesInserted.some(rule => rule.id == RULE_B.id), + "Should have inserted RULE_B" + ); + Assert.ok( + rulesInserted.some(rule => rule.id == RULE_C.id), + "Should have inserted RULE_C" + ); + + // Cleanup + cookieBannerListService.shutdown(); + rulesInserted = []; + rulesRemoved = []; + + Services.prefs.clearUserPref(PREF_TEST_RULES); +}); + +/** + * Tests that runContext string values get properly translated into nsIClickRule::RunContext. + */ +add_task(async function test_runContext_conversion() { + info("Initializing RemoteSettings collection " + COLLECTION_NAME); + + let ruleA = { + id: genUUID(), + click: { + presence: "#foobar", + runContext: "child", + }, + domains: ["a.com"], + }; + let ruleB = { + id: genUUID(), + click: { + presence: "#foobar", + }, + domains: ["b.com"], + }; + let ruleC = { + id: genUUID(), + click: { + presence: "#foobar", + runContext: "all", + }, + domains: ["c.com"], + }; + let ruleD = { + id: genUUID(), + click: { + presence: "#foobar", + runContext: "top", + }, + domains: ["d.com"], + }; + let ruleE = { + id: genUUID(), + click: { + presence: "#foobar", + runContext: "thisIsNotValid", + }, + domains: ["e.com"], + }; + + let db = RemoteSettings(COLLECTION_NAME).db; + db.clear(); + await db.create(ruleA); + await db.create(ruleB); + await db.create(ruleC); + await db.create(ruleD); + await db.create(ruleE); + await db.importChanges({}, Date.now()); + + let insertPromise = waitForInsert(() => rulesInserted.length >= 4); + + info( + "Initializing the cookie banner list service which triggers a collection get call" + ); + let cookieBannerListService = Cc[ + "@mozilla.org/cookie-banner-list-service;1" + ].getService(Ci.nsICookieBannerListService); + await cookieBannerListService.initForTest(); + + await insertPromise; + + let resultA = rulesInserted.find(rule => + rule.domains.includes("a.com") + ).clickRule; + let resultB = rulesInserted.find(rule => + rule.domains.includes("b.com") + ).clickRule; + let resultC = rulesInserted.find(rule => + rule.domains.includes("c.com") + ).clickRule; + let resultD = rulesInserted.find(rule => + rule.domains.includes("d.com") + ).clickRule; + let resultE = rulesInserted.find(rule => + rule.domains.includes("e.com") + ).clickRule; + + Assert.equal( + resultA.runContext, + Ci.nsIClickRule.RUN_CHILD, + "Rule A should have been imported with the correct runContext" + ); + Assert.equal( + resultB.runContext, + Ci.nsIClickRule.RUN_TOP, + "Rule B should have fallen back to default runContext" + ); + Assert.equal( + resultC.runContext, + Ci.nsIClickRule.RUN_ALL, + "Rule C should have been imported with the correct runContext" + ); + Assert.equal( + resultD.runContext, + Ci.nsIClickRule.RUN_TOP, + "Rule D should have been imported with the correct runContext" + ); + Assert.equal( + resultE.runContext, + Ci.nsIClickRule.RUN_TOP, + "Rule E should have fallen back to default runContext" + ); + + // Cleanup + cookieBannerListService.shutdown(); + rulesInserted = []; + rulesRemoved = []; + + db.clear(); + await db.importChanges({}, Date.now()); +}); + +/** + * Tests empty click rules don't get imported. + */ +add_task(async function test_empty_click_rule() { + info("Initializing RemoteSettings collection " + COLLECTION_NAME); + + let db = RemoteSettings(COLLECTION_NAME).db; + db.clear(); + await db.create(RULE_F_EMPTY_CLICK); + await db.importChanges({}, Date.now()); + + let insertPromise = waitForInsert(() => rulesInserted.length >= 1); + + info( + "Initializing the cookie banner list service which triggers a collection get call" + ); + let cookieBannerListService = Cc[ + "@mozilla.org/cookie-banner-list-service;1" + ].getService(Ci.nsICookieBannerListService); + await cookieBannerListService.initForTest(); + + await insertPromise; + + let ruleF = rulesInserted.find(rule => rule.id == RULE_F_EMPTY_CLICK.id); + + Assert.ok(ruleF, "Has rule F."); + Assert.ok(ruleF.cookiesOptOut?.length, "Should have imported a cookie rule."); + Assert.equal(ruleF.clickRule, null, "Should not have imported a click rule."); + + // Cleanup + cookieBannerListService.shutdown(); + rulesInserted = []; + rulesRemoved = []; + + db.clear(); + await db.importChanges({}, Date.now()); +}); diff --git a/toolkit/components/cookiebanners/test/unit/xpcshell.toml b/toolkit/components/cookiebanners/test/unit/xpcshell.toml new file mode 100644 index 0000000000..cfa2723627 --- /dev/null +++ b/toolkit/components/cookiebanners/test/unit/xpcshell.toml @@ -0,0 +1,3 @@ +[DEFAULT] + +["test_cookiebannerlistservice.js"] |