Add m-esr52 at 52.6.0

1 files changed, 574 insertions, 0 deletions

diff --git a/toolkit/components/telemetry/tests/unit/test_TelemetryScalars.js b/toolkit/components/telemetry/tests/unit/test_TelemetryScalars.js
new file mode 100644
index 000000000..5914a4235
--- /dev/null
+++ b/toolkit/components/telemetry/tests/unit/test_TelemetryScalars.js
@@ -0,0 +1,574 @@
+/* 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.");
+  });
+});