Source code
Revision control
Copy as Markdown
Other Tools
/**
* Tests the JSONFile object.
*/
"use strict";
// Globals
ChromeUtils.defineESModuleGetters(this, {
AsyncShutdown: "resource://gre/modules/AsyncShutdown.sys.mjs",
JSONFile: "resource://gre/modules/JSONFile.sys.mjs",
});
/**
* Returns a reference to a temporary file that is guaranteed not to exist and
* is cleaned up later. See FileTestUtils.getTempFile for details.
*/
function getTempFile(leafName) {
return FileTestUtils.getTempFile(leafName);
}
const TEST_STORE_FILE_NAME = "test-store.json";
const TEST_DATA = {
number: 123,
string: "test",
object: {
prop1: 1,
prop2: 2,
},
};
add_setup(
{ skip_if: () => AppConstants.platform == "android" },
function test_setup() {
// We need to initialize it once, otherwise operations will be stuck in the pre-init queue.
Services.fog.initializeFOG();
}
);
// Tests
add_task(async function test_save_reload() {
let storeForSave = new JSONFile({
path: getTempFile(TEST_STORE_FILE_NAME).path,
});
await storeForSave.load();
Assert.ok(storeForSave.dataReady);
Assert.deepEqual(storeForSave.data, {});
Object.assign(storeForSave.data, TEST_DATA);
await new Promise(resolve => {
let save = storeForSave._save.bind(storeForSave);
storeForSave._save = () => {
save();
resolve();
};
storeForSave.saveSoon();
});
let storeForLoad = new JSONFile({
path: storeForSave.path,
});
await storeForLoad.load();
Assert.deepEqual(storeForLoad.data, TEST_DATA);
});
add_task(async function test_load_sync() {
let storeForSave = new JSONFile({
path: getTempFile(TEST_STORE_FILE_NAME).path,
});
await storeForSave.load();
Object.assign(storeForSave.data, TEST_DATA);
await storeForSave._save();
let storeForLoad = new JSONFile({
path: storeForSave.path,
});
storeForLoad.ensureDataReady();
Assert.deepEqual(storeForLoad.data, TEST_DATA);
});
add_task(async function test_load_with_dataPostProcessor() {
let storeForSave = new JSONFile({
path: getTempFile(TEST_STORE_FILE_NAME).path,
});
await storeForSave.load();
Object.assign(storeForSave.data, TEST_DATA);
await storeForSave._save();
let random = Math.random();
let storeForLoad = new JSONFile({
path: storeForSave.path,
dataPostProcessor: data => {
Assert.deepEqual(data, TEST_DATA);
data.test = random;
return data;
},
});
await storeForLoad.load();
Assert.equal(storeForLoad.data.test, random);
});
add_task(async function test_load_with_dataPostProcessor_fails() {
let store = new JSONFile({
path: getTempFile(TEST_STORE_FILE_NAME).path,
dataPostProcessor: () => {
throw new Error("dataPostProcessor fails.");
},
});
await Assert.rejects(store.load(), /dataPostProcessor fails\./);
Assert.ok(!store.dataReady);
});
add_task(async function test_load_sync_with_dataPostProcessor_fails() {
let store = new JSONFile({
path: getTempFile(TEST_STORE_FILE_NAME).path,
dataPostProcessor: () => {
throw new Error("dataPostProcessor fails.");
},
});
Assert.throws(() => store.ensureDataReady(), /dataPostProcessor fails\./);
Assert.ok(!store.dataReady);
});
/**
* Loads data from a string in a predefined format. The purpose of this test is
* to verify that the JSON format used in previous versions can be loaded.
*/
add_task(async function test_load_string_predefined() {
let store = new JSONFile({
path: getTempFile(TEST_STORE_FILE_NAME).path,
});
let string = '{"number":123,"string":"test","object":{"prop1":1,"prop2":2}}';
await IOUtils.writeUTF8(store.path, string, {
tmpPath: store.path + ".tmp",
});
await store.load();
Assert.deepEqual(store.data, TEST_DATA);
});
/**
* Loads data from a malformed JSON string.
*/
add_task(async function test_load_string_malformed() {
let store = new JSONFile({
path: getTempFile(TEST_STORE_FILE_NAME).path,
});
let string = '{"number":123,"string":"test","object":{"prop1":1,';
await IOUtils.writeUTF8(store.path, string, {
tmpPath: store.path + ".tmp",
});
await store.load();
// A backup file should have been created.
Assert.ok(await IOUtils.exists(store.path + ".corrupt"));
await IOUtils.remove(store.path + ".corrupt");
// The store should be ready to accept new data.
Assert.ok(store.dataReady);
Assert.deepEqual(store.data, {});
});
/**
* Loads data from a malformed JSON string, using the synchronous initialization
* path.
*/
add_task(async function test_load_string_malformed_sync() {
let store = new JSONFile({
path: getTempFile(TEST_STORE_FILE_NAME).path,
});
let string = '{"number":123,"string":"test","object":{"prop1":1,';
await IOUtils.writeUTF8(store.path, string, {
tmpPath: store.path + ".tmp",
});
store.ensureDataReady();
// A backup file should have been created.
Assert.ok(await IOUtils.exists(store.path + ".corrupt"));
await IOUtils.remove(store.path + ".corrupt");
// The store should be ready to accept new data.
Assert.ok(store.dataReady);
Assert.deepEqual(store.data, {});
});
add_task(async function test_overwrite_data() {
let storeForSave = new JSONFile({
path: getTempFile(TEST_STORE_FILE_NAME).path,
});
let string = `{"number":456,"string":"tset","object":{"prop1":3,"prop2":4}}`;
await IOUtils.writeUTF8(storeForSave.path, string, {
tmpPath: storeForSave.path + ".tmp",
});
Assert.ok(!storeForSave.dataReady);
storeForSave.data = TEST_DATA;
Assert.ok(storeForSave.dataReady);
Assert.equal(storeForSave.data, TEST_DATA);
await new Promise(resolve => {
let save = storeForSave._save.bind(storeForSave);
storeForSave._save = () => {
save();
resolve();
};
storeForSave.saveSoon();
});
let storeForLoad = new JSONFile({
path: storeForSave.path,
});
await storeForLoad.load();
Assert.deepEqual(storeForLoad.data, TEST_DATA);
});
add_task(async function test_beforeSave() {
let store;
let promiseBeforeSave = new Promise(resolve => {
store = new JSONFile({
path: getTempFile(TEST_STORE_FILE_NAME).path,
beforeSave: resolve,
saveDelayMs: 250,
});
});
store.saveSoon();
await promiseBeforeSave;
});
add_task(async function test_beforeSave_rejects() {
let storeForSave = new JSONFile({
path: getTempFile(TEST_STORE_FILE_NAME).path,
beforeSave() {
return Promise.reject(new Error("oops"));
},
saveDelayMs: 250,
});
let promiseSave = new Promise((resolve, reject) => {
let save = storeForSave._save.bind(storeForSave);
storeForSave._save = () => {
save().then(resolve, reject);
};
storeForSave.saveSoon();
});
await Assert.rejects(promiseSave, function (ex) {
return ex.message == "oops";
});
});
add_task(async function test_finalize() {
let path = getTempFile(TEST_STORE_FILE_NAME).path;
let barrier = new AsyncShutdown.Barrier("test-auto-finalize");
let storeForSave = new JSONFile({
path,
saveDelayMs: 2000,
finalizeAt: barrier.client,
});
await storeForSave.load();
storeForSave.data = TEST_DATA;
storeForSave.saveSoon();
let promiseFinalize = storeForSave.finalize();
await Assert.rejects(storeForSave.finalize(), /has already been finalized$/);
await promiseFinalize;
Assert.ok(!storeForSave.dataReady);
// Finalization removes the blocker, so waiting should not log an unhandled
// error even though the object has been explicitly finalized.
await barrier.wait();
let storeForLoad = new JSONFile({ path });
await storeForLoad.load();
Assert.deepEqual(storeForLoad.data, TEST_DATA);
});
add_task(async function test_finalize_on_shutdown() {
let path = getTempFile(TEST_STORE_FILE_NAME).path;
let barrier = new AsyncShutdown.Barrier("test-finalize-shutdown");
let storeForSave = new JSONFile({
path,
saveDelayMs: 2000,
finalizeAt: barrier.client,
});
await storeForSave.load();
storeForSave.data = TEST_DATA;
// Arm the saver, then simulate shutdown and ensure the file is
// automatically finalized.
storeForSave.saveSoon();
await barrier.wait();
// It's possible for `finalize` to reject when called concurrently with
// shutdown. We don't distinguish between explicit `finalize` calls and
// finalization on shutdown because we expect most consumers to rely on the
// latter. However, this behavior can be safely changed if needed.
await Assert.rejects(storeForSave.finalize(), /has already been finalized$/);
Assert.ok(!storeForSave.dataReady);
let storeForLoad = new JSONFile({ path });
await storeForLoad.load();
Assert.deepEqual(storeForLoad.data, TEST_DATA);
});
add_task(async function test_save_failure_handler() {
let path = getTempFile(TEST_STORE_FILE_NAME).path;
let saveFailureHandler = sinon.stub();
let storeForSave = new JSONFile({
path,
saveDelayMs: 10,
saveFailureHandler,
});
await storeForSave.load();
// Let's now add some invalid data that we'll fail to save.
let circularThing = {};
circularThing.circle = circularThing;
storeForSave.data = {
circularThing,
};
await storeForSave._save();
Assert.ok(saveFailureHandler.calledOnce, "Failure handler was called");
Assert.ok(
saveFailureHandler.calledWith(
sinon.match(error => {
return error.message == "cyclic object value";
})
),
"Handler was passed Error"
);
});
if (AppConstants.platform != "android") {
add_task(async function test_load_error_telemetry() {
let file = getTempFile("idontexist.json");
let store = new JSONFile({
path: file.path,
sanitizedBasename: "logins",
});
await store.load();
let telemetryData = Glean.jsonfile.loadLogins.testGetValue();
console.log(
"Telemetry data after trying to read file that doesn't exist:",
JSON.stringify(telemetryData)
);
telemetryData = telemetryData?.filter(n =>
n.extra?.value?.startsWith("error")
);
Assert.equal(telemetryData.length, 1, "Telemetry should record one error.");
Assert.equal(
telemetryData[0]?.extra.value,
"error_notfounderror",
"Telemetry should record not found."
);
// Can't easily create a file we can't read on Windows.
if (AppConstants.platform != "win") {
Services.fog.testResetFOG();
store = new JSONFile({
path: file.path,
sanitizedBasename: "logins",
});
file.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o111);
await store.load();
telemetryData = Glean.jsonfile.loadLogins.testGetValue();
console.log(
"Telemetry data after trying to read unreadable file:",
JSON.stringify(telemetryData)
);
telemetryData = telemetryData?.filter(n =>
n.extra?.value?.startsWith("error")
);
Assert.equal(
telemetryData.length,
1,
"Telemetry should record one error."
);
Assert.equal(
telemetryData[0]?.extra.value,
"error_notallowederror",
"Telemetry should record permission denied."
);
Assert.ok(
await IOUtils.exists(store.path + ".corrupt"),
"A backup file should have been created (via move)."
);
await IOUtils.remove(store.path + ".corrupt");
Assert.ok(
!(await IOUtils.exists(store.path)),
"Original file should have been moved."
);
}
});
}