diff options
Diffstat (limited to 'browser/components/attribution/test/xpcshell/test_zoneId_parsing.js')
| -rw-r--r-- | browser/components/attribution/test/xpcshell/test_zoneId_parsing.js | 538 |
1 files changed, 538 insertions, 0 deletions
diff --git a/browser/components/attribution/test/xpcshell/test_zoneId_parsing.js b/browser/components/attribution/test/xpcshell/test_zoneId_parsing.js new file mode 100644 index 0000000000..2cab8678fd --- /dev/null +++ b/browser/components/attribution/test/xpcshell/test_zoneId_parsing.js @@ -0,0 +1,538 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ + */ +"use strict"; + +/** + * Test that we can properly parse and validate `zoneIdProvenanceData`. + */ + +const { AttributionIOUtils } = ChromeUtils.importESModule( + "resource:///modules/AttributionCode.sys.mjs" +); +const { ProvenanceData } = ChromeUtils.importESModule( + "resource:///modules/ProvenanceData.sys.mjs" +); +const { TelemetryTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/TelemetryTestUtils.sys.mjs" +); + +add_setup(function setup() { + let origReadUTF8 = AttributionIOUtils.readUTF8; + registerCleanupFunction(() => { + AttributionIOUtils.readUTF8 = origReadUTF8; + }); +}); + +// If `iniFileContents` is passed as `null`, we will simulate an error reading +// the INI. +async function testProvenance(iniFileContents, testFn, telemetryTestFn) { + // The extra data returned by `ProvenanceData.submitProvenanceTelemetry` uses + // names that don't actually match the scalar names due to name length + // restrictions. + let scalarToExtraKeyMap = { + "attribution.provenance.data_exists": "data_exists", + "attribution.provenance.file_system": "file_system", + "attribution.provenance.ads_exists": "ads_exists", + "attribution.provenance.security_zone": "security_zone", + "attribution.provenance.referrer_url_exists": "refer_url_exist", + "attribution.provenance.referrer_url_is_mozilla": "refer_url_moz", + "attribution.provenance.host_url_exists": "host_url_exist", + "attribution.provenance.host_url_is_mozilla": "host_url_moz", + }; + + if (iniFileContents == null) { + AttributionIOUtils.readUTF8 = async path => { + throw new Error("test error: simulating provenance file read error"); + }; + } else { + AttributionIOUtils.readUTF8 = async path => iniFileContents; + } + let provenance = await ProvenanceData.readZoneIdProvenanceFile(); + if (testFn) { + await testFn(provenance); + } + if (telemetryTestFn) { + Services.telemetry.clearScalars(); + let extras = await ProvenanceData.submitProvenanceTelemetry(); + let scalars = Services.telemetry.getSnapshotForScalars( + "new-profile", + false /* aClear */ + ).parent; + let checkScalar = (scalarName, expectedValue) => { + TelemetryTestUtils.assertScalar(scalars, scalarName, expectedValue); + let extraKey = scalarToExtraKeyMap[scalarName]; + Assert.equal(extras[extraKey], expectedValue.toString()); + }; + telemetryTestFn(checkScalar); + } + ProvenanceData._clearCache(); +} + +add_task(async function unableToReadFile() { + await testProvenance( + null, + provenance => { + Assert.ok("readProvenanceError" in provenance); + }, + checkScalar => { + checkScalar("attribution.provenance.data_exists", false); + } + ); +}); + +add_task(async function expectedMozilla() { + await testProvenance( + ` +[Mozilla] +fileSystem=NTFS +zoneIdFileSize=194 +zoneIdBufferLargeEnough=true +zoneIdTruncated=false + +[MozillaZoneIdentifierStartSentinel] +[ZoneTransfer] +ZoneId=3 +ReferrerUrl=https://mozilla.org/ +HostUrl=https://download-installer.cdn.mozilla.net/pub/firefox/nightly/latest-mozilla-central-l10n/Firefox%20Installer.en-US.exe +`, + provenance => { + Assert.deepEqual(provenance, { + fileSystem: "NTFS", + zoneIdFileSize: 194, + zoneIdBufferLargeEnough: true, + zoneIdTruncated: false, + zoneId: 3, + referrerUrl: "https://mozilla.org/", + hostUrl: + "https://download-installer.cdn.mozilla.net/pub/firefox/nightly/latest-mozilla-central-l10n/Firefox%20Installer.en-US.exe", + referrerUrlIsMozilla: true, + hostUrlIsMozilla: true, + }); + }, + checkScalar => { + checkScalar("attribution.provenance.data_exists", true); + checkScalar("attribution.provenance.file_system", "NTFS"); + checkScalar("attribution.provenance.ads_exists", true); + checkScalar("attribution.provenance.security_zone", "3"); + checkScalar("attribution.provenance.referrer_url_exists", true); + checkScalar("attribution.provenance.referrer_url_is_mozilla", true); + checkScalar("attribution.provenance.host_url_exists", true); + checkScalar("attribution.provenance.host_url_is_mozilla", true); + } + ); +}); + +add_task(async function expectedNonMozilla() { + await testProvenance( + ` +[ZoneTransfer] +ReferrerUrl=https://mozilla.foobar.org/ +HostUrl=https://download-installer.cdn.mozilla.foobar.net/pub/firefox/nightly/latest-mozilla-central-l10n/Firefox%20Installer.en-US.exe +`, + provenance => { + Assert.equal(provenance.referrerUrlIsMozilla, false); + Assert.equal(provenance.hostUrlIsMozilla, false); + }, + checkScalar => { + checkScalar("attribution.provenance.referrer_url_exists", true); + checkScalar("attribution.provenance.referrer_url_is_mozilla", false); + checkScalar("attribution.provenance.host_url_exists", true); + checkScalar("attribution.provenance.host_url_is_mozilla", false); + } + ); +}); + +add_task(async function readFsError() { + await testProvenance( + ` +[Mozilla] +readFsError=openFile +readFsErrorCode=1234 +`, + provenance => { + Assert.equal(provenance.readFsError, "openFile"); + Assert.equal(provenance.readFsErrorCode, 1234); + }, + checkScalar => { + checkScalar("attribution.provenance.file_system", "error"); + } + ); +}); + +add_task(async function unexpectedReadFsError() { + await testProvenance( + ` +[Mozilla] +readFsError=openFile +readFsErrorCode=bazqux +`, + provenance => { + Assert.equal(provenance.readFsError, "openFile"); + Assert.ok(!("readFsErrorCode" in provenance)); + }, + checkScalar => { + checkScalar("attribution.provenance.file_system", "error"); + } + ); +}); + +add_task(async function unexpectedReadFsError() { + await testProvenance( + ` +[Mozilla] +readFsError=foobar +`, + provenance => { + Assert.equal(provenance.readFsError, "unexpected"); + }, + checkScalar => { + checkScalar("attribution.provenance.file_system", "error"); + } + ); +}); + +add_task(async function missingFileSystem() { + await testProvenance( + ``, + provenance => { + Assert.equal(provenance.fileSystem, "missing"); + }, + checkScalar => { + checkScalar("attribution.provenance.file_system", "missing"); + } + ); +}); + +add_task(async function fileSystem() { + await testProvenance( + ` +[Mozilla] +fileSystem=ntfs +`, + provenance => { + Assert.equal(provenance.fileSystem, "NTFS"); + }, + checkScalar => { + checkScalar("attribution.provenance.file_system", "NTFS"); + } + ); +}); + +add_task(async function unexpectedFileSystem() { + await testProvenance( + ` +[Mozilla] +fileSystem=foobar +`, + provenance => { + Assert.equal(provenance.fileSystem, "other"); + }, + checkScalar => { + checkScalar("attribution.provenance.file_system", "other"); + } + ); +}); + +add_task(async function zoneIdFileSize() { + await testProvenance( + ` +[Mozilla] +zoneIdFileSize=1234 +`, + provenance => { + Assert.equal(provenance.zoneIdFileSize, 1234); + }, + null + ); +}); + +add_task(async function unknownZoneIdFileSize() { + await testProvenance( + ` +[Mozilla] +zoneIdFileSize=unknown +`, + provenance => { + Assert.equal(provenance.zoneIdFileSize, "unknown"); + }, + null + ); +}); + +add_task(async function unexpectedZoneIdFileSize() { + await testProvenance( + ` +[Mozilla] +zoneIdFileSize=foobar +`, + provenance => { + Assert.equal(provenance.zoneIdFileSize, "unexpected"); + }, + null + ); +}); + +add_task(async function missingZoneIdFileSize() { + await testProvenance( + ``, + provenance => { + Assert.ok(!("zoneIdFileSize" in provenance)); + }, + null + ); +}); + +add_task(async function zoneIdBufferLargeEnoughTrue() { + await testProvenance( + ` +[Mozilla] +zoneIdBufferLargeEnough=TrUe +`, + provenance => { + Assert.equal(provenance.zoneIdBufferLargeEnough, true); + }, + null + ); +}); + +add_task(async function zoneIdBufferLargeEnoughFalse() { + await testProvenance( + ` +[Mozilla] +zoneIdBufferLargeEnough=FaLsE +`, + provenance => { + Assert.equal(provenance.zoneIdBufferLargeEnough, false); + }, + null + ); +}); + +add_task(async function unknownZoneIdBufferLargeEnough() { + await testProvenance( + ` +[Mozilla] +zoneIdBufferLargeEnough=unknown +`, + provenance => { + Assert.equal(provenance.zoneIdBufferLargeEnough, "unknown"); + }, + null + ); +}); + +add_task(async function unknownZoneIdBufferLargeEnough() { + await testProvenance( + ` +[Mozilla] +zoneIdBufferLargeEnough=foobar +`, + provenance => { + Assert.equal(provenance.zoneIdBufferLargeEnough, "unexpected"); + }, + null + ); +}); + +add_task(async function missingZoneIdBufferLargeEnough() { + await testProvenance(``, provenance => { + Assert.ok(!("zoneIdBufferLargeEnough" in provenance)); + }); +}); + +add_task(async function zoneIdTruncatedTrue() { + await testProvenance( + ` +[Mozilla] +zoneIdTruncated=TrUe +`, + provenance => { + Assert.equal(provenance.zoneIdTruncated, true); + }, + null + ); +}); + +add_task(async function zoneIdTruncatedFalse() { + await testProvenance( + ` +[Mozilla] +zoneIdTruncated=FaLsE +`, + provenance => { + Assert.equal(provenance.zoneIdTruncated, false); + }, + null + ); +}); + +add_task(async function unknownZoneIdTruncated() { + await testProvenance( + ` +[Mozilla] +zoneIdTruncated=unknown +`, + provenance => { + Assert.equal(provenance.zoneIdTruncated, "unknown"); + }, + null + ); +}); + +add_task(async function unexpectedZoneIdTruncated() { + await testProvenance( + ` +[Mozilla] +zoneIdTruncated=foobar +`, + provenance => { + Assert.equal(provenance.zoneIdTruncated, "unexpected"); + }, + null + ); +}); + +add_task(async function missingZoneIdTruncated() { + await testProvenance(``, provenance => { + Assert.ok(!("zoneIdTruncated" in provenance)); + }); +}); + +add_task(async function readZoneIdError() { + await testProvenance( + ` +[Mozilla] +readZoneIdError=openFile +readZoneIdErrorCode=1234 +`, + provenance => { + Assert.equal(provenance.readZoneIdError, "openFile"); + Assert.equal(provenance.readZoneIdErrorCode, 1234); + }, + null + ); +}); + +add_task(async function unexpectedReadZoneIdErrorCode() { + await testProvenance( + ` +[Mozilla] +readZoneIdError=openFile +readZoneIdErrorCode=bazqux +`, + provenance => { + Assert.equal(provenance.readZoneIdError, "openFile"); + Assert.ok(!("readZoneIdErrorCode" in provenance)); + }, + null + ); +}); + +add_task(async function noAdsOnInstaller() { + await testProvenance( + ` +[Mozilla] +readZoneIdError=openFile +readZoneIdErrorCode=2 +`, + provenance => { + Assert.equal(provenance.readZoneIdError, "openFile"); + Assert.equal(provenance.readZoneIdErrorCode, 2); + }, + checkScalar => { + checkScalar("attribution.provenance.ads_exists", false); + } + ); +}); + +add_task(async function unexpectedReadZoneIdError() { + await testProvenance( + ` +[Mozilla] +readZoneIdError=foobar +`, + provenance => { + Assert.equal(provenance.readZoneIdError, "unexpected"); + }, + null + ); +}); + +add_task(async function missingZoneId() { + await testProvenance( + ``, + provenance => { + Assert.equal(provenance.zoneId, "missing"); + }, + null + ); +}); + +add_task(async function unexpectedZoneId() { + await testProvenance( + ` +[ZoneTransfer] +ZoneId=9999999999 +`, + provenance => { + Assert.equal(provenance.zoneId, "unexpected"); + }, + checkScalar => { + checkScalar("attribution.provenance.ads_exists", true); + checkScalar("attribution.provenance.security_zone", "unexpected"); + } + ); +}); + +add_task(async function missingReferrerUrl() { + await testProvenance( + ``, + provenance => { + Assert.equal(provenance.referrerUrl, "missing"); + }, + checkScalar => { + checkScalar("attribution.provenance.ads_exists", true); + checkScalar("attribution.provenance.referrer_url_exists", false); + } + ); +}); + +add_task(async function unexpectedReferrerUrl() { + await testProvenance( + ` +[ZoneTransfer] +ReferrerUrl=foobar +`, + provenance => { + Assert.equal(provenance.referrerUrl, "unexpected"); + }, + null + ); +}); + +add_task(async function missingHostUrl() { + await testProvenance( + ``, + provenance => { + Assert.equal(provenance.hostUrl, "missing"); + }, + checkScalar => { + checkScalar("attribution.provenance.ads_exists", true); + checkScalar("attribution.provenance.referrer_url_exists", false); + } + ); +}); + +add_task(async function unexpectedHostUrl() { + await testProvenance( + ` +[ZoneTransfer] +HostUrl=foobar +`, + provenance => { + Assert.equal(provenance.hostUrl, "unexpected"); + }, + null + ); +}); |