mirror of
https://github.com/ManchildProductions/UXP-Fixed.git
synced 2026-07-04 23:08:55 +00:00
Matt A. Tobin
575 lines
24 KiB
JavaScript
575 lines
24 KiB
JavaScript
/* Any copyright is dedicated to the Public Domain.
|
|
http://creativecommons.org/publicdomain/zero/1.0/
|
|
*/
|
|
|
|
const UINT_SCALAR = "telemetry.test.unsigned_int_kind";
|
|
const STRING_SCALAR = "telemetry.test.string_kind";
|
|
const BOOLEAN_SCALAR = "telemetry.test.boolean_kind";
|
|
const KEYED_UINT_SCALAR = "telemetry.test.keyed_unsigned_int";
|
|
|
|
add_task(function* test_serializationFormat() {
|
|
Telemetry.clearScalars();
|
|
|
|
// Set the scalars to a known value.
|
|
const expectedUint = 3785;
|
|
const expectedString = "some value";
|
|
Telemetry.scalarSet(UINT_SCALAR, expectedUint);
|
|
Telemetry.scalarSet(STRING_SCALAR, expectedString);
|
|
Telemetry.scalarSet(BOOLEAN_SCALAR, true);
|
|
Telemetry.keyedScalarSet(KEYED_UINT_SCALAR, "first_key", 1234);
|
|
|
|
// Get a snapshot of the scalars.
|
|
const scalars =
|
|
Telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
|
|
// Check that they are serialized to the correct format.
|
|
Assert.equal(typeof(scalars[UINT_SCALAR]), "number",
|
|
UINT_SCALAR + " must be serialized to the correct format.");
|
|
Assert.ok(Number.isInteger(scalars[UINT_SCALAR]),
|
|
UINT_SCALAR + " must be a finite integer.");
|
|
Assert.equal(scalars[UINT_SCALAR], expectedUint,
|
|
UINT_SCALAR + " must have the correct value.");
|
|
Assert.equal(typeof(scalars[STRING_SCALAR]), "string",
|
|
STRING_SCALAR + " must be serialized to the correct format.");
|
|
Assert.equal(scalars[STRING_SCALAR], expectedString,
|
|
STRING_SCALAR + " must have the correct value.");
|
|
Assert.equal(typeof(scalars[BOOLEAN_SCALAR]), "boolean",
|
|
BOOLEAN_SCALAR + " must be serialized to the correct format.");
|
|
Assert.equal(scalars[BOOLEAN_SCALAR], true,
|
|
BOOLEAN_SCALAR + " must have the correct value.");
|
|
Assert.ok(!(KEYED_UINT_SCALAR in scalars),
|
|
"Keyed scalars must be reported in a separate section.");
|
|
});
|
|
|
|
add_task(function* test_keyedSerializationFormat() {
|
|
Telemetry.clearScalars();
|
|
|
|
const expectedKey = "first_key";
|
|
const expectedOtherKey = "漢語";
|
|
const expectedUint = 3785;
|
|
const expectedOtherValue = 1107;
|
|
|
|
Telemetry.scalarSet(UINT_SCALAR, expectedUint);
|
|
Telemetry.keyedScalarSet(KEYED_UINT_SCALAR, expectedKey, expectedUint);
|
|
Telemetry.keyedScalarSet(KEYED_UINT_SCALAR, expectedOtherKey, expectedOtherValue);
|
|
|
|
// Get a snapshot of the scalars.
|
|
const keyedScalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
|
|
Assert.ok(!(UINT_SCALAR in keyedScalars),
|
|
UINT_SCALAR + " must not be serialized with the keyed scalars.");
|
|
Assert.ok(KEYED_UINT_SCALAR in keyedScalars,
|
|
KEYED_UINT_SCALAR + " must be serialized with the keyed scalars.");
|
|
Assert.equal(Object.keys(keyedScalars[KEYED_UINT_SCALAR]).length, 2,
|
|
"The keyed scalar must contain exactly 2 keys.");
|
|
Assert.ok(expectedKey in keyedScalars[KEYED_UINT_SCALAR],
|
|
KEYED_UINT_SCALAR + " must contain the expected keys.");
|
|
Assert.ok(expectedOtherKey in keyedScalars[KEYED_UINT_SCALAR],
|
|
KEYED_UINT_SCALAR + " must contain the expected keys.");
|
|
Assert.ok(Number.isInteger(keyedScalars[KEYED_UINT_SCALAR][expectedKey]),
|
|
KEYED_UINT_SCALAR + "." + expectedKey + " must be a finite integer.");
|
|
Assert.equal(keyedScalars[KEYED_UINT_SCALAR][expectedKey], expectedUint,
|
|
KEYED_UINT_SCALAR + "." + expectedKey + " must have the correct value.");
|
|
Assert.equal(keyedScalars[KEYED_UINT_SCALAR][expectedOtherKey], expectedOtherValue,
|
|
KEYED_UINT_SCALAR + "." + expectedOtherKey + " must have the correct value.");
|
|
});
|
|
|
|
add_task(function* test_nonexistingScalar() {
|
|
const NON_EXISTING_SCALAR = "telemetry.test.non_existing";
|
|
|
|
Telemetry.clearScalars();
|
|
|
|
// Make sure we throw on any operation for non-existing scalars.
|
|
Assert.throws(() => Telemetry.scalarAdd(NON_EXISTING_SCALAR, 11715),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Adding to a non existing scalar must throw.");
|
|
Assert.throws(() => Telemetry.scalarSet(NON_EXISTING_SCALAR, 11715),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Setting a non existing scalar must throw.");
|
|
Assert.throws(() => Telemetry.scalarSetMaximum(NON_EXISTING_SCALAR, 11715),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Setting the maximum of a non existing scalar must throw.");
|
|
|
|
// Make sure we throw on any operation for non-existing scalars.
|
|
Assert.throws(() => Telemetry.keyedScalarAdd(NON_EXISTING_SCALAR, "some_key", 11715),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Adding to a non existing keyed scalar must throw.");
|
|
Assert.throws(() => Telemetry.keyedScalarSet(NON_EXISTING_SCALAR, "some_key", 11715),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Setting a non existing keyed scalar must throw.");
|
|
Assert.throws(() => Telemetry.keyedScalarSetMaximum(NON_EXISTING_SCALAR, "some_key", 11715),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Setting the maximum of a non keyed existing scalar must throw.");
|
|
|
|
// Get a snapshot of the scalars.
|
|
const scalars =
|
|
Telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
|
|
Assert.ok(!(NON_EXISTING_SCALAR in scalars), "The non existing scalar must not be persisted.");
|
|
|
|
const keyedScalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
|
|
Assert.ok(!(NON_EXISTING_SCALAR in keyedScalars),
|
|
"The non existing keyed scalar must not be persisted.");
|
|
});
|
|
|
|
add_task(function* test_expiredScalar() {
|
|
const EXPIRED_SCALAR = "telemetry.test.expired";
|
|
const EXPIRED_KEYED_SCALAR = "telemetry.test.keyed_expired";
|
|
const UNEXPIRED_SCALAR = "telemetry.test.unexpired";
|
|
|
|
Telemetry.clearScalars();
|
|
|
|
// Try to set the expired scalar to some value. We will not be recording the value,
|
|
// but we shouldn't throw.
|
|
Telemetry.scalarAdd(EXPIRED_SCALAR, 11715);
|
|
Telemetry.scalarSet(EXPIRED_SCALAR, 11715);
|
|
Telemetry.scalarSetMaximum(EXPIRED_SCALAR, 11715);
|
|
Telemetry.keyedScalarAdd(EXPIRED_KEYED_SCALAR, "some_key", 11715);
|
|
Telemetry.keyedScalarSet(EXPIRED_KEYED_SCALAR, "some_key", 11715);
|
|
Telemetry.keyedScalarSetMaximum(EXPIRED_KEYED_SCALAR, "some_key", 11715);
|
|
|
|
// The unexpired scalar has an expiration version, but far away in the future.
|
|
const expectedValue = 11716;
|
|
Telemetry.scalarSet(UNEXPIRED_SCALAR, expectedValue);
|
|
|
|
// Get a snapshot of the scalars.
|
|
const scalars =
|
|
Telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
const keyedScalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
|
|
Assert.ok(!(EXPIRED_SCALAR in scalars), "The expired scalar must not be persisted.");
|
|
Assert.equal(scalars[UNEXPIRED_SCALAR], expectedValue,
|
|
"The unexpired scalar must be persisted with the correct value.");
|
|
Assert.ok(!(EXPIRED_KEYED_SCALAR in keyedScalars),
|
|
"The expired keyed scalar must not be persisted.");
|
|
});
|
|
|
|
add_task(function* test_unsignedIntScalar() {
|
|
let checkScalar = (expectedValue) => {
|
|
const scalars =
|
|
Telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
Assert.equal(scalars[UINT_SCALAR], expectedValue,
|
|
UINT_SCALAR + " must contain the expected value.");
|
|
};
|
|
|
|
Telemetry.clearScalars();
|
|
|
|
// Let's start with an accumulation without a prior set.
|
|
Telemetry.scalarAdd(UINT_SCALAR, 1);
|
|
Telemetry.scalarAdd(UINT_SCALAR, 2);
|
|
// Do we get what we expect?
|
|
checkScalar(3);
|
|
|
|
// Let's test setting the scalar to a value.
|
|
Telemetry.scalarSet(UINT_SCALAR, 3785);
|
|
checkScalar(3785);
|
|
Telemetry.scalarAdd(UINT_SCALAR, 1);
|
|
checkScalar(3786);
|
|
|
|
// Does setMaximum work?
|
|
Telemetry.scalarSet(UINT_SCALAR, 2);
|
|
checkScalar(2);
|
|
Telemetry.scalarSetMaximum(UINT_SCALAR, 5);
|
|
checkScalar(5);
|
|
// The value of the probe should still be 5, as the previous value
|
|
// is greater than the one we want to set.
|
|
Telemetry.scalarSetMaximum(UINT_SCALAR, 3);
|
|
checkScalar(5);
|
|
|
|
// Check that non-integer numbers get truncated and set.
|
|
Telemetry.scalarSet(UINT_SCALAR, 3.785);
|
|
checkScalar(3);
|
|
|
|
// Setting or adding a negative number must report an error through
|
|
// the console and drop the change (shouldn't throw).
|
|
Telemetry.scalarAdd(UINT_SCALAR, -5);
|
|
Telemetry.scalarSet(UINT_SCALAR, -5);
|
|
Telemetry.scalarSetMaximum(UINT_SCALAR, -1);
|
|
checkScalar(3);
|
|
|
|
// What happens if we try to set a value of a different type?
|
|
Telemetry.scalarSet(UINT_SCALAR, 1);
|
|
Assert.throws(() => Telemetry.scalarSet(UINT_SCALAR, "unexpected value"),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Setting the scalar to an unexpected value type must throw.");
|
|
Assert.throws(() => Telemetry.scalarAdd(UINT_SCALAR, "unexpected value"),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Adding an unexpected value type must throw.");
|
|
Assert.throws(() => Telemetry.scalarSetMaximum(UINT_SCALAR, "unexpected value"),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Setting the scalar to an unexpected value type must throw.");
|
|
// The stored value must not be compromised.
|
|
checkScalar(1);
|
|
});
|
|
|
|
add_task(function* test_stringScalar() {
|
|
let checkExpectedString = (expectedString) => {
|
|
const scalars =
|
|
Telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
Assert.equal(scalars[STRING_SCALAR], expectedString,
|
|
STRING_SCALAR + " must contain the expected string value.");
|
|
};
|
|
|
|
Telemetry.clearScalars();
|
|
|
|
// Let's check simple strings...
|
|
let expected = "test string";
|
|
Telemetry.scalarSet(STRING_SCALAR, expected);
|
|
checkExpectedString(expected);
|
|
expected = "漢語";
|
|
Telemetry.scalarSet(STRING_SCALAR, expected);
|
|
checkExpectedString(expected);
|
|
|
|
// We have some unsupported operations for strings.
|
|
Assert.throws(() => Telemetry.scalarAdd(STRING_SCALAR, 1),
|
|
/NS_ERROR_NOT_AVAILABLE/,
|
|
"Using an unsupported operation must throw.");
|
|
Assert.throws(() => Telemetry.scalarAdd(STRING_SCALAR, "string value"),
|
|
/NS_ERROR_NOT_AVAILABLE/,
|
|
"Using an unsupported operation must throw.");
|
|
Assert.throws(() => Telemetry.scalarSetMaximum(STRING_SCALAR, 1),
|
|
/NS_ERROR_NOT_AVAILABLE/,
|
|
"Using an unsupported operation must throw.");
|
|
Assert.throws(() => Telemetry.scalarSetMaximum(STRING_SCALAR, "string value"),
|
|
/NS_ERROR_NOT_AVAILABLE/,
|
|
"Using an unsupported operation must throw.");
|
|
Assert.throws(() => Telemetry.scalarSet(STRING_SCALAR, 1),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"The string scalar must throw if we're not setting a string.");
|
|
|
|
// Try to set the scalar to a string longer than the maximum length limit.
|
|
const LONG_STRING = "browser.qaxfiuosnzmhlg.rpvxicawolhtvmbkpnludhedobxvkjwqyeyvmv";
|
|
Telemetry.scalarSet(STRING_SCALAR, LONG_STRING);
|
|
checkExpectedString(LONG_STRING.substr(0, 50));
|
|
});
|
|
|
|
add_task(function* test_booleanScalar() {
|
|
let checkExpectedBool = (expectedBoolean) => {
|
|
const scalars =
|
|
Telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
Assert.equal(scalars[BOOLEAN_SCALAR], expectedBoolean,
|
|
BOOLEAN_SCALAR + " must contain the expected boolean value.");
|
|
};
|
|
|
|
Telemetry.clearScalars();
|
|
|
|
// Set a test boolean value.
|
|
let expected = false;
|
|
Telemetry.scalarSet(BOOLEAN_SCALAR, expected);
|
|
checkExpectedBool(expected);
|
|
expected = true;
|
|
Telemetry.scalarSet(BOOLEAN_SCALAR, expected);
|
|
checkExpectedBool(expected);
|
|
|
|
// Check that setting a numeric value implicitly converts to boolean.
|
|
Telemetry.scalarSet(BOOLEAN_SCALAR, 1);
|
|
checkExpectedBool(true);
|
|
Telemetry.scalarSet(BOOLEAN_SCALAR, 0);
|
|
checkExpectedBool(false);
|
|
Telemetry.scalarSet(BOOLEAN_SCALAR, 1.0);
|
|
checkExpectedBool(true);
|
|
Telemetry.scalarSet(BOOLEAN_SCALAR, 0.0);
|
|
checkExpectedBool(false);
|
|
|
|
// Check that unsupported operations for booleans throw.
|
|
Assert.throws(() => Telemetry.scalarAdd(BOOLEAN_SCALAR, 1),
|
|
/NS_ERROR_NOT_AVAILABLE/,
|
|
"Using an unsupported operation must throw.");
|
|
Assert.throws(() => Telemetry.scalarAdd(BOOLEAN_SCALAR, "string value"),
|
|
/NS_ERROR_NOT_AVAILABLE/,
|
|
"Using an unsupported operation must throw.");
|
|
Assert.throws(() => Telemetry.scalarSetMaximum(BOOLEAN_SCALAR, 1),
|
|
/NS_ERROR_NOT_AVAILABLE/,
|
|
"Using an unsupported operation must throw.");
|
|
Assert.throws(() => Telemetry.scalarSetMaximum(BOOLEAN_SCALAR, "string value"),
|
|
/NS_ERROR_NOT_AVAILABLE/,
|
|
"Using an unsupported operation must throw.");
|
|
Assert.throws(() => Telemetry.scalarSet(BOOLEAN_SCALAR, "true"),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"The boolean scalar must throw if we're not setting a boolean.");
|
|
});
|
|
|
|
add_task(function* test_scalarRecording() {
|
|
const OPTIN_SCALAR = "telemetry.test.release_optin";
|
|
const OPTOUT_SCALAR = "telemetry.test.release_optout";
|
|
|
|
let checkValue = (scalarName, expectedValue) => {
|
|
const scalars =
|
|
Telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
Assert.equal(scalars[scalarName], expectedValue,
|
|
scalarName + " must contain the expected value.");
|
|
};
|
|
|
|
let checkNotSerialized = (scalarName) => {
|
|
const scalars =
|
|
Telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
Assert.ok(!(scalarName in scalars), scalarName + " was not recorded.");
|
|
};
|
|
|
|
Telemetry.canRecordBase = false;
|
|
Telemetry.canRecordExtended = false;
|
|
Telemetry.clearScalars();
|
|
|
|
// Check that no scalar is recorded if both base and extended recording are off.
|
|
Telemetry.scalarSet(OPTOUT_SCALAR, 3);
|
|
Telemetry.scalarSet(OPTIN_SCALAR, 3);
|
|
checkNotSerialized(OPTOUT_SCALAR);
|
|
checkNotSerialized(OPTIN_SCALAR);
|
|
|
|
// Check that opt-out scalars are recorded, while opt-in are not.
|
|
Telemetry.canRecordBase = true;
|
|
Telemetry.scalarSet(OPTOUT_SCALAR, 3);
|
|
Telemetry.scalarSet(OPTIN_SCALAR, 3);
|
|
checkValue(OPTOUT_SCALAR, 3);
|
|
checkNotSerialized(OPTIN_SCALAR);
|
|
|
|
// Check that both opt-out and opt-in scalars are recorded.
|
|
Telemetry.canRecordExtended = true;
|
|
Telemetry.scalarSet(OPTOUT_SCALAR, 5);
|
|
Telemetry.scalarSet(OPTIN_SCALAR, 6);
|
|
checkValue(OPTOUT_SCALAR, 5);
|
|
checkValue(OPTIN_SCALAR, 6);
|
|
});
|
|
|
|
add_task(function* test_keyedScalarRecording() {
|
|
const OPTIN_SCALAR = "telemetry.test.keyed_release_optin";
|
|
const OPTOUT_SCALAR = "telemetry.test.keyed_release_optout";
|
|
const testKey = "policy_key";
|
|
|
|
let checkValue = (scalarName, expectedValue) => {
|
|
const scalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
Assert.equal(scalars[scalarName][testKey], expectedValue,
|
|
scalarName + " must contain the expected value.");
|
|
};
|
|
|
|
let checkNotSerialized = (scalarName) => {
|
|
const scalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
Assert.ok(!(scalarName in scalars), scalarName + " was not recorded.");
|
|
};
|
|
|
|
Telemetry.canRecordBase = false;
|
|
Telemetry.canRecordExtended = false;
|
|
Telemetry.clearScalars();
|
|
|
|
// Check that no scalar is recorded if both base and extended recording are off.
|
|
Telemetry.keyedScalarSet(OPTOUT_SCALAR, testKey, 3);
|
|
Telemetry.keyedScalarSet(OPTIN_SCALAR, testKey, 3);
|
|
checkNotSerialized(OPTOUT_SCALAR);
|
|
checkNotSerialized(OPTIN_SCALAR);
|
|
|
|
// Check that opt-out scalars are recorded, while opt-in are not.
|
|
Telemetry.canRecordBase = true;
|
|
Telemetry.keyedScalarSet(OPTOUT_SCALAR, testKey, 3);
|
|
Telemetry.keyedScalarSet(OPTIN_SCALAR, testKey, 3);
|
|
checkValue(OPTOUT_SCALAR, 3);
|
|
checkNotSerialized(OPTIN_SCALAR);
|
|
|
|
// Check that both opt-out and opt-in scalars are recorded.
|
|
Telemetry.canRecordExtended = true;
|
|
Telemetry.keyedScalarSet(OPTOUT_SCALAR, testKey, 5);
|
|
Telemetry.keyedScalarSet(OPTIN_SCALAR, testKey, 6);
|
|
checkValue(OPTOUT_SCALAR, 5);
|
|
checkValue(OPTIN_SCALAR, 6);
|
|
});
|
|
|
|
add_task(function* test_subsession() {
|
|
Telemetry.clearScalars();
|
|
|
|
// Set the scalars to a known value.
|
|
Telemetry.scalarSet(UINT_SCALAR, 3785);
|
|
Telemetry.scalarSet(STRING_SCALAR, "some value");
|
|
Telemetry.scalarSet(BOOLEAN_SCALAR, false);
|
|
Telemetry.keyedScalarSet(KEYED_UINT_SCALAR, "some_random_key", 12);
|
|
|
|
// Get a snapshot and reset the subsession. The value we set must be there.
|
|
let scalars =
|
|
Telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
|
|
let keyedScalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
|
|
|
|
Assert.equal(scalars[UINT_SCALAR], 3785,
|
|
UINT_SCALAR + " must contain the expected value.");
|
|
Assert.equal(scalars[STRING_SCALAR], "some value",
|
|
STRING_SCALAR + " must contain the expected value.");
|
|
Assert.equal(scalars[BOOLEAN_SCALAR], false,
|
|
BOOLEAN_SCALAR + " must contain the expected value.");
|
|
Assert.equal(keyedScalars[KEYED_UINT_SCALAR]["some_random_key"], 12,
|
|
KEYED_UINT_SCALAR + " must contain the expected value.");
|
|
|
|
// Get a new snapshot and reset the subsession again. Since no new value
|
|
// was set, the scalars should not be reported.
|
|
scalars =
|
|
Telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
|
|
keyedScalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
|
|
|
|
Assert.ok(!(UINT_SCALAR in scalars), UINT_SCALAR + " must be empty and not reported.");
|
|
Assert.ok(!(STRING_SCALAR in scalars), STRING_SCALAR + " must be empty and not reported.");
|
|
Assert.ok(!(BOOLEAN_SCALAR in scalars), BOOLEAN_SCALAR + " must be empty and not reported.");
|
|
Assert.ok(!(KEYED_UINT_SCALAR in keyedScalars), KEYED_UINT_SCALAR + " must be empty and not reported.");
|
|
});
|
|
|
|
add_task(function* test_keyed_uint() {
|
|
Telemetry.clearScalars();
|
|
|
|
const KEYS = [ "a_key", "another_key", "third_key" ];
|
|
let expectedValues = [ 1, 1, 1 ];
|
|
|
|
// Set all the keys to a baseline value.
|
|
for (let key of KEYS) {
|
|
Telemetry.keyedScalarSet(KEYED_UINT_SCALAR, key, 1);
|
|
}
|
|
|
|
// Increment only one key.
|
|
Telemetry.keyedScalarAdd(KEYED_UINT_SCALAR, KEYS[1], 1);
|
|
expectedValues[1]++;
|
|
|
|
// Use SetMaximum on the third key.
|
|
Telemetry.keyedScalarSetMaximum(KEYED_UINT_SCALAR, KEYS[2], 37);
|
|
expectedValues[2] = 37;
|
|
|
|
// Get a snapshot of the scalars and make sure the keys contain
|
|
// the correct values.
|
|
const keyedScalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
|
|
for (let k = 0; k < 3; k++) {
|
|
const keyName = KEYS[k];
|
|
Assert.equal(keyedScalars[KEYED_UINT_SCALAR][keyName], expectedValues[k],
|
|
KEYED_UINT_SCALAR + "." + keyName + " must contain the correct value.");
|
|
}
|
|
|
|
// Are we still throwing when doing unsupported things on uint keyed scalars?
|
|
// Just test one single unsupported operation, the other are covered in the plain
|
|
// unsigned scalar test.
|
|
Assert.throws(() => Telemetry.scalarSet(KEYED_UINT_SCALAR, "new_key", "unexpected value"),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Setting the scalar to an unexpected value type must throw.");
|
|
});
|
|
|
|
add_task(function* test_keyed_boolean() {
|
|
Telemetry.clearScalars();
|
|
|
|
const KEYED_BOOLEAN_TYPE = "telemetry.test.keyed_boolean_kind";
|
|
const first_key = "first_key";
|
|
const second_key = "second_key";
|
|
|
|
// Set the initial values.
|
|
Telemetry.keyedScalarSet(KEYED_BOOLEAN_TYPE, first_key, true);
|
|
Telemetry.keyedScalarSet(KEYED_BOOLEAN_TYPE, second_key, false);
|
|
|
|
// Get a snapshot of the scalars and make sure the keys contain
|
|
// the correct values.
|
|
let keyedScalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
Assert.equal(keyedScalars[KEYED_BOOLEAN_TYPE][first_key], true,
|
|
"The key must contain the expected value.");
|
|
Assert.equal(keyedScalars[KEYED_BOOLEAN_TYPE][second_key], false,
|
|
"The key must contain the expected value.");
|
|
|
|
// Now flip the values and make sure we get the expected values back.
|
|
Telemetry.keyedScalarSet(KEYED_BOOLEAN_TYPE, first_key, false);
|
|
Telemetry.keyedScalarSet(KEYED_BOOLEAN_TYPE, second_key, true);
|
|
|
|
keyedScalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
Assert.equal(keyedScalars[KEYED_BOOLEAN_TYPE][first_key], false,
|
|
"The key must contain the expected value.");
|
|
Assert.equal(keyedScalars[KEYED_BOOLEAN_TYPE][second_key], true,
|
|
"The key must contain the expected value.");
|
|
|
|
// Are we still throwing when doing unsupported things on a boolean keyed scalars?
|
|
// Just test one single unsupported operation, the other are covered in the plain
|
|
// boolean scalar test.
|
|
Assert.throws(() => Telemetry.keyedScalarAdd(KEYED_BOOLEAN_TYPE, "somehey", 1),
|
|
/NS_ERROR_NOT_AVAILABLE/,
|
|
"Using an unsupported operation must throw.");
|
|
});
|
|
|
|
add_task(function* test_keyed_keys_length() {
|
|
Telemetry.clearScalars();
|
|
|
|
const LONG_KEY_STRING =
|
|
"browser.qaxfiuosnzmhlg.rpvxicawolhtvmbkpnludhedobxvkjwqyeyvmv.somemoresowereach70chars";
|
|
const NORMAL_KEY = "a_key";
|
|
|
|
// Set the value for a key within the length limits.
|
|
Telemetry.keyedScalarSet(KEYED_UINT_SCALAR, NORMAL_KEY, 1);
|
|
|
|
// Now try to set and modify the value for a very long key.
|
|
Assert.throws(() => Telemetry.keyedScalarAdd(KEYED_UINT_SCALAR, LONG_KEY_STRING, 10),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Using keys longer than 70 characters must throw.");
|
|
Assert.throws(() => Telemetry.keyedScalarSet(KEYED_UINT_SCALAR, LONG_KEY_STRING, 1),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Using keys longer than 70 characters must throw.");
|
|
Assert.throws(() => Telemetry.keyedScalarSetMaximum(KEYED_UINT_SCALAR, LONG_KEY_STRING, 10),
|
|
/NS_ERROR_ILLEGAL_VALUE/,
|
|
"Using keys longer than 70 characters must throw.");
|
|
|
|
// Make sure the key with the right length contains the expected value.
|
|
let keyedScalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
Assert.equal(Object.keys(keyedScalars[KEYED_UINT_SCALAR]).length, 1,
|
|
"The keyed scalar must contain exactly 1 key.");
|
|
Assert.ok(NORMAL_KEY in keyedScalars[KEYED_UINT_SCALAR],
|
|
"The keyed scalar must contain the expected key.");
|
|
Assert.equal(keyedScalars[KEYED_UINT_SCALAR][NORMAL_KEY], 1,
|
|
"The key must contain the expected value.");
|
|
Assert.ok(!(LONG_KEY_STRING in keyedScalars[KEYED_UINT_SCALAR]),
|
|
"The data for the long key should not have been recorded.");
|
|
});
|
|
|
|
add_task(function* test_keyed_max_keys() {
|
|
Telemetry.clearScalars();
|
|
|
|
// Generate the names for the first 100 keys.
|
|
let keyNamesSet = new Set();
|
|
for (let k = 0; k < 100; k++) {
|
|
keyNamesSet.add("key_" + k);
|
|
}
|
|
|
|
// Add 100 keys to an histogram and set their initial value.
|
|
let valueToSet = 0;
|
|
keyNamesSet.forEach(keyName => {
|
|
Telemetry.keyedScalarSet(KEYED_UINT_SCALAR, keyName, valueToSet++);
|
|
});
|
|
|
|
// Perform some operations on the 101th key. This should throw, as
|
|
// we're not allowed to have more than 100 keys.
|
|
const LAST_KEY_NAME = "overflowing_key";
|
|
Assert.throws(() => Telemetry.keyedScalarAdd(KEYED_UINT_SCALAR, LAST_KEY_NAME, 10),
|
|
/NS_ERROR_FAILURE/,
|
|
"Using more than 100 keys must throw.");
|
|
Assert.throws(() => Telemetry.keyedScalarSet(KEYED_UINT_SCALAR, LAST_KEY_NAME, 1),
|
|
/NS_ERROR_FAILURE/,
|
|
"Using more than 100 keys must throw.");
|
|
Assert.throws(() => Telemetry.keyedScalarSetMaximum(KEYED_UINT_SCALAR, LAST_KEY_NAME, 10),
|
|
/NS_ERROR_FAILURE/,
|
|
"Using more than 100 keys must throw.");
|
|
|
|
// Make sure all the keys except the last one are available and have the correct
|
|
// values.
|
|
let keyedScalars =
|
|
Telemetry.snapshotKeyedScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
|
|
|
|
// Check that the keyed scalar only contain the first 100 keys.
|
|
const reportedKeysSet = new Set(Object.keys(keyedScalars[KEYED_UINT_SCALAR]));
|
|
Assert.ok([...keyNamesSet].filter(x => reportedKeysSet.has(x)) &&
|
|
[...reportedKeysSet].filter(x => keyNamesSet.has(x)),
|
|
"The keyed scalar must contain all the 100 keys, and drop the others.");
|
|
|
|
// Check that all the keys recorded the expected values.
|
|
let expectedValue = 0;
|
|
keyNamesSet.forEach(keyName => {
|
|
Assert.equal(keyedScalars[KEYED_UINT_SCALAR][keyName], expectedValue++,
|
|
"The key must contain the expected value.");
|
|
});
|
|
});
|