/* Any copyright is dedicated to the Public Domain.
http://creativecommons.org/publicdomain/zero/1.0/ */
const { Kinto } = ChromeUtils.importESModule(
"resource://services-common/kinto-offline-client.sys.mjs"
);
const { FirefoxAdapter } = ChromeUtils.importESModule(
"resource://services-common/kinto-storage-adapter.sys.mjs"
);
var server;
// set up what we need to make storage adapters
const kintoFilename =
"kinto.sqlite";
function do_get_kinto_sqliteHandle() {
return FirefoxAdapter.openConnection({ path: kintoFilename });
}
function do_get_kinto_collection(sqliteHandle, collection =
"test_collection") {
let config = {
remote: `http:
//localhost:${server.identity.primaryPort}/v1/`,
headers: { Authorization:
"Basic " + btoa(
"user:pass") },
adapter: FirefoxAdapter,
adapterOptions: { sqliteHandle },
};
return new Kinto(config).collection(collection);
}
async
function clear_collection() {
let sqliteHandle;
try {
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection = do_get_kinto_collection(sqliteHandle);
await collection.clear();
}
finally {
await sqliteHandle.close();
}
}
// test some operations on a local collection
add_task(async
function test_kinto_add_get() {
let sqliteHandle;
try {
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection = do_get_kinto_collection(sqliteHandle);
let newRecord = { foo:
"bar" };
// check a record is created
let createResult = await collection.create(newRecord);
Assert.equal(createResult.data.foo, newRecord.foo);
// check getting the record gets the same info
let getResult = await collection.get(createResult.data.id);
deepEqual(createResult.data, getResult.data);
// check what happens if we create the same item again (it should throw
// since you can't create with id)
try {
await collection.create(createResult.data);
do_throw(
"Creation of a record with an id should fail");
}
catch (err) {}
// try a few creates without waiting for the first few to resolve
let promises = [];
promises.push(collection.create(newRecord));
promises.push(collection.create(newRecord));
promises.push(collection.create(newRecord));
await collection.create(newRecord);
await Promise.all(promises);
}
finally {
await sqliteHandle.close();
}
});
add_task(clear_collection);
// test some operations on multiple connections
add_task(async
function test_kinto_add_get() {
let sqliteHandle;
try {
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection1 = do_get_kinto_collection(sqliteHandle);
const collection2 = do_get_kinto_collection(
sqliteHandle,
"test_collection_2"
);
let newRecord = { foo:
"bar" };
// perform several write operations alternately without waiting for promises
// to resolve
let promises = [];
for (let i = 0; i < 10; i++) {
promises.push(collection1.create(newRecord));
promises.push(collection2.create(newRecord));
}
// ensure subsequent operations still work
await Promise.all([
collection1.create(newRecord),
collection2.create(newRecord),
]);
await Promise.all(promises);
}
finally {
await sqliteHandle.close();
}
});
add_task(clear_collection);
add_task(async
function test_kinto_update() {
let sqliteHandle;
try {
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection = do_get_kinto_collection(sqliteHandle);
const newRecord = { foo:
"bar" };
// check a record is created
let createResult = await collection.create(newRecord);
Assert.equal(createResult.data.foo, newRecord.foo);
Assert.equal(createResult.data._status,
"created");
// check we can update this OK
let copiedRecord = Object.assign(createResult.data, {});
deepEqual(createResult.data, copiedRecord);
copiedRecord.foo =
"wibble";
let updateResult = await collection.update(copiedRecord);
// check the field was updated
Assert.equal(updateResult.data.foo, copiedRecord.foo);
// check the status is still "created", since we haven't synced
// the record
Assert.equal(updateResult.data._status,
"created");
}
finally {
await sqliteHandle.close();
}
});
add_task(clear_collection);
add_task(async
function test_kinto_clear() {
let sqliteHandle;
try {
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection = do_get_kinto_collection(sqliteHandle);
// create an expected number of records
const expected = 10;
const newRecord = { foo:
"bar" };
for (let i = 0; i < expected; i++) {
await collection.create(newRecord);
}
// check the collection contains the correct number
let list = await collection.list();
Assert.equal(list.data.length, expected);
// clear the collection and check again - should be 0
await collection.clear();
list = await collection.list();
Assert.equal(list.data.length, 0);
}
finally {
await sqliteHandle.close();
}
});
add_task(clear_collection);
add_task(async
function test_kinto_delete() {
let sqliteHandle;
try {
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection = do_get_kinto_collection(sqliteHandle);
const newRecord = { foo:
"bar" };
// check a record is created
let createResult = await collection.create(newRecord);
Assert.equal(createResult.data.foo, newRecord.foo);
// check getting the record gets the same info
let getResult = await collection.get(createResult.data.id);
deepEqual(createResult.data, getResult.data);
// delete that record
let deleteResult = await collection.
delete(createResult.data.id);
// check the ID is set on the result
Assert.equal(getResult.data.id, deleteResult.data.id);
// and check that get no longer returns the record
try {
getResult = await collection.get(createResult.data.id);
do_throw(
"there should not be a result");
}
catch (e) {}
}
finally {
await sqliteHandle.close();
}
});
add_task(async
function test_kinto_list() {
let sqliteHandle;
try {
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection = do_get_kinto_collection(sqliteHandle);
const expected = 10;
const created = [];
for (let i = 0; i < expected; i++) {
let newRecord = { foo:
"test " + i };
let createResult = await collection.create(newRecord);
created.push(createResult.data);
}
// check the collection contains the correct number
let list = await collection.list();
Assert.equal(list.data.length, expected);
// check that all created records exist in the retrieved list
for (let createdRecord of created) {
let found =
false;
for (let retrievedRecord of list.data) {
if (createdRecord.id == retrievedRecord.id) {
deepEqual(createdRecord, retrievedRecord);
found =
true;
}
}
Assert.ok(found);
}
}
finally {
await sqliteHandle.close();
}
});
add_task(clear_collection);
add_task(async
function test_importBulk_ignores_already_imported_records() {
let sqliteHandle;
try {
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection = do_get_kinto_collection(sqliteHandle);
const record = {
id:
"41b71c13-17e9-4ee3-9268-6a41abf9730f",
title:
"foo",
last_modified: 1457896541,
};
await collection.importBulk([record]);
let impactedRecords = await collection.importBulk([record]);
Assert.equal(impactedRecords.length, 0);
}
finally {
await sqliteHandle.close();
}
});
add_task(clear_collection);
add_task(async
function test_loadDump_should_overwrite_old_records() {
let sqliteHandle;
try {
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection = do_get_kinto_collection(sqliteHandle);
const record = {
id:
"41b71c13-17e9-4ee3-9268-6a41abf9730f",
title:
"foo",
last_modified: 1457896541,
};
await collection.loadDump([record]);
const updated = Object.assign({}, record, { last_modified: 1457896543 });
let impactedRecords = await collection.loadDump([updated]);
Assert.equal(impactedRecords.length, 1);
}
finally {
await sqliteHandle.close();
}
});
add_task(clear_collection);
add_task(async
function test_loadDump_should_not_overwrite_unsynced_records() {
let sqliteHandle;
try {
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection = do_get_kinto_collection(sqliteHandle);
const recordId =
"41b71c13-17e9-4ee3-9268-6a41abf9730f";
await collection.create(
{ id: recordId, title:
"foo" },
{ useRecordId:
true }
);
const record = { id: recordId, title:
"bar", last_modified: 1457896541 };
let impactedRecords = await collection.loadDump([record]);
Assert.equal(impactedRecords.length, 0);
}
finally {
await sqliteHandle.close();
}
});
add_task(clear_collection);
add_task(
async
function test_loadDump_should_not_overwrite_records_without_last_modified() {
let sqliteHandle;
try {
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection = do_get_kinto_collection(sqliteHandle);
const recordId =
"41b71c13-17e9-4ee3-9268-6a41abf9730f";
await collection.create({ id: recordId, title:
"foo" }, { synced:
true });
const record = { id: recordId, title:
"bar", last_modified: 1457896541 };
let impactedRecords = await collection.loadDump([record]);
Assert.equal(impactedRecords.length, 0);
}
finally {
await sqliteHandle.close();
}
}
);
add_task(clear_collection);
// Now do some sanity checks against a server - we're not looking to test
// core kinto.js functionality here (there is excellent test coverage in
// kinto.js), more making sure things are basically working as expected.
add_task(async
function test_kinto_sync() {
const configPath =
"/v1/";
const metadataPath =
"/v1/buckets/default/collections/test_collection";
const recordsPath =
"/v1/buckets/default/collections/test_collection/records";
// register a handler
function handleResponse(request, response) {
try {
const sampled = getSampleResponse(request, server.identity.primaryPort);
if (!sampled) {
do_throw(
`unexpected ${request.method} request
for ${request.path}?${request.queryString}`
);
}
response.setStatusLine(
null,
sampled.status.status,
sampled.status.statusText
);
// send the headers
for (let headerLine of sampled.sampleHeaders) {
let headerElements = headerLine.split(
":");
response.setHeader(headerElements[0], headerElements[1].trimLeft());
}
response.setHeader(
"Date",
new Date().toUTCString());
response.write(sampled.responseBody);
}
catch (e) {
dump(`${e}\n`);
}
}
server.registerPathHandler(configPath, handleResponse);
server.registerPathHandler(metadataPath, handleResponse);
server.registerPathHandler(recordsPath, handleResponse);
// create an empty collection, sync to populate
let sqliteHandle;
try {
let result;
sqliteHandle = await do_get_kinto_sqliteHandle();
const collection = do_get_kinto_collection(sqliteHandle);
result = await collection.sync();
Assert.ok(result.ok);
// our test data has a single record; it should be in the local collection
let list = await collection.list();
Assert.equal(list.data.length, 1);
// now sync again; we should now have 2 records
result = await collection.sync();
Assert.ok(result.ok);
list = await collection.list();
Assert.equal(list.data.length, 2);
// sync again; the second records should have been modified
const before = list.data[0].title;
result = await collection.sync();
Assert.ok(result.ok);
list = await collection.list();
const after = list.data[1].title;
Assert.notEqual(before, after);
const manualID = list.data[0].id;
Assert.equal(list.data.length, 3);
Assert.equal(manualID,
"some-manually-chosen-id");
}
finally {
await sqliteHandle.close();
}
});
function run_test() {
// Set up an HTTP Server
server =
new HttpServer();
server.start(-1);
run_next_test();
registerCleanupFunction(
function () {
server.stop(
function () {});
});
}
// get a response for a given request from sample data
function getSampleResponse(req, port) {
const responses = {
OPTIONS: {
sampleHeaders: [
"Access-Control-Allow-Headers: Content-Length,Expires,Backoff,Retry-After,Last-Modified,Total-Records,ETag,Pragma,Cache-Control,authorization,content-type,if-none-match,Alert,Next-Page",
"Access-Control-Allow-Methods: GET,HEAD,OPTIONS,POST,DELETE,OPTIONS",
"Access-Control-Allow-Origin: *",
"Content-Type: application/json; charset=UTF-8",
"Server: waitress",
],
status: { status: 200, statusText:
"OK" },
responseBody:
"null",
},
"GET:/v1/?": {
sampleHeaders: [
"Access-Control-Allow-Origin: *",
"Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
"Content-Type: application/json; charset=UTF-8",
"Server: waitress",
],
status: { status: 200, statusText:
"OK" },
responseBody: JSON.stringify({
settings: {
batch_max_requests: 25,
},
url: `http:
//localhost:${port}/v1/`,
documentation:
"https://kinto.readthedocs.org/",
version:
"1.5.1",
commit:
"cbc6f58",
hello:
"kinto",
}),
},
"GET:/v1/buckets/default/collections/test_collection": {
sampleHeaders: [
"Access-Control-Allow-Origin: *",
"Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
"Content-Type: application/json; charset=UTF-8",
"Server: waitress",
'Etag: "1234"',
],
status: { status: 200, statusText:
"OK" },
responseBody: JSON.stringify({
data: {
id:
"test_collection",
last_modified: 1234,
},
}),
},
"GET:/v1/buckets/default/collections/test_collection/records?_sort=-last_modified":
{
sampleHeaders: [
"Access-Control-Allow-Origin: *",
"Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
"Content-Type: application/json; charset=UTF-8",
"Server: waitress",
'Etag: "1445606341071"',
],
status: { status: 200, statusText:
"OK" },
responseBody: JSON.stringify({
data: [
{
last_modified: 1445606341071,
done:
false,
id:
"68db8313-686e-4fff-835e-07d78ad6f2af",
title:
"New test",
},
],
}),
},
"GET:/v1/buckets/default/collections/test_collection/records?_sort=-last_modified&_since=1445606341071":
{
sampleHeaders: [
"Access-Control-Allow-Origin: *",
"Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
"Content-Type: application/json; charset=UTF-8",
"Server: waitress",
'Etag: "1445607941223"',
],
status: { status: 200, statusText:
"OK" },
responseBody: JSON.stringify({
data: [
{
last_modified: 1445607941223,
done:
false,
id:
"901967b0-f729-4b30-8d8d-499cba7f4b1d",
title:
"Another new test",
},
],
}),
},
"GET:/v1/buckets/default/collections/test_collection/records?_sort=-last_modified&_since=1445607941223":
{
sampleHeaders: [
"Access-Control-Allow-Origin: *",
"Access-Control-Expose-Headers: Retry-After, Content-Length, Alert, Backoff",
"Content-Type: application/json; charset=UTF-8",
"Server: waitress",
'Etag: "1445607541267"',
],
status: { status: 200, statusText:
"OK" },
responseBody: JSON.stringify({
data: [
{
last_modified: 1445607541265,
done:
false,
id:
"901967b0-f729-4b30-8d8d-499cba7f4b1d",
title:
"Modified title",
},
{
last_modified: 1445607541267,
done:
true,
id:
"some-manually-chosen-id",
title:
"New record with custom ID",
},
],
}),
},
};
return (
responses[`${req.method}:${req.path}?${req.queryString}`] ||
responses[`${req.method}:${req.path}`] ||
responses[req.method]
);
}
