mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
840 lines
29 KiB
JavaScript
840 lines
29 KiB
JavaScript
/* Any copyright is dedicated to the Public Domain.
|
|
* http://creativecommons.org/publicdomain/zero/1.0/ */
|
|
|
|
"use strict";
|
|
|
|
const {utils: Cu} = Components;
|
|
|
|
Cu.import("resource://gre/modules/Promise.jsm");
|
|
Cu.import("resource://gre/modules/Metrics.jsm");
|
|
Cu.import("resource://services-common/utils.js");
|
|
|
|
|
|
const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
|
|
|
|
|
|
function run_test() {
|
|
run_next_test();
|
|
}
|
|
|
|
add_test(function test_days_date_conversion() {
|
|
let toDays = Metrics.dateToDays;
|
|
let toDate = Metrics.daysToDate;
|
|
|
|
let d = new Date(0);
|
|
do_check_eq(toDays(d), 0);
|
|
|
|
d = new Date(MILLISECONDS_PER_DAY);
|
|
do_check_eq(toDays(d), 1);
|
|
|
|
d = new Date(MILLISECONDS_PER_DAY - 1);
|
|
do_check_eq(toDays(d), 0);
|
|
|
|
d = new Date("1970-12-31T23:59:59.999Z");
|
|
do_check_eq(toDays(d), 364);
|
|
|
|
d = new Date("1971-01-01T00:00:00Z");
|
|
do_check_eq(toDays(d), 365);
|
|
|
|
d = toDate(0);
|
|
do_check_eq(d.getTime(), 0);
|
|
|
|
d = toDate(1);
|
|
do_check_eq(d.getTime(), MILLISECONDS_PER_DAY);
|
|
|
|
d = toDate(365);
|
|
do_check_eq(d.getUTCFullYear(), 1971);
|
|
do_check_eq(d.getUTCMonth(), 0);
|
|
do_check_eq(d.getUTCDate(), 1);
|
|
do_check_eq(d.getUTCHours(), 0);
|
|
do_check_eq(d.getUTCMinutes(), 0);
|
|
do_check_eq(d.getUTCSeconds(), 0);
|
|
do_check_eq(d.getUTCMilliseconds(), 0);
|
|
|
|
run_next_test();
|
|
});
|
|
|
|
add_task(function test_get_sqlite_backend() {
|
|
let backend = yield Metrics.Storage("get_sqlite_backend.sqlite");
|
|
|
|
do_check_neq(backend._connection, null);
|
|
|
|
// Ensure WAL and auto checkpoint are enabled.
|
|
do_check_neq(backend._enabledWALCheckpointPages, null);
|
|
let rows = yield backend._connection.execute("PRAGMA journal_mode");
|
|
do_check_eq(rows[0].getResultByIndex(0), "wal");
|
|
rows = yield backend._connection.execute("PRAGMA wal_autocheckpoint");
|
|
do_check_eq(rows[0].getResultByIndex(0), backend._enabledWALCheckpointPages);
|
|
|
|
yield backend.close();
|
|
do_check_null(backend._connection);
|
|
});
|
|
|
|
add_task(function test_reconnect() {
|
|
let backend = yield Metrics.Storage("reconnect");
|
|
yield backend.close();
|
|
|
|
let backend2 = yield Metrics.Storage("reconnect");
|
|
yield backend2.close();
|
|
});
|
|
|
|
add_task(function test_future_schema_errors() {
|
|
let backend = yield Metrics.Storage("future_schema_errors");
|
|
backend._connection.schemaVersion = 2;
|
|
yield backend.close();
|
|
|
|
let backend2;
|
|
let failed = false;
|
|
try {
|
|
backend2 = yield Metrics.Storage("future_schema_errors");
|
|
} catch (ex) {
|
|
failed = true;
|
|
do_check_true(ex.message.startsWith("Unknown database schema"));
|
|
}
|
|
|
|
do_check_null(backend2);
|
|
do_check_true(failed);
|
|
});
|
|
|
|
add_task(function test_checkpoint_apis() {
|
|
let backend = yield Metrics.Storage("checkpoint_apis");
|
|
let c = backend._connection;
|
|
let count = c._statementCounter;
|
|
|
|
yield backend.setAutoCheckpoint(0);
|
|
do_check_eq(c._statementCounter, count + 1);
|
|
|
|
let rows = yield c.execute("PRAGMA wal_autocheckpoint");
|
|
do_check_eq(rows[0].getResultByIndex(0), 0);
|
|
count = c._statementCounter;
|
|
|
|
yield backend.setAutoCheckpoint(1);
|
|
do_check_eq(c._statementCounter, count + 1);
|
|
|
|
rows = yield c.execute("PRAGMA wal_autocheckpoint");
|
|
do_check_eq(rows[0].getResultByIndex(0), backend._enabledWALCheckpointPages);
|
|
count = c._statementCounter;
|
|
|
|
yield backend.checkpoint();
|
|
do_check_eq(c._statementCounter, count + 1);
|
|
|
|
yield backend.checkpoint();
|
|
do_check_eq(c._statementCounter, count + 2);
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_measurement_registration() {
|
|
let backend = yield Metrics.Storage("measurement_registration");
|
|
|
|
do_check_false(backend.hasProvider("foo"));
|
|
do_check_false(backend.hasMeasurement("foo", "bar", 1));
|
|
|
|
let id = yield backend.registerMeasurement("foo", "bar", 1);
|
|
do_check_eq(id, 1);
|
|
|
|
do_check_true(backend.hasProvider("foo"));
|
|
do_check_true(backend.hasMeasurement("foo", "bar", 1));
|
|
do_check_eq(backend.measurementID("foo", "bar", 1), id);
|
|
do_check_false(backend.hasMeasurement("foo", "bar", 2));
|
|
|
|
let id2 = yield backend.registerMeasurement("foo", "bar", 2);
|
|
do_check_eq(id2, 2);
|
|
do_check_true(backend.hasMeasurement("foo", "bar", 2));
|
|
do_check_eq(backend.measurementID("foo", "bar", 2), id2);
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_field_registration_basic() {
|
|
let backend = yield Metrics.Storage("field_registration_basic");
|
|
|
|
do_check_false(backend.hasField("foo", "bar", 1, "baz"));
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
do_check_false(backend.hasField("foo", "bar", 1, "baz"));
|
|
do_check_false(backend.hasFieldFromMeasurement(mID, "baz"));
|
|
|
|
let bazID = yield backend.registerField(mID, "baz",
|
|
backend.FIELD_DAILY_COUNTER);
|
|
do_check_true(backend.hasField("foo", "bar", 1, "baz"));
|
|
do_check_true(backend.hasFieldFromMeasurement(mID, "baz"));
|
|
|
|
let bar2ID = yield backend.registerMeasurement("foo", "bar2", 1);
|
|
|
|
yield backend.registerField(bar2ID, "baz",
|
|
backend.FIELD_DAILY_DISCRETE_NUMERIC);
|
|
|
|
do_check_true(backend.hasField("foo", "bar2", 1, "baz"));
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
// Ensure changes types of fields results in fatal error.
|
|
add_task(function test_field_registration_changed_type() {
|
|
let backend = yield Metrics.Storage("field_registration_changed_type");
|
|
|
|
let mID = yield backend.registerMeasurement("bar", "bar", 1);
|
|
|
|
let id = yield backend.registerField(mID, "baz",
|
|
backend.FIELD_DAILY_COUNTER);
|
|
|
|
let caught = false;
|
|
try {
|
|
yield backend.registerField(mID, "baz",
|
|
backend.FIELD_DAILY_DISCRETE_NUMERIC);
|
|
} catch (ex) {
|
|
caught = true;
|
|
do_check_true(ex.message.startsWith("Field already defined with different type"));
|
|
}
|
|
|
|
do_check_true(caught);
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_field_registration_repopulation() {
|
|
let backend = yield Metrics.Storage("field_registration_repopulation");
|
|
|
|
let mID1 = yield backend.registerMeasurement("foo", "bar", 1);
|
|
let mID2 = yield backend.registerMeasurement("foo", "bar", 2);
|
|
let mID3 = yield backend.registerMeasurement("foo", "biz", 1);
|
|
let mID4 = yield backend.registerMeasurement("baz", "foo", 1);
|
|
|
|
let fID1 = yield backend.registerField(mID1, "foo", backend.FIELD_DAILY_COUNTER);
|
|
let fID2 = yield backend.registerField(mID1, "bar", backend.FIELD_DAILY_DISCRETE_NUMERIC);
|
|
let fID3 = yield backend.registerField(mID4, "foo", backend.FIELD_LAST_TEXT);
|
|
|
|
yield backend.close();
|
|
|
|
backend = yield Metrics.Storage("field_registration_repopulation");
|
|
|
|
do_check_true(backend.hasProvider("foo"));
|
|
do_check_true(backend.hasProvider("baz"));
|
|
do_check_true(backend.hasMeasurement("foo", "bar", 1));
|
|
do_check_eq(backend.measurementID("foo", "bar", 1), mID1);
|
|
do_check_true(backend.hasMeasurement("foo", "bar", 2));
|
|
do_check_eq(backend.measurementID("foo", "bar", 2), mID2);
|
|
do_check_true(backend.hasMeasurement("foo", "biz", 1));
|
|
do_check_eq(backend.measurementID("foo", "biz", 1), mID3);
|
|
do_check_true(backend.hasMeasurement("baz", "foo", 1));
|
|
do_check_eq(backend.measurementID("baz", "foo", 1), mID4);
|
|
|
|
do_check_true(backend.hasField("foo", "bar", 1, "foo"));
|
|
do_check_eq(backend.fieldID("foo", "bar", 1, "foo"), fID1);
|
|
do_check_true(backend.hasField("foo", "bar", 1, "bar"));
|
|
do_check_eq(backend.fieldID("foo", "bar", 1, "bar"), fID2);
|
|
do_check_true(backend.hasField("baz", "foo", 1, "foo"));
|
|
do_check_eq(backend.fieldID("baz", "foo", 1, "foo"), fID3);
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_enqueue_operation_execution_order() {
|
|
let backend = yield Metrics.Storage("enqueue_operation_execution_order");
|
|
|
|
let executionCount = 0;
|
|
|
|
let fns = {
|
|
op1: function () {
|
|
do_check_eq(executionCount, 1);
|
|
},
|
|
|
|
op2: function () {
|
|
do_check_eq(executionCount, 2);
|
|
},
|
|
|
|
op3: function () {
|
|
do_check_eq(executionCount, 3);
|
|
},
|
|
};
|
|
|
|
function enqueuedOperation(fn) {
|
|
let deferred = Promise.defer();
|
|
|
|
CommonUtils.nextTick(function onNextTick() {
|
|
executionCount++;
|
|
fn();
|
|
deferred.resolve();
|
|
});
|
|
|
|
return deferred.promise;
|
|
}
|
|
|
|
let promises = [];
|
|
for (let i = 1; i <= 3; i++) {
|
|
let fn = fns["op" + i];
|
|
promises.push(backend.enqueueOperation(enqueuedOperation.bind(this, fn)));
|
|
}
|
|
|
|
for (let promise of promises) {
|
|
yield promise;
|
|
}
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_enqueue_operation_many() {
|
|
let backend = yield Metrics.Storage("enqueue_operation_many");
|
|
|
|
let promises = [];
|
|
for (let i = 0; i < 100; i++) {
|
|
promises.push(backend.registerMeasurement("foo", "bar" + i, 1));
|
|
}
|
|
|
|
for (let promise of promises) {
|
|
yield promise;
|
|
}
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
// If the operation did not return a promise, everything should still execute.
|
|
add_task(function test_enqueue_operation_no_return_promise() {
|
|
let backend = yield Metrics.Storage("enqueue_operation_no_return_promise");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
let fID = yield backend.registerField(mID, "baz", backend.FIELD_DAILY_COUNTER);
|
|
let now = new Date();
|
|
|
|
let promises = [];
|
|
for (let i = 0; i < 10; i++) {
|
|
promises.push(backend.enqueueOperation(function op() {
|
|
backend.incrementDailyCounterFromFieldID(fID, now);
|
|
}));
|
|
}
|
|
|
|
let deferred = Promise.defer();
|
|
|
|
let finished = 0;
|
|
for (let promise of promises) {
|
|
promise.then(
|
|
do_throw.bind(this, "Unexpected resolve."),
|
|
function onError() {
|
|
finished++;
|
|
|
|
if (finished == promises.length) {
|
|
backend.getDailyCounterCountFromFieldID(fID, now).then(function onCount(count) {
|
|
// There should not be a race condition here because storage
|
|
// serializes all statements. So, for the getDailyCounterCount
|
|
// query to finish means that all counter update statements must
|
|
// have completed.
|
|
do_check_eq(count, promises.length);
|
|
deferred.resolve();
|
|
});
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
yield deferred.promise;
|
|
yield backend.close();
|
|
});
|
|
|
|
// If an operation throws, subsequent operations should still execute.
|
|
add_task(function test_enqueue_operation_throw_exception() {
|
|
let backend = yield Metrics.Storage("enqueue_operation_rejected_promise");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
let fID = yield backend.registerField(mID, "baz", backend.FIELD_DAILY_COUNTER);
|
|
let now = new Date();
|
|
|
|
let deferred = Promise.defer();
|
|
backend.enqueueOperation(function bad() {
|
|
throw new Error("I failed.");
|
|
}).then(do_throw, function onError(error) {
|
|
do_check_true(error.message.contains("I failed."));
|
|
deferred.resolve();
|
|
});
|
|
|
|
let promise = backend.enqueueOperation(function () {
|
|
return backend.incrementDailyCounterFromFieldID(fID, now);
|
|
});
|
|
|
|
yield deferred.promise;
|
|
yield promise;
|
|
|
|
let count = yield backend.getDailyCounterCountFromFieldID(fID, now);
|
|
do_check_eq(count, 1);
|
|
yield backend.close();
|
|
});
|
|
|
|
// If an operation rejects, subsequent operations should still execute.
|
|
add_task(function test_enqueue_operation_reject_promise() {
|
|
let backend = yield Metrics.Storage("enqueue_operation_reject_promise");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
let fID = yield backend.registerField(mID, "baz", backend.FIELD_DAILY_COUNTER);
|
|
let now = new Date();
|
|
|
|
let deferred = Promise.defer();
|
|
backend.enqueueOperation(function reject() {
|
|
let d = Promise.defer();
|
|
|
|
CommonUtils.nextTick(function nextTick() {
|
|
d.reject("I failed.");
|
|
});
|
|
|
|
return d.promise;
|
|
}).then(do_throw, function onError(error) {
|
|
deferred.resolve();
|
|
});
|
|
|
|
let promise = backend.enqueueOperation(function () {
|
|
return backend.incrementDailyCounterFromFieldID(fID, now);
|
|
});
|
|
|
|
yield deferred.promise;
|
|
yield promise;
|
|
|
|
let count = yield backend.getDailyCounterCountFromFieldID(fID, now);
|
|
do_check_eq(count, 1);
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_enqueue_transaction() {
|
|
let backend = yield Metrics.Storage("enqueue_transaction");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
let fID = yield backend.registerField(mID, "baz", backend.FIELD_DAILY_COUNTER);
|
|
let now = new Date();
|
|
|
|
yield backend.incrementDailyCounterFromFieldID(fID, now);
|
|
|
|
yield backend.enqueueTransaction(function transaction() {
|
|
yield backend.incrementDailyCounterFromFieldID(fID, now);
|
|
});
|
|
|
|
let count = yield backend.getDailyCounterCountFromFieldID(fID, now);
|
|
do_check_eq(count, 2);
|
|
|
|
let errored = false;
|
|
try {
|
|
yield backend.enqueueTransaction(function aborted() {
|
|
yield backend.incrementDailyCounterFromFieldID(fID, now);
|
|
|
|
throw new Error("Some error.");
|
|
});
|
|
} catch (ex) {
|
|
errored = true;
|
|
} finally {
|
|
do_check_true(errored);
|
|
}
|
|
|
|
count = yield backend.getDailyCounterCountFromFieldID(fID, now);
|
|
do_check_eq(count, 2);
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_increment_daily_counter_basic() {
|
|
let backend = yield Metrics.Storage("increment_daily_counter_basic");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
|
|
let fieldID = yield backend.registerField(mID, "baz",
|
|
backend.FIELD_DAILY_COUNTER);
|
|
|
|
let now = new Date();
|
|
yield backend.incrementDailyCounterFromFieldID(fieldID, now);
|
|
|
|
let count = yield backend.getDailyCounterCountFromFieldID(fieldID, now);
|
|
do_check_eq(count, 1);
|
|
|
|
yield backend.incrementDailyCounterFromFieldID(fieldID, now);
|
|
count = yield backend.getDailyCounterCountFromFieldID(fieldID, now);
|
|
do_check_eq(count, 2);
|
|
|
|
yield backend.incrementDailyCounterFromFieldID(fieldID, now, 10);
|
|
count = yield backend.getDailyCounterCountFromFieldID(fieldID, now);
|
|
do_check_eq(count, 12);
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_increment_daily_counter_multiple_days() {
|
|
let backend = yield Metrics.Storage("increment_daily_counter_multiple_days");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
let fieldID = yield backend.registerField(mID, "baz",
|
|
backend.FIELD_DAILY_COUNTER);
|
|
|
|
let days = [];
|
|
let now = Date.now();
|
|
for (let i = 0; i < 100; i++) {
|
|
days.push(new Date(now - i * MILLISECONDS_PER_DAY));
|
|
}
|
|
|
|
for (let day of days) {
|
|
yield backend.incrementDailyCounterFromFieldID(fieldID, day);
|
|
}
|
|
|
|
let result = yield backend.getDailyCounterCountsFromFieldID(fieldID);
|
|
do_check_eq(result.size, 100);
|
|
for (let day of days) {
|
|
do_check_true(result.hasDay(day));
|
|
do_check_eq(result.getDay(day), 1);
|
|
}
|
|
|
|
let fields = yield backend.getMeasurementDailyCountersFromMeasurementID(mID);
|
|
do_check_eq(fields.size, 1);
|
|
do_check_true(fields.has("baz"));
|
|
do_check_eq(fields.get("baz").size, 100);
|
|
|
|
for (let day of days) {
|
|
do_check_true(fields.get("baz").hasDay(day));
|
|
do_check_eq(fields.get("baz").getDay(day), 1);
|
|
}
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_last_values() {
|
|
let backend = yield Metrics.Storage("set_last");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
let numberID = yield backend.registerField(mID, "number",
|
|
backend.FIELD_LAST_NUMERIC);
|
|
let textID = yield backend.registerField(mID, "text",
|
|
backend.FIELD_LAST_TEXT);
|
|
let now = new Date();
|
|
let nowDay = new Date(Math.floor(now.getTime() / MILLISECONDS_PER_DAY) * MILLISECONDS_PER_DAY);
|
|
|
|
yield backend.setLastNumericFromFieldID(numberID, 42, now);
|
|
yield backend.setLastTextFromFieldID(textID, "hello world", now);
|
|
|
|
let result = yield backend.getLastNumericFromFieldID(numberID);
|
|
do_check_true(Array.isArray(result));
|
|
do_check_eq(result[0].getTime(), nowDay.getTime());
|
|
do_check_eq(typeof(result[1]), "number");
|
|
do_check_eq(result[1], 42);
|
|
|
|
result = yield backend.getLastTextFromFieldID(textID);
|
|
do_check_true(Array.isArray(result));
|
|
do_check_eq(result[0].getTime(), nowDay.getTime());
|
|
do_check_eq(typeof(result[1]), "string");
|
|
do_check_eq(result[1], "hello world");
|
|
|
|
let missingID = yield backend.registerField(mID, "missing",
|
|
backend.FIELD_LAST_NUMERIC);
|
|
do_check_null(yield backend.getLastNumericFromFieldID(missingID));
|
|
|
|
let fields = yield backend.getMeasurementLastValuesFromMeasurementID(mID);
|
|
do_check_eq(fields.size, 2);
|
|
do_check_true(fields.has("number"));
|
|
do_check_true(fields.has("text"));
|
|
do_check_eq(fields.get("number")[1], 42);
|
|
do_check_eq(fields.get("text")[1], "hello world");
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_discrete_values_basic() {
|
|
let backend = yield Metrics.Storage("discrete_values_basic");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
let numericID = yield backend.registerField(mID, "numeric",
|
|
backend.FIELD_DAILY_DISCRETE_NUMERIC);
|
|
let textID = yield backend.registerField(mID, "text",
|
|
backend.FIELD_DAILY_DISCRETE_TEXT);
|
|
|
|
let now = new Date();
|
|
let expectedNumeric = [];
|
|
let expectedText = [];
|
|
for (let i = 0; i < 100; i++) {
|
|
expectedNumeric.push(i);
|
|
expectedText.push("value" + i);
|
|
yield backend.addDailyDiscreteNumericFromFieldID(numericID, i, now);
|
|
yield backend.addDailyDiscreteTextFromFieldID(textID, "value" + i, now);
|
|
}
|
|
|
|
let values = yield backend.getDailyDiscreteNumericFromFieldID(numericID);
|
|
do_check_eq(values.size, 1);
|
|
do_check_true(values.hasDay(now));
|
|
do_check_true(Array.isArray(values.getDay(now)));
|
|
do_check_eq(values.getDay(now).length, expectedNumeric.length);
|
|
|
|
for (let i = 0; i < expectedNumeric.length; i++) {
|
|
do_check_eq(values.getDay(now)[i], expectedNumeric[i]);
|
|
}
|
|
|
|
values = yield backend.getDailyDiscreteTextFromFieldID(textID);
|
|
do_check_eq(values.size, 1);
|
|
do_check_true(values.hasDay(now));
|
|
do_check_true(Array.isArray(values.getDay(now)));
|
|
do_check_eq(values.getDay(now).length, expectedText.length);
|
|
|
|
for (let i = 0; i < expectedText.length; i++) {
|
|
do_check_eq(values.getDay(now)[i], expectedText[i]);
|
|
}
|
|
|
|
let fields = yield backend.getMeasurementDailyDiscreteValuesFromMeasurementID(mID);
|
|
do_check_eq(fields.size, 2);
|
|
do_check_true(fields.has("numeric"));
|
|
do_check_true(fields.has("text"));
|
|
|
|
let numeric = fields.get("numeric");
|
|
let text = fields.get("text");
|
|
do_check_true(numeric.hasDay(now));
|
|
do_check_true(text.hasDay(now));
|
|
do_check_eq(numeric.getDay(now).length, expectedNumeric.length);
|
|
do_check_eq(text.getDay(now).length, expectedText.length);
|
|
|
|
for (let i = 0; i < expectedNumeric.length; i++) {
|
|
do_check_eq(numeric.getDay(now)[i], expectedNumeric[i]);
|
|
}
|
|
|
|
for (let i = 0; i < expectedText.length; i++) {
|
|
do_check_eq(text.getDay(now)[i], expectedText[i]);
|
|
}
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_discrete_values_multiple_days() {
|
|
let backend = yield Metrics.Storage("discrete_values_multiple_days");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
let id = yield backend.registerField(mID, "baz",
|
|
backend.FIELD_DAILY_DISCRETE_NUMERIC);
|
|
|
|
let now = new Date();
|
|
let dates = [];
|
|
for (let i = 0; i < 50; i++) {
|
|
let date = new Date(now.getTime() + i * MILLISECONDS_PER_DAY);
|
|
dates.push(date);
|
|
|
|
yield backend.addDailyDiscreteNumericFromFieldID(id, i, date);
|
|
}
|
|
|
|
let values = yield backend.getDailyDiscreteNumericFromFieldID(id);
|
|
do_check_eq(values.size, 50);
|
|
|
|
let i = 0;
|
|
for (let date of dates) {
|
|
do_check_true(values.hasDay(date));
|
|
do_check_eq(values.getDay(date)[0], i);
|
|
i++;
|
|
}
|
|
|
|
let fields = yield backend.getMeasurementDailyDiscreteValuesFromMeasurementID(mID);
|
|
do_check_eq(fields.size, 1);
|
|
do_check_true(fields.has("baz"));
|
|
let baz = fields.get("baz");
|
|
do_check_eq(baz.size, 50);
|
|
i = 0;
|
|
for (let date of dates) {
|
|
do_check_true(baz.hasDay(date));
|
|
do_check_eq(baz.getDay(date).length, 1);
|
|
do_check_eq(baz.getDay(date)[0], i);
|
|
i++;
|
|
}
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_daily_last_values() {
|
|
let backend = yield Metrics.Storage("daily_last_values");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
let numericID = yield backend.registerField(mID, "numeric",
|
|
backend.FIELD_DAILY_LAST_NUMERIC);
|
|
let textID = yield backend.registerField(mID, "text",
|
|
backend.FIELD_DAILY_LAST_TEXT);
|
|
|
|
let now = new Date();
|
|
let yesterday = new Date(now.getTime() - MILLISECONDS_PER_DAY);
|
|
let dayBefore = new Date(yesterday.getTime() - MILLISECONDS_PER_DAY);
|
|
|
|
yield backend.setDailyLastNumericFromFieldID(numericID, 1, yesterday);
|
|
yield backend.setDailyLastNumericFromFieldID(numericID, 2, now);
|
|
yield backend.setDailyLastNumericFromFieldID(numericID, 3, dayBefore);
|
|
yield backend.setDailyLastTextFromFieldID(textID, "foo", now);
|
|
yield backend.setDailyLastTextFromFieldID(textID, "bar", yesterday);
|
|
yield backend.setDailyLastTextFromFieldID(textID, "baz", dayBefore);
|
|
|
|
let days = yield backend.getDailyLastNumericFromFieldID(numericID);
|
|
do_check_eq(days.size, 3);
|
|
do_check_eq(days.getDay(yesterday), 1);
|
|
do_check_eq(days.getDay(now), 2);
|
|
do_check_eq(days.getDay(dayBefore), 3);
|
|
|
|
days = yield backend.getDailyLastTextFromFieldID(textID);
|
|
do_check_eq(days.size, 3);
|
|
do_check_eq(days.getDay(now), "foo");
|
|
do_check_eq(days.getDay(yesterday), "bar");
|
|
do_check_eq(days.getDay(dayBefore), "baz");
|
|
|
|
yield backend.setDailyLastNumericFromFieldID(numericID, 4, yesterday);
|
|
days = yield backend.getDailyLastNumericFromFieldID(numericID);
|
|
do_check_eq(days.getDay(yesterday), 4);
|
|
|
|
yield backend.setDailyLastTextFromFieldID(textID, "biz", yesterday);
|
|
days = yield backend.getDailyLastTextFromFieldID(textID);
|
|
do_check_eq(days.getDay(yesterday), "biz");
|
|
|
|
days = yield backend.getDailyLastNumericFromFieldID(numericID, yesterday);
|
|
do_check_eq(days.size, 1);
|
|
do_check_eq(days.getDay(yesterday), 4);
|
|
|
|
days = yield backend.getDailyLastTextFromFieldID(textID, yesterday);
|
|
do_check_eq(days.size, 1);
|
|
do_check_eq(days.getDay(yesterday), "biz");
|
|
|
|
let fields = yield backend.getMeasurementDailyLastValuesFromMeasurementID(mID);
|
|
do_check_eq(fields.size, 2);
|
|
do_check_true(fields.has("numeric"));
|
|
do_check_true(fields.has("text"));
|
|
let numeric = fields.get("numeric");
|
|
let text = fields.get("text");
|
|
do_check_true(numeric.hasDay(yesterday));
|
|
do_check_true(numeric.hasDay(dayBefore));
|
|
do_check_true(numeric.hasDay(now));
|
|
do_check_true(text.hasDay(yesterday));
|
|
do_check_true(text.hasDay(dayBefore));
|
|
do_check_true(text.hasDay(now));
|
|
do_check_eq(numeric.getDay(yesterday), 4);
|
|
do_check_eq(text.getDay(yesterday), "biz");
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_prune_data_before() {
|
|
let backend = yield Metrics.Storage("prune_data_before");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
|
|
let counterID = yield backend.registerField(mID, "baz",
|
|
backend.FIELD_DAILY_COUNTER);
|
|
let text1ID = yield backend.registerField(mID, "one_text_1",
|
|
backend.FIELD_LAST_TEXT);
|
|
let text2ID = yield backend.registerField(mID, "one_text_2",
|
|
backend.FIELD_LAST_TEXT);
|
|
let numeric1ID = yield backend.registerField(mID, "one_numeric_1",
|
|
backend.FIELD_LAST_NUMERIC);
|
|
let numeric2ID = yield backend.registerField(mID, "one_numeric_2",
|
|
backend.FIELD_LAST_NUMERIC);
|
|
let text3ID = yield backend.registerField(mID, "daily_last_text_1",
|
|
backend.FIELD_DAILY_LAST_TEXT);
|
|
let text4ID = yield backend.registerField(mID, "daily_last_text_2",
|
|
backend.FIELD_DAILY_LAST_TEXT);
|
|
let numeric3ID = yield backend.registerField(mID, "daily_last_numeric_1",
|
|
backend.FIELD_DAILY_LAST_NUMERIC);
|
|
let numeric4ID = yield backend.registerField(mID, "daily_last_numeric_2",
|
|
backend.FIELD_DAILY_LAST_NUMERIC);
|
|
|
|
let now = new Date();
|
|
let yesterday = new Date(now.getTime() - MILLISECONDS_PER_DAY);
|
|
let dayBefore = new Date(yesterday.getTime() - MILLISECONDS_PER_DAY);
|
|
|
|
yield backend.incrementDailyCounterFromFieldID(counterID, now);
|
|
yield backend.incrementDailyCounterFromFieldID(counterID, yesterday);
|
|
yield backend.incrementDailyCounterFromFieldID(counterID, dayBefore);
|
|
yield backend.setLastTextFromFieldID(text1ID, "hello", dayBefore);
|
|
yield backend.setLastTextFromFieldID(text2ID, "world", yesterday);
|
|
yield backend.setLastNumericFromFieldID(numeric1ID, 42, dayBefore);
|
|
yield backend.setLastNumericFromFieldID(numeric2ID, 43, yesterday);
|
|
yield backend.setDailyLastTextFromFieldID(text3ID, "foo", dayBefore);
|
|
yield backend.setDailyLastTextFromFieldID(text3ID, "bar", yesterday);
|
|
yield backend.setDailyLastTextFromFieldID(text4ID, "hello", dayBefore);
|
|
yield backend.setDailyLastTextFromFieldID(text4ID, "world", yesterday);
|
|
yield backend.setDailyLastNumericFromFieldID(numeric3ID, 40, dayBefore);
|
|
yield backend.setDailyLastNumericFromFieldID(numeric3ID, 41, yesterday);
|
|
yield backend.setDailyLastNumericFromFieldID(numeric4ID, 42, dayBefore);
|
|
yield backend.setDailyLastNumericFromFieldID(numeric4ID, 43, yesterday);
|
|
|
|
let days = yield backend.getDailyCounterCountsFromFieldID(counterID);
|
|
do_check_eq(days.size, 3);
|
|
|
|
yield backend.pruneDataBefore(yesterday);
|
|
days = yield backend.getDailyCounterCountsFromFieldID(counterID);
|
|
do_check_eq(days.size, 2);
|
|
do_check_false(days.hasDay(dayBefore));
|
|
|
|
do_check_null(yield backend.getLastTextFromFieldID(text1ID));
|
|
do_check_null(yield backend.getLastNumericFromFieldID(numeric1ID));
|
|
|
|
let result = yield backend.getLastTextFromFieldID(text2ID);
|
|
do_check_true(Array.isArray(result));
|
|
do_check_eq(result[1], "world");
|
|
|
|
result = yield backend.getLastNumericFromFieldID(numeric2ID);
|
|
do_check_true(Array.isArray(result));
|
|
do_check_eq(result[1], 43);
|
|
|
|
result = yield backend.getDailyLastNumericFromFieldID(numeric3ID);
|
|
do_check_eq(result.size, 1);
|
|
do_check_true(result.hasDay(yesterday));
|
|
|
|
result = yield backend.getDailyLastTextFromFieldID(text3ID);
|
|
do_check_eq(result.size, 1);
|
|
do_check_true(result.hasDay(yesterday));
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_provider_state() {
|
|
let backend = yield Metrics.Storage("provider_state");
|
|
|
|
yield backend.registerMeasurement("foo", "bar", 1);
|
|
yield backend.setProviderState("foo", "apple", "orange");
|
|
let value = yield backend.getProviderState("foo", "apple");
|
|
do_check_eq(value, "orange");
|
|
|
|
yield backend.setProviderState("foo", "apple", "pear");
|
|
value = yield backend.getProviderState("foo", "apple");
|
|
do_check_eq(value, "pear");
|
|
|
|
yield backend.close();
|
|
});
|
|
|
|
add_task(function test_get_measurement_values() {
|
|
let backend = yield Metrics.Storage("get_measurement_values");
|
|
|
|
let mID = yield backend.registerMeasurement("foo", "bar", 1);
|
|
let id1 = yield backend.registerField(mID, "id1", backend.FIELD_DAILY_COUNTER);
|
|
let id2 = yield backend.registerField(mID, "id2", backend.FIELD_DAILY_DISCRETE_NUMERIC);
|
|
let id3 = yield backend.registerField(mID, "id3", backend.FIELD_DAILY_DISCRETE_TEXT);
|
|
let id4 = yield backend.registerField(mID, "id4", backend.FIELD_DAILY_LAST_NUMERIC);
|
|
let id5 = yield backend.registerField(mID, "id5", backend.FIELD_DAILY_LAST_TEXT);
|
|
let id6 = yield backend.registerField(mID, "id6", backend.FIELD_LAST_NUMERIC);
|
|
let id7 = yield backend.registerField(mID, "id7", backend.FIELD_LAST_TEXT);
|
|
|
|
let now = new Date();
|
|
let yesterday = new Date(now.getTime() - MILLISECONDS_PER_DAY);
|
|
|
|
yield backend.incrementDailyCounterFromFieldID(id1, now);
|
|
yield backend.addDailyDiscreteNumericFromFieldID(id2, 3, now);
|
|
yield backend.addDailyDiscreteNumericFromFieldID(id2, 4, now);
|
|
yield backend.addDailyDiscreteNumericFromFieldID(id2, 5, yesterday);
|
|
yield backend.addDailyDiscreteNumericFromFieldID(id2, 6, yesterday);
|
|
yield backend.addDailyDiscreteTextFromFieldID(id3, "1", now);
|
|
yield backend.addDailyDiscreteTextFromFieldID(id3, "2", now);
|
|
yield backend.addDailyDiscreteTextFromFieldID(id3, "3", yesterday);
|
|
yield backend.addDailyDiscreteTextFromFieldID(id3, "4", yesterday);
|
|
yield backend.setDailyLastNumericFromFieldID(id4, 1, now);
|
|
yield backend.setDailyLastNumericFromFieldID(id4, 2, yesterday);
|
|
yield backend.setDailyLastTextFromFieldID(id5, "foo", now);
|
|
yield backend.setDailyLastTextFromFieldID(id5, "bar", yesterday);
|
|
yield backend.setLastNumericFromFieldID(id6, 42, now);
|
|
yield backend.setLastTextFromFieldID(id7, "foo", now);
|
|
|
|
let fields = yield backend.getMeasurementValues(mID);
|
|
do_check_eq(Object.keys(fields).length, 2);
|
|
do_check_true("days" in fields);
|
|
do_check_true("singular" in fields);
|
|
do_check_eq(fields.days.size, 2);
|
|
do_check_true(fields.days.hasDay(now));
|
|
do_check_true(fields.days.hasDay(yesterday));
|
|
do_check_eq(fields.days.getDay(now).size, 5);
|
|
do_check_eq(fields.days.getDay(yesterday).size, 4);
|
|
do_check_eq(fields.days.getDay(now).get("id3")[0], 1);
|
|
do_check_eq(fields.days.getDay(yesterday).get("id4"), 2);
|
|
do_check_eq(fields.singular.size, 2);
|
|
do_check_eq(fields.singular.get("id6")[1], 42);
|
|
do_check_eq(fields.singular.get("id7")[1], "foo");
|
|
|
|
yield backend.close();
|
|
});
|
|
|