Source code
Revision control
Copy as Markdown
Other Tools
Test Info:
/* Any copyright is dedicated to the Public Domain.
*/
const CATEGORY = "telemetry.test";
const MAIN_ONLY = `${CATEGORY}.main_only`;
const SYNC_ONLY = `${CATEGORY}.sync_only`;
const MULTIPLE_STORES = `${CATEGORY}.multiple_stores`;
const MULTIPLE_STORES_STRING = `${CATEGORY}.multiple_stores_string`;
const MULTIPLE_STORES_BOOL = `${CATEGORY}.multiple_stores_bool`;
const MULTIPLE_STORES_KEYED = `${CATEGORY}.multiple_stores_keyed`;
function getParentSnapshot(store, keyed = false, clear = false) {
return keyed
? Telemetry.getSnapshotForKeyedScalars(store, clear).parent
: Telemetry.getSnapshotForScalars(store, clear).parent;
}
add_task(async function test_multistore_basics() {
Telemetry.clearScalars();
const expectedUint = 3785;
const expectedBool = true;
const expectedString = "some value";
const expectedKey = "some key";
Telemetry.scalarSet(MAIN_ONLY, expectedUint);
Telemetry.scalarSet(SYNC_ONLY, expectedUint);
Telemetry.scalarSet(MULTIPLE_STORES, expectedUint);
Telemetry.scalarSet(MULTIPLE_STORES_STRING, expectedString);
Telemetry.scalarSet(MULTIPLE_STORES_BOOL, expectedBool);
Telemetry.keyedScalarSet(MULTIPLE_STORES_KEYED, expectedKey, expectedUint);
const mainScalars = getParentSnapshot("main");
const syncScalars = getParentSnapshot("sync");
const mainKeyedScalars = getParentSnapshot("main", true /* keyed */);
const syncKeyedScalars = getParentSnapshot("sync", true /* keyed */);
Assert.ok(
MAIN_ONLY in mainScalars,
`Main-store scalar ${MAIN_ONLY} must be in main snapshot.`
);
Assert.ok(
!(MAIN_ONLY in syncScalars),
`Main-store scalar ${MAIN_ONLY} must not be in sync snapshot.`
);
Assert.equal(
mainScalars[MAIN_ONLY],
expectedUint,
`Main-store scalar ${MAIN_ONLY} must have correct value.`
);
Assert.ok(
SYNC_ONLY in syncScalars,
`Sync-store scalar ${SYNC_ONLY} must be in sync snapshot.`
);
Assert.ok(
!(SYNC_ONLY in mainScalars),
`Sync-store scalar ${SYNC_ONLY} must not be in main snapshot.`
);
Assert.equal(
syncScalars[SYNC_ONLY],
expectedUint,
`Sync-store scalar ${SYNC_ONLY} must have correct value.`
);
Assert.ok(
MULTIPLE_STORES in mainScalars && MULTIPLE_STORES in syncScalars,
`Multi-store scalar ${MULTIPLE_STORES} must be in both main and sync snapshots.`
);
Assert.equal(
mainScalars[MULTIPLE_STORES],
expectedUint,
`Multi-store scalar ${MULTIPLE_STORES} must have correct value in main store.`
);
Assert.equal(
syncScalars[MULTIPLE_STORES],
expectedUint,
`Multi-store scalar ${MULTIPLE_STORES} must have correct value in sync store.`
);
Assert.ok(
MULTIPLE_STORES_STRING in mainScalars &&
MULTIPLE_STORES_STRING in syncScalars,
`Multi-store scalar ${MULTIPLE_STORES_STRING} must be in both main and sync snapshots.`
);
Assert.equal(
mainScalars[MULTIPLE_STORES_STRING],
expectedString,
`Multi-store scalar ${MULTIPLE_STORES_STRING} must have correct value in main store.`
);
Assert.equal(
syncScalars[MULTIPLE_STORES_STRING],
expectedString,
`Multi-store scalar ${MULTIPLE_STORES_STRING} must have correct value in sync store.`
);
Assert.ok(
MULTIPLE_STORES_BOOL in mainScalars && MULTIPLE_STORES_BOOL in syncScalars,
`Multi-store scalar ${MULTIPLE_STORES_BOOL} must be in both main and sync snapshots.`
);
Assert.equal(
mainScalars[MULTIPLE_STORES_BOOL],
expectedBool,
`Multi-store scalar ${MULTIPLE_STORES_BOOL} must have correct value in main store.`
);
Assert.equal(
syncScalars[MULTIPLE_STORES_BOOL],
expectedBool,
`Multi-store scalar ${MULTIPLE_STORES_BOOL} must have correct value in sync store.`
);
Assert.ok(
MULTIPLE_STORES_KEYED in mainKeyedScalars &&
MULTIPLE_STORES_KEYED in syncKeyedScalars,
`Multi-store scalar ${MULTIPLE_STORES_KEYED} must be in both main and sync snapshots.`
);
Assert.ok(
expectedKey in mainKeyedScalars[MULTIPLE_STORES_KEYED] &&
expectedKey in syncKeyedScalars[MULTIPLE_STORES_KEYED],
`Multi-store scalar ${MULTIPLE_STORES_KEYED} must have key ${expectedKey} in both snapshots.`
);
Assert.equal(
mainKeyedScalars[MULTIPLE_STORES_KEYED][expectedKey],
expectedUint,
`Multi-store scalar ${MULTIPLE_STORES_KEYED} must have correct value in main store.`
);
Assert.equal(
syncKeyedScalars[MULTIPLE_STORES_KEYED][expectedKey],
expectedUint,
`Multi-store scalar ${MULTIPLE_STORES_KEYED} must have correct value in sync store.`
);
});
add_task(async function test_multistore_uint() {
Telemetry.clearScalars();
// Uint scalars are the only kind with an implicit default value of 0.
// They shouldn't report any value until set, but if you Add or SetMaximum
// they pretend that they have been set to 0 for the purposes of that operation.
function assertNotIn() {
let mainScalars = getParentSnapshot("main");
let syncScalars = getParentSnapshot("sync");
if (!mainScalars && !syncScalars) {
Assert.ok(true, "No scalars at all");
} else {
Assert.ok(
!(MULTIPLE_STORES in mainScalars) && !(MULTIPLE_STORES in syncScalars),
`Multi-store scalar ${MULTIPLE_STORES} must not have an initial value in either store.`
);
}
}
assertNotIn();
// Test that Add operates on implicit 0.
Telemetry.scalarAdd(MULTIPLE_STORES, 1);
function assertBothEqual(val, clear = false) {
let mainScalars = getParentSnapshot("main", false, clear);
let syncScalars = getParentSnapshot("sync", false, clear);
Assert.ok(
MULTIPLE_STORES in mainScalars && MULTIPLE_STORES in syncScalars,
`Multi-store scalar ${MULTIPLE_STORES} must be in both main and sync snapshots.`
);
Assert.equal(
mainScalars[MULTIPLE_STORES],
val,
`Multi-store scalar ${MULTIPLE_STORES} must have the correct value in main store.`
);
Assert.equal(
syncScalars[MULTIPLE_STORES],
val,
`Multi-store scalar ${MULTIPLE_STORES} must have the correct value in sync store.`
);
}
assertBothEqual(1, true /* clear */);
assertNotIn();
// Test that SetMaximum operates on implicit 0.
Telemetry.scalarSetMaximum(MULTIPLE_STORES, 1337);
assertBothEqual(1337);
// Test that Add works, since we're in the neighbourhood.
Telemetry.scalarAdd(MULTIPLE_STORES, 1);
assertBothEqual(1338, true /* clear */);
assertNotIn();
// Test that clearing individual stores works
// and that afterwards the values are managed independently.
Telemetry.scalarAdd(MULTIPLE_STORES, 1234);
assertBothEqual(1234);
let syncScalars = getParentSnapshot(
"sync",
false /* keyed */,
true /* clear */
);
Assert.equal(
syncScalars[MULTIPLE_STORES],
1234,
`Multi-store scalar ${MULTIPLE_STORES} must be present in a second snapshot.`
);
syncScalars = getParentSnapshot("sync");
Assert.equal(
syncScalars,
undefined,
`Multi-store scalar ${MULTIPLE_STORES} must not be present after clearing.`
);
let mainScalars = getParentSnapshot("main");
Assert.equal(
mainScalars[MULTIPLE_STORES],
1234,
`Multi-store scalar ${MULTIPLE_STORES} must maintain value in main store after sync store is cleared.`
);
Telemetry.scalarSetMaximum(MULTIPLE_STORES, 1);
syncScalars = getParentSnapshot("sync");
Assert.equal(
syncScalars[MULTIPLE_STORES],
1,
`Multi-store scalar ${MULTIPLE_STORES} must return to using implicit 0 for setMax operation.`
);
mainScalars = getParentSnapshot("main");
Assert.equal(
mainScalars[MULTIPLE_STORES],
1234,
`Multi-store scalar ${MULTIPLE_STORES} must retain old value.`
);
Telemetry.scalarAdd(MULTIPLE_STORES, 1);
syncScalars = getParentSnapshot("sync");
Assert.equal(
syncScalars[MULTIPLE_STORES],
2,
`Multi-store scalar ${MULTIPLE_STORES} must manage independently for add operations.`
);
mainScalars = getParentSnapshot("main");
Assert.equal(
mainScalars[MULTIPLE_STORES],
1235,
`Multi-store scalar ${MULTIPLE_STORES} must add properly.`
);
Telemetry.scalarSet(MULTIPLE_STORES, 9876);
assertBothEqual(9876);
});
add_task(async function test_empty_absence() {
// Current semantics are we don't snapshot empty things.
// So no {parent: {}, ...}. Instead {...}.
Telemetry.clearScalars();
Telemetry.scalarSet(MULTIPLE_STORES, 1);
let snapshot = getParentSnapshot("main", false /* keyed */, true /* clear */);
Assert.ok(
MULTIPLE_STORES in snapshot,
`${MULTIPLE_STORES} must be in the snapshot.`
);
Assert.equal(
snapshot[MULTIPLE_STORES],
1,
`${MULTIPLE_STORES} must have the correct value.`
);
snapshot = getParentSnapshot("main", false /* keyed */, true /* clear */);
Assert.equal(
snapshot,
undefined,
`Parent snapshot must be empty if no data.`
);
snapshot = getParentSnapshot("sync", false /* keyed */, true /* clear */);
Assert.ok(
MULTIPLE_STORES in snapshot,
`${MULTIPLE_STORES} must be in the sync snapshot.`
);
Assert.equal(
snapshot[MULTIPLE_STORES],
1,
`${MULTIPLE_STORES} must have the correct value in the sync snapshot.`
);
});
add_task(async function test_empty_absence_keyed() {
// Current semantics are we don't snapshot empty things.
// So no {parent: {}, ...}. Instead {...}.
// And for Keyed Scalars, no {parent: { keyed_scalar: {} }, ...}. Just {...}.
Telemetry.clearScalars();
const key = "just a key, y'know";
Telemetry.keyedScalarSet(MULTIPLE_STORES_KEYED, key, 1);
let snapshot = getParentSnapshot("main", true /* keyed */, true /* clear */);
Assert.ok(
MULTIPLE_STORES_KEYED in snapshot,
`${MULTIPLE_STORES_KEYED} must be in the snapshot.`
);
Assert.ok(
key in snapshot[MULTIPLE_STORES_KEYED],
`${MULTIPLE_STORES_KEYED} must have the stored key.`
);
Assert.equal(
snapshot[MULTIPLE_STORES_KEYED][key],
1,
`${MULTIPLE_STORES_KEYED}[${key}] should have the correct value.`
);
snapshot = getParentSnapshot("main", true /* keyed */);
Assert.equal(
snapshot,
undefined,
`Parent snapshot should be empty if no data.`
);
snapshot = getParentSnapshot("sync", true /* keyed */);
Assert.ok(
MULTIPLE_STORES_KEYED in snapshot,
`${MULTIPLE_STORES_KEYED} must be in the sync snapshot.`
);
Assert.ok(
key in snapshot[MULTIPLE_STORES_KEYED],
`${MULTIPLE_STORES_KEYED} must have the stored key.`
);
Assert.equal(
snapshot[MULTIPLE_STORES_KEYED][key],
1,
`${MULTIPLE_STORES_KEYED}[${key}] should have the correct value.`
);
});
add_task(async function test_multistore_default_values() {
Telemetry.clearScalars();
const expectedUint = 3785;
const expectedKey = "some key";
Telemetry.scalarSet(MAIN_ONLY, expectedUint);
Telemetry.scalarSet(SYNC_ONLY, expectedUint);
Telemetry.scalarSet(MULTIPLE_STORES, expectedUint);
Telemetry.keyedScalarSet(MULTIPLE_STORES_KEYED, expectedKey, expectedUint);
let mainScalars;
let mainKeyedScalars;
// Getting snapshot and NOT clearing (using default values for optional parameters)
mainScalars = Telemetry.getSnapshotForScalars().parent;
mainKeyedScalars = Telemetry.getSnapshotForKeyedScalars().parent;
Assert.equal(
mainScalars[MAIN_ONLY],
expectedUint,
`Main-store scalar ${MAIN_ONLY} must have correct value.`
);
Assert.ok(
!(SYNC_ONLY in mainScalars),
`Sync-store scalar ${SYNC_ONLY} must not be in main snapshot.`
);
Assert.equal(
mainScalars[MULTIPLE_STORES],
expectedUint,
`Multi-store scalar ${MULTIPLE_STORES} must have correct value in main store.`
);
Assert.equal(
mainKeyedScalars[MULTIPLE_STORES_KEYED][expectedKey],
expectedUint,
`Multi-store scalar ${MULTIPLE_STORES_KEYED} must have correct value in main store.`
);
// Getting snapshot and clearing
mainScalars = Telemetry.getSnapshotForScalars("main", true).parent;
mainKeyedScalars = Telemetry.getSnapshotForKeyedScalars("main", true).parent;
Assert.equal(
mainScalars[MAIN_ONLY],
expectedUint,
`Main-store scalar ${MAIN_ONLY} must have correct value.`
);
Assert.ok(
!(SYNC_ONLY in mainScalars),
`Sync-store scalar ${SYNC_ONLY} must not be in main snapshot.`
);
Assert.equal(
mainScalars[MULTIPLE_STORES],
expectedUint,
`Multi-store scalar ${MULTIPLE_STORES} must have correct value in main store.`
);
Assert.equal(
mainKeyedScalars[MULTIPLE_STORES_KEYED][expectedKey],
expectedUint,
`Multi-store scalar ${MULTIPLE_STORES_KEYED} must have correct value in main store.`
);
// Getting snapshot (with default values), should be empty now
mainScalars = Telemetry.getSnapshotForScalars().parent || {};
mainKeyedScalars = Telemetry.getSnapshotForKeyedScalars().parent || {};
Assert.ok(
!(MAIN_ONLY in mainScalars),
`Main-store scalar ${MAIN_ONLY} must not be in main snapshot.`
);
Assert.ok(
!(MULTIPLE_STORES in mainScalars),
`Multi-store scalar ${MULTIPLE_STORES} must not be in main snapshot.`
);
Assert.ok(
!(MULTIPLE_STORES_KEYED in mainKeyedScalars),
`Multi-store scalar ${MULTIPLE_STORES_KEYED} must not be in main snapshot.`
);
});