diff options
Diffstat (limited to 'toolkit/components/telemetry/tests/unit/test_TelemetryScalars.js')
| -rw-r--r-- | toolkit/components/telemetry/tests/unit/test_TelemetryScalars.js | 574 |
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."); + }); +}); |