Skip to content

J
jio
Commit 122da4b3 authored by Romain Courteaud's avatar Romain Courteaud
Browse files
Options

Rewrite replicateStorage. 

Synchronisation status is based on document signature (sha) comparison.
Signature are stored each time a document is successfully synchronised.

Conflict are detected but reported as an error for now, as no solve process is implemented.
parent ece651db
Hide whitespace changes
Inline Side-by-side
Showing with 1272 additions and 1615 deletions
Gruntfile.js
View file @ 122da4b3
...@@ -171,6 +171,9 @@ module.exports = function (grunt) { ...@@ -171,6 +171,9 @@ module.exports = function (grunt) {
'src/jio.js', 'src/jio.js',
'node_modules/rusha/rusha.js',
'src/jio.storage/replicatestorage.js',
'src/jio.storage/uuidstorage.js', 'src/jio.storage/uuidstorage.js',
'src/jio.storage/memorystorage.js', 'src/jio.storage/memorystorage.js',
'src/jio.storage/localstorage.js', 'src/jio.storage/localstorage.js',
......
package.json
View file @ 122da4b3
...@@ -31,7 +31,8 @@ ...@@ -31,7 +31,8 @@
"dependencies": { "dependencies": {
"rsvp": "git+http://git.erp5.org/repos/rsvp.js.git", "rsvp": "git+http://git.erp5.org/repos/rsvp.js.git",
"uritemplate": "git+http://git.erp5.org/repos/uritemplate-js.git", "uritemplate": "git+http://git.erp5.org/repos/uritemplate-js.git",
"moment": "2.8.3" "moment": "2.8.3",
"rusha": "0.8.2"
}, },
"devDependencies": { "devDependencies": {
"renderjs": "git+http://git.erp5.org/repos/renderjs.git", "renderjs": "git+http://git.erp5.org/repos/renderjs.git",
......
src/jio.storage/replicatestorage.js
View file @ 122da4b3
/* /*
* JIO extension for resource replication. * JIO extension for resource replication.
* Copyright (C) 2013 Nexedi SA * Copyright (C) 2013, 2015 Nexedi SA
* *
* This library is free software: you can redistribute it and/or modify * This library is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by * it under the terms of the GNU Lesser General Public License as published by
...@@ -16,405 +16,314 @@ ...@@ -16,405 +16,314 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
/*jslint indent: 2, maxlen: 80, nomen: true */ /*jslint nomen: true*/
/*global define, module, require, jIO, RSVP */ /*global jIO, RSVP, Rusha*/
(function (factory) { (function (jIO, RSVP, Rusha) {
"use strict"; "use strict";
if (typeof define === 'function' && define.amd) {
return define(["jio", "rsvp"], function () {
return factory(require);
});
}
if (typeof require === 'function') {
module.exports = factory(require);
return;
}
factory(function (name) {
return {
"jio": jIO,
"rsvp": RSVP
}[name];
});
}(function (require) {
"use strict";
var Promise = require('rsvp').Promise,
all = require('rsvp').all,
addStorageFunction = require('jio').addStorage,
uniqueJSONStringify = require('jio').util.uniqueJSONStringify;
function success(promise) {
return promise.then(null, function (reason) { return reason; });
}
/**
* firstFulfilled(promises): promises< last_fulfilment_value >
*
* Responds with the first resolved promise answer recieved. If all promises
* are rejected, it returns the latest rejected promise answer
* received. Promises are cancelled only by calling
* `firstFulfilled(promises).cancel()`.
*
* @param {Array} promises An array of promises
* @return {Promise} A new promise
*/
function firstFulfilled(promises) {
var length = promises.length;
function onCancel() { var rusha = new Rusha();
var i, l, promise;
for (i = 0, l = promises.length; i < l; i += 1) {
promise = promises[i];
if (typeof promise.cancel === "function") {
promise.cancel();
}
}
}
return new Promise(function (resolve, reject, notify) { /****************************************************
var i, count = 0; Use a local jIO to read/write/search documents
function resolver(answer) { Synchronize in background those document with a remote jIO.
resolve(answer); Synchronization status is stored for each document as an local attachment.
onCancel(); ****************************************************/
}
function rejecter(answer) {
count += 1;
if (count === length) {
return reject(answer);
}
}
for (i = 0; i < length; i += 1) { function generateHash(content) {
promises[i].then(resolver, rejecter, notify); // XXX Improve performance by moving calculation to WebWorker
} return rusha.digestFromString(content);
}, onCancel);
} }
// //////////////////////////////////////////////////////////////////////
// /**
// * An Universal Unique ID generator
// *
// * @return {String} The new UUID.
// */
// function generateUuid() {
// function S4() {
// return ('0000' + Math.floor(
// Math.random() * 0x10000 /* 65536 */
// ).toString(16)).slice(-4);
// }
// return S4() + S4() + "-" +
// S4() + "-" +
// S4() + "-" +
// S4() + "-" +
// S4() + S4() + S4();
// }
function ReplicateStorage(spec) { function ReplicateStorage(spec) {
if (!Array.isArray(spec.storage_list)) { this._local_sub_storage = jIO.createJIO(spec.local_sub_storage);
throw new TypeError("ReplicateStorage(): " + this._remote_sub_storage = jIO.createJIO(spec.remote_sub_storage);
"storage_list is not of type array");
} this._signature_hash = "_replicate_" + generateHash(
this._storage_list = spec.storage_list; JSON.stringify(spec.local_sub_storage) +
JSON.stringify(spec.remote_sub_storage)
);
this._signature_sub_storage = jIO.createJIO({
type: "document",
document_id: this._signature_hash,
sub_storage: spec.local_sub_storage
});
} }
ReplicateStorage.prototype.syncGetAnswerList = function (command, ReplicateStorage.prototype.remove = function (id) {
answer_list) { if (id === this._signature_hash) {
var i, l, answer, answer_modified_date, winner, winner_modified_date, throw new jIO.util.jIOError(this._signature_hash + " is frozen",
winner_str, promise_list = [], winner_index, winner_id; 403);
/*jslint continue: true */
for (i = 0, l = answer_list.length; i < l; i += 1) {
answer = answer_list[i];
if (!answer || answer === 404) { continue; }
if (!winner) {
winner = answer;
winner_index = i;
winner_modified_date = new Date(answer.data.modified).getTime();
} else {
answer_modified_date = new Date(answer.data.modified).getTime();
if (isFinite(answer_modified_date) &&
answer_modified_date > winner_modified_date) {
winner = answer;
winner_index = i;
winner_modified_date = answer_modified_date;
}
}
}
winner = winner.data;
if (!winner) { return; }
// winner_attachments = winner._attachments;
delete winner._attachments;
winner_id = winner._id;
winner_str = uniqueJSONStringify(winner);
// document synchronisation
for (i = 0, l = answer_list.length; i < l; i += 1) {
answer = answer_list[i];
if (!answer) { continue; }
if (i === winner_index) { continue; }
if (answer === 404) {
delete winner._id;
promise_list.push(success(
command.storage(this._storage_list[i]).post(winner)
));
winner._id = winner_id;
// delete _id AND reassign _id -> avoid modifying document before
// resolving the get method.
continue;
}
delete answer._attachments;
if (uniqueJSONStringify(answer.data) !== winner_str) {
promise_list.push(success(
command.storage(this._storage_list[i]).put(winner)
));
}
} }
return all(promise_list); return this._local_sub_storage.remove.apply(this._local_sub_storage,
// XXX .then synchronize attachments arguments);
}; };
ReplicateStorage.prototype.post = function () {
ReplicateStorage.prototype.post = function (command, metadata, option) { return this._local_sub_storage.post.apply(this._local_sub_storage,
var promise_list = [], index, length = this._storage_list.length; arguments);
// if (!isDate(metadata.modified)) {
// command.error(
// 409,
// "invalid 'modified' metadata",
// "The metadata 'modified' should be a valid date string or date object"
// );
// return;
// }
for (index = 0; index < length; index += 1) {
promise_list[index] =
command.storage(this._storage_list[index]).post(metadata, option);
}
firstFulfilled(promise_list).
then(command.success, command.error, command.notify);
}; };
ReplicateStorage.prototype.put = function (id) {
ReplicateStorage.prototype.put = function (command, metadata, option) { if (id === this._signature_hash) {
var promise_list = [], index, length = this._storage_list.length; throw new jIO.util.jIOError(this._signature_hash + " is frozen",
// if (!isDate(metadata.modified)) { 403);
// command.error(
// 409,
// "invalid 'modified' metadata",
// "The metadata 'modified' should be a valid date string or date object"
// );
// return;
// }
for (index = 0; index < length; index += 1) {
promise_list[index] =
command.storage(this._storage_list[index]).put(metadata, option);
} }
firstFulfilled(promise_list). return this._local_sub_storage.put.apply(this._local_sub_storage,
then(command.success, command.error, command.notify); arguments);
}; };
ReplicateStorage.prototype.get = function () {
ReplicateStorage.prototype.putAttachment = function (command, param, option) { return this._local_sub_storage.get.apply(this._local_sub_storage,
var promise_list = [], index, length = this._storage_list.length; arguments);
for (index = 0; index < length; index += 1) {
promise_list[index] =
command.storage(this._storage_list[index]).putAttachment(param, option);
}
firstFulfilled(promise_list).
then(command.success, command.error, command.notify);
}; };
ReplicateStorage.prototype.hasCapacity = function () {
ReplicateStorage.prototype.remove = function (command, param, option) { return this._local_sub_storage.hasCapacity.apply(this._local_sub_storage,
var promise_list = [], index, length = this._storage_list.length; arguments);
for (index = 0; index < length; index += 1) {
promise_list[index] =
command.storage(this._storage_list[index]).remove(param, option);
}
firstFulfilled(promise_list).
then(command.success, command.error, command.notify);
}; };
ReplicateStorage.prototype.buildQuery = function () {
ReplicateStorage.prototype.removeAttachment = function ( // XXX Remove signature document?
command, return this._local_sub_storage.buildQuery.apply(this._local_sub_storage,
param, arguments);
option
) {
var promise_list = [], index, length = this._storage_list.length;
for (index = 0; index < length; index += 1) {
promise_list[index] =
command.storage(this._storage_list[index]).
removeAttachment(param, option);
}
firstFulfilled(promise_list).
then(command.success, command.error, command.notify);
}; };
/** ReplicateStorage.prototype.repair = function () {
* Respond with the first get answer received and synchronize the document to var context = this,
* the other storages in the background. argument_list = arguments,
*/ skip_document_dict = {};
ReplicateStorage.prototype.get = function (command, param, option) {
var promise_list = [], index, length = this._storage_list.length, // Do not sync the signature document
answer_list = [], this_ = this; skip_document_dict[context._signature_hash] = null;
for (index = 0; index < length; index += 1) {
promise_list[index] = function propagateModification(destination, doc, hash, id) {
command.storage(this._storage_list[index]).get(param, option); return destination.put(id, doc)
.push(function () {
return context._signature_sub_storage.put(id, {
"hash": hash
});
})
.push(function () {
skip_document_dict[id] = null;
});
} }
new Promise(function (resolve, reject, notify) { function checkLocalCreation(queue, source, destination, id) {
var count = 0, error_count = 0; var remote_doc;
function resolver(index) { queue
return function (answer) { .push(function () {
count += 1; return destination.get(id);
if (count === 1) { })
resolve(answer); .push(function (doc) {
remote_doc = doc;
}, function (error) {
if ((error instanceof jIO.util.jIOError) &&
(error.status_code === 404)) {
// This document was never synced.
// Push it to the remote storage and store sync information
return;
} }
answer_list[index] = answer; throw error;
if (count + error_count === length && count > 0) { })
this_.syncGetAnswerList(command, answer_list); .push(function () {
// This document was never synced.
// Push it to the remote storage and store sync information
return source.get(id);
})
.push(function (doc) {
var local_hash = generateHash(JSON.stringify(doc)),
remote_hash;
if (remote_doc === undefined) {
return propagateModification(destination, doc, local_hash, id);
} }
};
}
function rejecter(index) { remote_hash = generateHash(JSON.stringify(remote_doc));
return function (reason) { if (local_hash === remote_hash) {
error_count += 1; // Same document
if (reason.status === 404) { return context._signature_sub_storage.put(id, {
answer_list[index] = 404; "hash": local_hash
})
.push(function () {
skip_document_dict[id] = null;
});
} }
if (error_count === length) { // Already exists on destination
reject(reason); throw new jIO.util.jIOError("Conflict on '" + id + "'",
} 409);
if (count + error_count === length && count > 0) { });
this_.syncGetAnswerList(command, answer_list); }
}
};
}
for (index = 0; index < length; index += 1) {
promise_list[index].then(resolver(index), rejecter(index), notify);
}
}, function () {
for (index = 0; index < length; index += 1) {
promise_list[index].cancel();
}
}).then(command.success, command.error, command.notify);
};
ReplicateStorage.prototype.getAttachment = function (command, param, option) { function checkLocalDeletion(queue, destination, id, source) {
var promise_list = [], index, length = this._storage_list.length; var status_hash;
for (index = 0; index < length; index += 1) { queue
promise_list[index] = .push(function () {
command.storage(this._storage_list[index]).getAttachment(param, option); return context._signature_sub_storage.get(id);
})
.push(function (result) {
status_hash = result.hash;
return destination.get(id)
.push(function (doc) {
var remote_hash = generateHash(JSON.stringify(doc));
if (remote_hash === status_hash) {
return destination.remove(id)
.push(function () {
return context._signature_sub_storage.remove(id);
})
.push(function () {
skip_document_dict[id] = null;
});
}
// Modifications on remote side
// Push them locally
return propagateModification(source, doc, remote_hash, id);
}, function (error) {
if ((error instanceof jIO.util.jIOError) &&
(error.status_code === 404)) {
return context._signature_sub_storage.remove(id)
.push(function () {
skip_document_dict[id] = null;
});
}
throw error;
});
});
} }
firstFulfilled(promise_list).
then(command.success, command.error, command.notify);
};
ReplicateStorage.prototype.allDocs = function (command, param, option) { function checkSignatureDifference(queue, source, destination, id) {
var promise_list = [], index, length = this._storage_list.length; queue
for (index = 0; index < length; index += 1) { .push(function () {
promise_list[index] = return RSVP.all([
success(command.storage(this._storage_list[index]).allDocs(option)); source.get(id),
context._signature_sub_storage.get(id)
]);
})
.push(function (result_list) {
var doc = result_list[0],
local_hash = generateHash(JSON.stringify(doc)),
status_hash = result_list[1].hash;
if (local_hash !== status_hash) {
// Local modifications
return destination.get(id)
.push(function (remote_doc) {
var remote_hash = generateHash(JSON.stringify(remote_doc));
if (remote_hash !== status_hash) {
// Modifications on both sides
if (local_hash === remote_hash) {
// Same modifications on both side \o/
return context._signature_sub_storage.put(id, {
"hash": local_hash
})
.push(function () {
skip_document_dict[id] = null;
});
}
throw new jIO.util.jIOError("Conflict on '" + id + "'",
409);
}
return propagateModification(destination, doc, local_hash, id);
}, function (error) {
if ((error instanceof jIO.util.jIOError) &&
(error.status_code === 404)) {
// Document has been deleted remotely
return propagateModification(destination, doc, local_hash,
id);
}
throw error;
});
}
});
} }
all(promise_list).then(function (answers) {
// merge responses function pushStorage(source, destination) {
var i, j, k, found, rows; var queue = new RSVP.Queue();
// browsing answers return queue
for (i = 0; i < answers.length; i += 1) { .push(function () {
if (answers[i].result === "success") { return RSVP.all([
rows = answers[i].data.rows; source.allDocs(),
break; context._signature_sub_storage.allDocs()
} ]);
} })
for (i += 1; i < answers.length; i += 1) { .push(function (result_list) {
if (answers[i].result === "success") { var i,
// browsing answer rows local_dict = {},
for (j = 0; j < answers[i].data.rows.length; j += 1) { signature_dict = {},
found = false; key;
// browsing result rows for (i = 0; i < result_list[0].data.total_rows; i += 1) {
for (k = 0; k < rows.length; k += 1) { if (!skip_document_dict.hasOwnProperty(
if (rows[k].id === answers[i].data.rows[j].id) { result_list[0].data.rows[i].id
found = true; )) {
break; local_dict[result_list[0].data.rows[i].id] = i;
}
}
for (i = 0; i < result_list[1].data.total_rows; i += 1) {
if (!skip_document_dict.hasOwnProperty(
result_list[1].data.rows[i].id
)) {
signature_dict[result_list[1].data.rows[i].id] = i;
}
}
for (key in local_dict) {
if (local_dict.hasOwnProperty(key)) {
if (!signature_dict.hasOwnProperty(key)) {
checkLocalCreation(queue, source, destination, key);
} }
} }
if (!found) { }
rows.push(answers[i].data.rows[j]); for (key in signature_dict) {
if (signature_dict.hasOwnProperty(key)) {
if (local_dict.hasOwnProperty(key)) {
checkSignatureDifference(queue, source, destination, key);
} else {
checkLocalDeletion(queue, destination, key, source);
}
} }
} }
} });
}
return {"data": {"total_rows": (rows || []).length, "rows": rows || []}};
}).then(command.success, command.error, command.notify);
/*jslint unparam: true */
};
ReplicateStorage.prototype.check = function (command, param, option) {
var promise_list = [], index, length = this._storage_list.length;
for (index = 0; index < length; index += 1) {
promise_list[index] =
command.storage(this._storage_list[index]).check(param, option);
}
return all(promise_list).
then(function () { return; }).
then(command.success, command.error, command.notify);
};
ReplicateStorage.prototype.repair = function (command, param, option) {
var storage_list = this._storage_list, length = storage_list.length,
this_ = this;
if (typeof param._id !== 'string' || !param._id) {
command.error("bad_request");
return;
}
storage_list = storage_list.map(function (description) {
return command.storage(description);
});
function repairSubStorages() {
var promise_list = [], i;
for (i = 0; i < length; i += 1) {
promise_list[i] = success(storage_list[i].repair(param, option));
}
return all(promise_list);
} }
function returnThe404ReasonsElseNull(reason) { return new RSVP.Queue()
if (reason.status === 404) { .push(function () {
return 404; // Ensure that the document storage is usable
} return context._signature_sub_storage.__storage._sub_storage.get(
return null; context._signature_hash
} );
})
function getSubStoragesDocument() { .push(undefined, function (error) {
var promise_list = [], i; if ((error instanceof jIO.util.jIOError) &&
for (i = 0; i < length; i += 1) { (error.status_code === 404)) {
promise_list[i] = return context._signature_sub_storage.__storage._sub_storage.put(
storage_list[i].get(param).then(null, returnThe404ReasonsElseNull); context._signature_hash,
} {}
return all(promise_list); );
}
function synchronizeDocument(answers) {
return this_.syncGetAnswerList(command, answers);
}
function checkAnswers(answers) {
var i;
for (i = 0; i < answers.length; i += 1) {
if (answers[i].result !== "success") {
throw answers[i];
} }
} throw error;
} })
return repairSubStorages(). .push(function () {
then(getSubStoragesDocument). return RSVP.all([
then(synchronizeDocument). // Don't repair local_sub_storage twice
then(checkAnswers). // context._signature_sub_storage.repair.apply(
then(command.success, command.error, command.notify); // context._signature_sub_storage,
// argument_list
// ),
context._local_sub_storage.repair.apply(
context._local_sub_storage,
argument_list
),
context._remote_sub_storage.repair.apply(
context._remote_sub_storage,
argument_list
)
]);
})
.push(function () {
return pushStorage(context._local_sub_storage,
context._remote_sub_storage);
})
.push(function () {
return pushStorage(context._remote_sub_storage,
context._local_sub_storage);
});
}; };
addStorageFunction('replicate', ReplicateStorage); jIO.addStorage('replicate', ReplicateStorage);
})); }(jIO, RSVP, Rusha));
test/jio.storage/replicatestorage.tests.js
View file @ 122da4b3
/*jslint indent: 2, maxlen: 80, nomen: true */ /*jslint nomen: true*/
/*global define, RSVP, jIO, fake_storage, module, test, stop, start, deepEqual, (function (jIO, QUnit) {
setTimeout, clearTimeout, XMLHttpRequest, window, ok */
(function (dependencies, factory) {
"use strict"; "use strict";
if (typeof define === 'function' && define.amd) { var test = QUnit.test,
return define(dependencies, factory); stop = QUnit.stop,
start = QUnit.start,
ok = QUnit.ok,
expect = QUnit.expect,
deepEqual = QUnit.deepEqual,
equal = QUnit.equal,
module = QUnit.module,
throws = QUnit.throws;
/////////////////////////////////////////////////////////////////
// Custom test substorage definition
/////////////////////////////////////////////////////////////////
function Storage200() {
return this;
} }
factory(RSVP, jIO, fake_storage); jIO.addStorage('replicatestorage200', Storage200);
}([
"rsvp",
"jio",
"fakestorage",
"replicatestorage"
], function (RSVP, jIO, fake_storage) {
"use strict";
var all = RSVP.all, chain = RSVP.resolve, Promise = RSVP.Promise; function Storage500() {
return this;
/**
* sleep(delay, [value]): promise< value >
*
* Produces a new promise which will resolve with `value` after `delay`
* milliseconds.
*
* @param {Number} delay The time to sleep.
* @param {Any} [value] The value to resolve.
* @return {Promise} A new promise.
*/
function sleep(delay, value) {
var ident;
return new Promise(function (resolve) {
ident = setTimeout(resolve, delay, value);
}, function () {
clearTimeout(ident);
});
} }
jIO.addStorage('replicatestorage500', Storage500);
/////////////////////////////////////////////////////////////////
// replicateStorage.constructor
/////////////////////////////////////////////////////////////////
module("replicateStorage.constructor");
test("create substorage", function () {
var jio = jIO.createJIO({
type: "replicate",
local_sub_storage: {
type: "replicatestorage200"
},
remote_sub_storage: {
type: "replicatestorage500"
}
});
function jsonClone(object, replacer) { ok(jio.__storage._local_sub_storage instanceof jio.constructor);
if (object === undefined) { equal(jio.__storage._local_sub_storage.__type, "replicatestorage200");
return undefined; ok(jio.__storage._remote_sub_storage instanceof jio.constructor);
} equal(jio.__storage._remote_sub_storage.__type, "replicatestorage500");
return JSON.parse(JSON.stringify(object, replacer));
}
function reverse(promise) { equal(jio.__storage._signature_hash,
return promise.then(function (a) { throw a; }, function (e) { return e; }); "_replicate_7b54b9b5183574854e5870beb19b15152a36ef4e");
}
function orderRowsById(a, b) { ok(jio.__storage._signature_sub_storage instanceof jio.constructor);
return a.id > b.id ? 1 : b.id > a.id ? -1 : 0; equal(jio.__storage._signature_sub_storage.__type, "document");
}
module("Replicate + GID + Local"); equal(jio.__storage._signature_sub_storage.__storage._document_id,
jio.__storage._signature_hash);
test("Get", function () { ok(jio.__storage._signature_sub_storage.__storage._sub_storage
var shared = {}, i, jio_list, replicate_jio; instanceof jio.constructor);
equal(jio.__storage._signature_sub_storage.__storage._sub_storage.__type,
"replicatestorage200");
// this test can work with at least 2 sub storages });
shared.gid_description = {
"type": "gid",
"constraints": {
"default": {
"identifier": "list"
}
},
"sub_storage": null
};
shared.storage_description_list = []; /////////////////////////////////////////////////////////////////
for (i = 0; i < 4; i += 1) { // replicateStorage.get
shared.storage_description_list[i] = jsonClone(shared.gid_description); /////////////////////////////////////////////////////////////////
shared.storage_description_list[i].sub_storage = { module("replicateStorage.get");
"type": "local", test("get called substorage get", function () {
"username": "replicate scenario test for get method - " + (i + 1), stop();
"mode": "memory" expect(2);
};
}
shared.replicate_storage_description = { var jio = jIO.createJIO({
"type": "replicate", type: "replicate",
"storage_list": shared.storage_description_list local_sub_storage: {
}; type: "replicatestorage200"
},
remote_sub_storage: {
type: "replicatestorage500"
}
});
shared.workspace = {}; Storage200.prototype.get = function (id) {
shared.jio_option = { equal(id, "bar", "get 200 called");
"workspace": shared.workspace, return {title: "foo"};
"max_retry": 0
}; };
jio_list = shared.storage_description_list.map(function (description) { jio.get("bar")
return jIO.createJIO(description, shared.jio_option); .then(function (result) {
}); deepEqual(result, {
replicate_jio = jIO.createJIO( "title": "foo"
shared.replicate_storage_description, }, "Check document");
shared.jio_option })
); .fail(function (error) {
ok(false, error);
})
.always(function () {
start();
});
});
/////////////////////////////////////////////////////////////////
// replicateStorage.post
/////////////////////////////////////////////////////////////////
module("replicateStorage.post");
test("post called substorage post", function () {
stop(); stop();
expect(2);
shared.modified_date_list = [ var jio = jIO.createJIO({
new Date("1995"), type: "replicate",
new Date("2000"), local_sub_storage: {
null, type: "replicatestorage200"
new Date("Invalid Date") },
]; remote_sub_storage: {
shared.winner_modified_date = shared.modified_date_list[1]; type: "replicatestorage500"
}
function setFakeStorage() { });
setFakeStorage.original = shared.storage_description_list[0].sub_storage;
shared.storage_description_list[0].sub_storage = {
"type": "fake",
"id": "replicate scenario test for get method - 1"
};
jio_list[0] = jIO.createJIO(
shared.storage_description_list[0],
shared.jio_option
);
replicate_jio = jIO.createJIO(
shared.replicate_storage_description,
shared.jio_option
);
}
function unsetFakeStorage() {
shared.storage_description_list[0].sub_storage = setFakeStorage.original;
jio_list[0] = jIO.createJIO(
shared.storage_description_list[0],
shared.jio_option
);
replicate_jio = jIO.createJIO(
shared.replicate_storage_description,
shared.jio_option
);
}
function putSimilarDocuments() {
return all(jio_list.map(function (jio) {
return jio.post({
"identifier": "a",
"modified": shared.modified_date_list[0]
});
}));
}
function getDocumentNothingToSynchronize() { Storage200.prototype.post = function (param) {
return replicate_jio.get({"_id": "{\"identifier\":[\"a\"]}"}); deepEqual(param, {title: "bar"}, "post 200 called");
} return "foo";
};
function getDocumentNothingToSynchronizeTest(answer) { jio.post({title: "bar"})
deepEqual(answer, { .then(function (result) {
"data": { equal(result, "foo", "Check id");
"_id": "{\"identifier\":[\"a\"]}", })
"identifier": "a", .fail(function (error) {
"modified": shared.modified_date_list[0].toJSON() ok(false, error);
}, })
"id": "{\"identifier\":[\"a\"]}", .always(function () {
"method": "get", start();
"result": "success", });
"status": 200, });
"statusText": "Ok"
}, "Get document, nothing to synchronize.");
// check storage state
return sleep(1000).
// possible synchronization in background (should not occur)
then(function () {
return all(jio_list.map(function (jio) {
return jio.get({"_id": "{\"identifier\":[\"a\"]}"});
}));
}).then(function (answers) {
answers.forEach(function (answer) {
deepEqual(answer, {
"data": {
"_id": "{\"identifier\":[\"a\"]}",
"identifier": "a",
"modified": shared.modified_date_list[0].toJSON()
},
"id": "{\"identifier\":[\"a\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Check storage content");
});
});
}
function putDifferentDocuments() { /////////////////////////////////////////////////////////////////
return all(jio_list.map(function (jio, i) { // replicateStorage.hasCapacity
return jio.post({ /////////////////////////////////////////////////////////////////
"identifier": "b", module("replicateStorage.hasCapacity");
"modified": shared.modified_date_list[i] test("hasCapacity return substorage value", function () {
}); var jio = jIO.createJIO({
})); type: "replicate",
} local_sub_storage: {
type: "replicatestorage200"
},
remote_sub_storage: {
type: "replicatestorage500"
}
});
function getDocumentWithSynchronization() { delete Storage200.prototype.hasCapacity;
return replicate_jio.get({"_id": "{\"identifier\":[\"b\"]}"});
}
function getDocumentWithSynchronizationTest(answer) { throws(
if (answer && answer.data) { function () {
ok(shared.modified_date_list.map(function (v) { jio.hasCapacity("foo");
return (v && v.toJSON()) || undefined; },
}).indexOf(answer.data.modified) !== -1, "Should be a known date"); function (error) {
delete answer.data.modified; ok(error instanceof jIO.util.jIOError);
equal(error.status_code, 501);
equal(error.message,
"Capacity 'foo' is not implemented on 'replicatestorage200'");
return true;
} }
deepEqual(answer, { );
"data": { });
"_id": "{\"identifier\":[\"b\"]}",
"identifier": "b"
},
"id": "{\"identifier\":[\"b\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Get document, pending synchronization.");
// check storage state
return sleep(1000).
// synchronizing in background
then(function () {
return all(jio_list.map(function (jio) {
return jio.get({"_id": "{\"identifier\":[\"b\"]}"});
}));
}).then(function (answers) {
answers.forEach(function (answer) {
deepEqual(answer, {
"data": {
"_id": "{\"identifier\":[\"b\"]}",
"identifier": "b",
"modified": shared.winner_modified_date.toJSON()
},
"id": "{\"identifier\":[\"b\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Check storage content");
});
});
}
function putOneDocument() { /////////////////////////////////////////////////////////////////
return jio_list[1].post({ // replicateStorage.buildQuery
"identifier": "c", /////////////////////////////////////////////////////////////////
"modified": shared.modified_date_list[1] module("replicateStorage.buildQuery");
});
}
function getDocumentWith404Synchronization() { test("buildQuery return substorage buildQuery", function () {
return replicate_jio.get({"_id": "{\"identifier\":[\"c\"]}"}); stop();
} expect(2);
function getDocumentWith404SynchronizationTest(answer) { var jio = jIO.createJIO({
if (answer && answer.data) { type: "replicate",
ok(shared.modified_date_list.map(function (v) { local_sub_storage: {
return (v && v.toJSON()) || undefined; type: "replicatestorage200"
}).indexOf(answer.data.modified) !== -1, "Should be a known date"); },
delete answer.data.modified; remote_sub_storage: {
type: "replicatestorage500"
} }
deepEqual(answer, { });
"data": {
"_id": "{\"identifier\":[\"c\"]}",
"identifier": "c"
},
"id": "{\"identifier\":[\"c\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Get document, synchronizing with not found document.");
// check storage state
return sleep(1000).
// synchronizing in background
then(function () {
return all(jio_list.map(function (jio) {
return jio.get({"_id": "{\"identifier\":[\"c\"]}"});
}));
}).then(function (answers) {
answers.forEach(function (answer) {
deepEqual(answer, {
"data": {
"_id": "{\"identifier\":[\"c\"]}",
"identifier": "c",
"modified": shared.winner_modified_date.toJSON()
},
"id": "{\"identifier\":[\"c\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Check storage content");
});
});
}
function putDifferentDocuments2() { Storage200.prototype.hasCapacity = function () {
return all(jio_list.map(function (jio, i) { return true;
return jio.post({ };
"identifier": "d",
"modified": shared.modified_date_list[i]
});
}));
}
function getDocumentWithUnavailableStorage() { Storage200.prototype.buildQuery = function (options) {
setFakeStorage(); deepEqual(options, {
setTimeout(function () { include_docs: false,
fake_storage.commands[ sort_on: [["title", "ascending"]],
"replicate scenario test for get method - 1/allDocs" limit: [5],
].error({"status": 0}); select_list: ["title", "id"],
}, 100); replicate: 'title: "two"'
return replicate_jio.get({"_id": "{\"identifier\":[\"d\"]}"}); }, "allDocs parameter");
} return "bar";
};
function getDocumentWithUnavailableStorageTest(answer) { jio.allDocs({
if (answer && answer.data) { include_docs: false,
ok(shared.modified_date_list.map(function (v) { sort_on: [["title", "ascending"]],
return (v && v.toJSON()) || undefined; limit: [5],
}).indexOf(answer.data.modified) !== -1, "Should be a known date"); select_list: ["title", "id"],
delete answer.data.modified; replicate: 'title: "two"'
} })
deepEqual(answer, { .then(function (result) {
"data": { deepEqual(result, {
"_id": "{\"identifier\":[\"d\"]}", data: {
"identifier": "d" rows: "bar",
}, total_rows: 3
"id": "{\"identifier\":[\"d\"]}", }
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Get document, synchronizing with unavailable storage.");
unsetFakeStorage();
// check storage state
return sleep(1000).
// synchronizing in background
then(function () {
return all(jio_list.map(function (jio) {
return jio.get({"_id": "{\"identifier\":[\"d\"]}"});
}));
}).then(function (answers) {
deepEqual(answers[0], {
"data": {
"_id": "{\"identifier\":[\"d\"]}",
"identifier": "d",
"modified": shared.modified_date_list[0].toJSON()
},
"id": "{\"identifier\":[\"d\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Check storage content");
answers.slice(1).forEach(function (answer) {
deepEqual(answer, {
"data": {
"_id": "{\"identifier\":[\"d\"]}",
"identifier": "d",
"modified": shared.winner_modified_date.toJSON()
},
"id": "{\"identifier\":[\"d\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Check storage content");
});
}); });
} })
.fail(function (error) {
function unexpectedError(error) { ok(false, error);
if (error instanceof Error) { })
deepEqual([ .always(function () {
error.name + ": " + error.message, start();
error });
], "NO ERROR", "Unexpected error");
} else {
deepEqual(error, "NO ERROR", "Unexpected error");
}
}
chain().
// get without synchronizing anything
then(putSimilarDocuments).
then(getDocumentNothingToSynchronize).
then(getDocumentNothingToSynchronizeTest).
// get with synchronization
then(putDifferentDocuments).
then(getDocumentWithSynchronization).
then(getDocumentWithSynchronizationTest).
// get with 404 synchronization
then(putOneDocument).
then(getDocumentWith404Synchronization).
then(getDocumentWith404SynchronizationTest).
// XXX get with attachment synchronization
// get with unavailable storage
then(putDifferentDocuments2).
then(getDocumentWithUnavailableStorage).
then(getDocumentWithUnavailableStorageTest).
// End of scenario
then(null, unexpectedError).
then(start, start);
}); });
test("Post + Put", function () { /////////////////////////////////////////////////////////////////
var shared = {}, i, jio_list, replicate_jio; // replicateStorage.put
/////////////////////////////////////////////////////////////////
module("replicateStorage.put");
test("put called substorage put", function () {
stop();
expect(3);
// this test can work with at least 2 sub storages var jio = jIO.createJIO({
shared.gid_description = { type: "replicate",
"type": "gid", local_sub_storage: {
"constraints": { type: "replicatestorage200"
"default": {
"identifier": "list"
}
}, },
"sub_storage": null remote_sub_storage: {
type: "replicatestorage500"
}
});
Storage200.prototype.put = function (id, param) {
equal(id, "bar", "put 200 called");
deepEqual(param, {"title": "foo"}, "put 200 called");
return id;
}; };
shared.storage_description_list = []; jio.put("bar", {"title": "foo"})
for (i = 0; i < 4; i += 1) { .then(function (result) {
shared.storage_description_list[i] = jsonClone(shared.gid_description); equal(result, "bar");
shared.storage_description_list[i].sub_storage = { })
"type": "local", .fail(function (error) {
"username": "replicate scenario test for post method - " + (i + 1), ok(false, error);
"mode": "memory" })
}; .always(function () {
} start();
});
shared.replicate_storage_description = { });
"type": "replicate",
"storage_list": shared.storage_description_list
};
shared.workspace = {}; test("put can not modify the signature", function () {
shared.jio_option = { stop();
"workspace": shared.workspace, expect(3);
"max_retry": 0
};
jio_list = shared.storage_description_list.map(function (description) { var jio = jIO.createJIO({
return jIO.createJIO(description, shared.jio_option); type: "replicate",
local_sub_storage: {
type: "replicatestorage200"
},
remote_sub_storage: {
type: "replicatestorage500"
}
}); });
replicate_jio = jIO.createJIO( delete Storage200.prototype.put;
shared.replicate_storage_description,
shared.jio_option jio.put(jio.__storage._signature_hash, {"title": "foo"})
); .then(function () {
ok(false);
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
equal(error.message, jio.__storage._signature_hash + " is frozen");
equal(error.status_code, 403);
})
.always(function () {
start();
});
});
/////////////////////////////////////////////////////////////////
// replicateStorage.remove
/////////////////////////////////////////////////////////////////
module("replicateStorage.remove");
test("remove called substorage remove", function () {
stop(); stop();
expect(2);
function setFakeStorage() { var jio = jIO.createJIO({
setFakeStorage.original = shared.storage_description_list[0].sub_storage; type: "replicate",
shared.storage_description_list[0].sub_storage = { local_sub_storage: {
"type": "fake", type: "replicatestorage200"
"id": "replicate scenario test for post method - 1" },
}; remote_sub_storage: {
jio_list[0] = jIO.createJIO( type: "replicatestorage500"
shared.storage_description_list[0], }
shared.jio_option });
); Storage200.prototype.remove = function (id) {
replicate_jio = jIO.createJIO( equal(id, "bar", "remove 200 called");
shared.replicate_storage_description, return id;
shared.jio_option };
);
}
function unsetFakeStorage() {
shared.storage_description_list[0].sub_storage = setFakeStorage.original;
jio_list[0] = jIO.createJIO(
shared.storage_description_list[0],
shared.jio_option
);
replicate_jio = jIO.createJIO(
shared.replicate_storage_description,
shared.jio_option
);
}
function createDocument() {
return replicate_jio.post({"identifier": "a"});
}
function createDocumentTest(answer) { jio.remove("bar", {"title": "foo"})
deepEqual(answer, { .then(function (result) {
"id": "{\"identifier\":[\"a\"]}", equal(result, "bar");
"method": "post", })
"result": "success", .fail(function (error) {
"status": 201, ok(false, error);
"statusText": "Created" })
}, "Post document"); .always(function () {
start();
});
});
return sleep(100); test("remove can not modify the signature", function () {
} stop();
expect(3);
function checkStorageContent() { var jio = jIO.createJIO({
// check storage state type: "replicate",
return all(jio_list.map(function (jio) { local_sub_storage: {
return jio.get({"_id": "{\"identifier\":[\"a\"]}"}); type: "replicatestorage200"
})).then(function (answers) { },
answers.forEach(function (answer) { remote_sub_storage: {
deepEqual(answer, { type: "replicatestorage500"
"data": { }
"_id": "{\"identifier\":[\"a\"]}", });
"identifier": "a" delete Storage200.prototype.remove;
},
"id": "{\"identifier\":[\"a\"]}", jio.remove(jio.__storage._signature_hash)
"method": "get", .then(function () {
"result": "success", ok(false);
"status": 200, })
"statusText": "Ok" .fail(function (error) {
}, "Check storage content"); ok(error instanceof jIO.util.jIOError);
}); equal(error.message, jio.__storage._signature_hash + " is frozen");
equal(error.status_code, 403);
})
.always(function () {
start();
}); });
} });
function updateDocument() { /////////////////////////////////////////////////////////////////
return replicate_jio.put({ // replicateStorage.repair use cases
"_id": "{\"identifier\":[\"a\"]}", /////////////////////////////////////////////////////////////////
"identifier": "a", module("replicateStorage.repair", {
"title": "b" setup: function () {
// Uses memory substorage, so that it is flushed after each run
this.jio = jIO.createJIO({
type: "replicate",
local_sub_storage: {
type: "uuid",
sub_storage: {
type: "memory"
}
},
remote_sub_storage: {
type: "uuid",
sub_storage: {
type: "memory"
}
}
}); });
}
function updateDocumentTest(answer) {
deepEqual(answer, {
"id": "{\"identifier\":[\"a\"]}",
"method": "put",
"result": "success",
"status": 204,
"statusText": "No Content"
}, "Update document");
return sleep(100);
} }
});
function checkStorageContent3() { test("local document creation", function () {
// check storage state stop();
return all(jio_list.map(function (jio) { expect(2);
return jio.get({"_id": "{\"identifier\":[\"a\"]}"});
})).then(function (answers) { var id,
answers.forEach(function (answer) { context = this;
deepEqual(answer, {
"data": { context.jio.post({"title": "foo"})
"_id": "{\"identifier\":[\"a\"]}", .then(function (result) {
"identifier": "a", id = result;
"title": "b" return context.jio.repair();
}, })
"id": "{\"identifier\":[\"a\"]}", .then(function () {
"method": "get", return context.jio.__storage._remote_sub_storage.get(id);
"result": "success", })
"status": 200, .then(function (result) {
"statusText": "Ok" deepEqual(result, {
}, "Check storage content"); title: "foo"
});
})
.then(function () {
return context.jio.__storage._signature_sub_storage.get(id);
})
.then(function (result) {
deepEqual(result, {
hash: "5ea9013447539ad65de308cbd75b5826a2ae30e5"
}); });
})
.fail(function (error) {
ok(false, error);
})
.always(function () {
start();
}); });
} });
function createDocumentWithUnavailableStorage() {
setFakeStorage();
setTimeout(function () {
fake_storage.commands[
"replicate scenario test for post method - 1/allDocs"
].error({"status": 0});
}, 100);
return replicate_jio.post({"identifier": "b"});
}
function createDocumentWithUnavailableStorageTest(answer) {
deepEqual(answer, {
"id": "{\"identifier\":[\"b\"]}",
"method": "post",
"result": "success",
"status": 201,
"statusText": "Created"
}, "Post document with unavailable storage");
return sleep(100);
}
function checkStorageContent2() { test("remote document creation", function () {
unsetFakeStorage(); stop();
// check storage state expect(2);
return all(jio_list.map(function (jio, i) {
if (i === 0) { var id,
return reverse(jio.get({"_id": "{\"identifier\":[\"b\"]}"})); context = this;
}
return jio.get({"_id": "{\"identifier\":[\"b\"]}"}); context.jio.__storage._remote_sub_storage.post({"title": "bar"})
})).then(function (answers) { .then(function (result) {
deepEqual(answers[0], { id = result;
"error": "not_found", return context.jio.repair();
"id": "{\"identifier\":[\"b\"]}", })
"message": "Cannot get document", .then(function () {
"method": "get", return context.jio.get(id);
"reason": "missing", })
"result": "error", .then(function (result) {
"status": 404, deepEqual(result, {
"statusText": "Not Found" title: "bar"
}, "Check storage content"); });
answers.slice(1).forEach(function (answer) { })
deepEqual(answer, { .then(function () {
"data": { return context.jio.__storage._signature_sub_storage.get(id);
"_id": "{\"identifier\":[\"b\"]}", })
"identifier": "b" .then(function (result) {
}, deepEqual(result, {
"id": "{\"identifier\":[\"b\"]}", hash: "6799f3ea80e325b89f19589282a343c376c1f1af"
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Check storage content");
}); });
})
.fail(function (error) {
ok(false, error);
})
.always(function () {
start();
}); });
}
function unexpectedError(error) {
if (error instanceof Error) {
deepEqual([
error.name + ": " + error.message,
error
], "NO ERROR", "Unexpected error");
} else {
deepEqual(error, "NO ERROR", "Unexpected error");
}
}
chain().
// create a document
then(createDocument).
then(createDocumentTest).
then(checkStorageContent).
// update document
then(updateDocument).
then(updateDocumentTest).
then(checkStorageContent3).
// create a document with unavailable storage
then(createDocumentWithUnavailableStorage).
then(createDocumentWithUnavailableStorageTest).
then(checkStorageContent2).
// End of scenario
then(null, unexpectedError).
then(start, start);
}); });
test("Remove", function () { test("local and remote document creations", function () {
var shared = {}, i, jio_list, replicate_jio;
// this test can work with at least 2 sub storages
shared.gid_description = {
"type": "gid",
"constraints": {
"default": {
"identifier": "list"
}
},
"sub_storage": null
};
shared.storage_description_list = [];
for (i = 0; i < 4; i += 1) {
shared.storage_description_list[i] = jsonClone(shared.gid_description);
shared.storage_description_list[i].sub_storage = {
"type": "local",
"username": "replicate scenario test for remove method - " + (i + 1),
"mode": "memory"
};
}
shared.replicate_storage_description = {
"type": "replicate",
"storage_list": shared.storage_description_list
};
shared.workspace = {};
shared.jio_option = {
"workspace": shared.workspace,
"max_retry": 0
};
jio_list = shared.storage_description_list.map(function (description) {
return jIO.createJIO(description, shared.jio_option);
});
replicate_jio = jIO.createJIO(
shared.replicate_storage_description,
shared.jio_option
);
stop(); stop();
expect(5);
var context = this;
RSVP.all([
context.jio.put("conflict", {"title": "foo"}),
context.jio.__storage._remote_sub_storage.put("conflict",
{"title": "bar"})
])
.then(function () {
return context.jio.repair();
})
.then(function () {
ok(false);
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
equal(error.message, "Conflict on 'conflict'");
equal(error.status_code, 409);
})
.then(function () {
return context.jio.__storage._signature_sub_storage.get("conflict");
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
// equal(error.message, "Cannot find document: conflict");
equal(error.status_code, 404);
})
.always(function () {
start();
});
});
function setFakeStorage() { test("local and remote same document creations", function () {
setFakeStorage.original = shared.storage_description_list[0].sub_storage; stop();
shared.storage_description_list[0].sub_storage = { expect(1);
"type": "fake",
"id": "replicate scenario test for remove method - 1" var context = this;
};
jio_list[0] = jIO.createJIO( RSVP.all([
shared.storage_description_list[0], context.jio.put("conflict", {"title": "foo"}),
shared.jio_option context.jio.__storage._remote_sub_storage.put("conflict",
); {"title": "foo"})
replicate_jio = jIO.createJIO( ])
shared.replicate_storage_description, .then(function () {
shared.jio_option return context.jio.repair();
); })
} .then(function () {
return context.jio.__storage._signature_sub_storage.get("conflict");
function unsetFakeStorage() { })
shared.storage_description_list[0].sub_storage = setFakeStorage.original; .then(function (result) {
jio_list[0] = jIO.createJIO( deepEqual(result, {
shared.storage_description_list[0], hash: "5ea9013447539ad65de308cbd75b5826a2ae30e5"
shared.jio_option
);
replicate_jio = jIO.createJIO(
shared.replicate_storage_description,
shared.jio_option
);
}
function putSomeDocuments() {
return all(jio_list.map(function (jio) {
return jio.post({"identifier": "a"});
}));
}
function removeDocument() {
return replicate_jio.remove({"_id": "{\"identifier\":[\"a\"]}"});
}
function removeDocumentTest(answer) {
deepEqual(answer, {
"id": "{\"identifier\":[\"a\"]}",
"method": "remove",
"result": "success",
"status": 204,
"statusText": "No Content"
}, "Remove document");
return sleep(100);
}
function checkStorageContent() {
// check storage state
return all(jio_list.map(function (jio) {
return reverse(jio.get({"_id": "{\"identifier\":[\"a\"]}"}));
})).then(function (answers) {
answers.forEach(function (answer) {
deepEqual(answer, {
"error": "not_found",
"id": "{\"identifier\":[\"a\"]}",
"message": "Cannot get document",
"method": "get",
"reason": "missing",
"result": "error",
"status": 404,
"statusText": "Not Found"
}, "Check storage content");
}); });
})
.fail(function (error) {
ok(false, error);
})
.always(function () {
start();
}); });
} });
function putSomeDocuments2() {
return all(jio_list.map(function (jio) {
return jio.post({"identifier": "b"});
}));
}
function removeDocumentWithUnavailableStorage() {
setFakeStorage();
setTimeout(function () {
fake_storage.commands[
"replicate scenario test for remove method - 1/allDocs"
].error({"status": 0});
}, 100);
return replicate_jio.remove({"_id": "{\"identifier\":[\"b\"]}"});
}
function removeDocumentWithUnavailableStorageTest(answer) {
deepEqual(answer, {
"id": "{\"identifier\":[\"b\"]}",
"method": "remove",
"result": "success",
"status": 204,
"statusText": "No Content"
}, "Remove document with unavailable storage");
return sleep(100);
}
function checkStorageContent2() { test("no modification", function () {
unsetFakeStorage(); stop();
// check storage state expect(2);
return all(jio_list.map(function (jio, i) {
if (i === 0) { var id,
return jio.get({"_id": "{\"identifier\":[\"b\"]}"}); context = this;
}
return reverse(jio.get({"_id": "{\"identifier\":[\"b\"]}"})); context.jio.post({"title": "foo"})
})).then(function (answers) { .then(function (result) {
deepEqual(answers[0], { id = result;
"data": { return context.jio.repair();
"_id": "{\"identifier\":[\"b\"]}", })
"identifier": "b" .then(function () {
}, return context.jio.repair();
"id": "{\"identifier\":[\"b\"]}", })
"method": "get", .then(function () {
"result": "success", return context.jio.__storage._remote_sub_storage.get(id);
"status": 200, })
"statusText": "Ok" .then(function (result) {
}, "Check storage content"); deepEqual(result, {
answers.slice(1).forEach(function (answer) { title: "foo"
deepEqual(answer, {
"error": "not_found",
"id": "{\"identifier\":[\"b\"]}",
"message": "Cannot get document",
"method": "get",
"reason": "missing",
"result": "error",
"status": 404,
"statusText": "Not Found"
}, "Check storage content");
}); });
})
.then(function () {
return context.jio.__storage._signature_sub_storage.get(id);
})
.then(function (result) {
deepEqual(result, {
hash: "5ea9013447539ad65de308cbd75b5826a2ae30e5"
});
})
.fail(function (error) {
ok(false, error);
})
.always(function () {
start();
}); });
}
function unexpectedError(error) {
if (error instanceof Error) {
deepEqual([
error.name + ": " + error.message,
error
], "NO ERROR", "Unexpected error");
} else {
deepEqual(error, "NO ERROR", "Unexpected error");
}
}
chain().
// remove document
then(putSomeDocuments).
then(removeDocument).
then(removeDocumentTest).
then(checkStorageContent).
// remove document with unavailable storage
then(putSomeDocuments2).
then(removeDocumentWithUnavailableStorage).
then(removeDocumentWithUnavailableStorageTest).
then(checkStorageContent2).
// End of scenario
then(null, unexpectedError).
then(start, start);
}); });
test("AllDocs", function () { test("local document modification", function () {
var shared = {}, i, jio_list, replicate_jio;
// this test can work with at least 2 sub storages
shared.gid_description = {
"type": "gid",
"constraints": {
"default": {
"identifier": "list"
}
},
"sub_storage": null
};
shared.storage_description_list = [];
for (i = 0; i < 2; i += 1) {
shared.storage_description_list[i] = jsonClone(shared.gid_description);
shared.storage_description_list[i].sub_storage = {
"type": "local",
"username": "replicate scenario test for allDocs method - " + (i + 1),
"mode": "memory"
};
}
shared.replicate_storage_description = {
"type": "replicate",
"storage_list": shared.storage_description_list
};
shared.workspace = {};
shared.jio_option = {
"workspace": shared.workspace,
"max_retry": 0
};
jio_list = shared.storage_description_list.map(function (description) {
return jIO.createJIO(description, shared.jio_option);
});
replicate_jio = jIO.createJIO(
shared.replicate_storage_description,
shared.jio_option
);
stop(); stop();
expect(2);
shared.modified_date_list = [
new Date("2000"), var id,
new Date("1995"), context = this;
null,
new Date("Invalid Date") context.jio.post({"title": "foo"})
]; .then(function (result) {
id = result;
function postSomeDocuments() { return context.jio.repair();
return all([ })
jio_list[0].post({ .then(function () {
"identifier": "a", return context.jio.put(id, {"title": "foo2"});
"modified": shared.modified_date_list[0] })
}), .then(function () {
jio_list[0].post({ return context.jio.repair();
"identifier": "b", })
"modified": shared.modified_date_list[1] .then(function () {
}), return context.jio.__storage._remote_sub_storage.get(id);
jio_list[1].post({ })
"identifier": "b", .then(function (result) {
"modified": shared.modified_date_list[0] deepEqual(result, {
}) title: "foo2"
]); });
} })
.then(function () {
function listDocuments() { return context.jio.__storage._signature_sub_storage.get(id);
return replicate_jio.allDocs({"include_docs": true}); })
} .then(function (result) {
deepEqual(result, {
function listDocumentsTest(answer) { hash: "9819187e39531fdc9bcfd40dbc6a7d3c78fe8dab"
answer.data.rows.sort(orderRowsById); });
deepEqual(answer, { })
"data": { .fail(function (error) {
"total_rows": 2, ok(false, error);
"rows": [ })
{ .always(function () {
"id": "{\"identifier\":[\"a\"]}", start();
"doc": { });
"_id": "{\"identifier\":[\"a\"]}",
"identifier": "a",
"modified": shared.modified_date_list[0].toJSON()
},
"value": {}
},
{
"id": "{\"identifier\":[\"b\"]}",
"doc": {
"_id": "{\"identifier\":[\"b\"]}",
"identifier": "b",
"modified": shared.modified_date_list[1].toJSON()
// there's no winner detection here
},
"value": {}
}
]
},
"method": "allDocs",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Document list should be merged correctly");
}
function setFakeStorage() {
shared.storage_description_list[0].sub_storage = {
"type": "fake",
"id": "replicate scenario test for allDocs method - 1"
};
jio_list[0] = jIO.createJIO(
shared.storage_description_list[0],
shared.jio_option
);
replicate_jio = jIO.createJIO(
shared.replicate_storage_description,
shared.jio_option
);
}
function listDocumentsWithUnavailableStorage() {
setTimeout(function () {
fake_storage.commands[
"replicate scenario test for allDocs method - 1/allDocs"
].error({"status": 0});
}, 100);
return replicate_jio.allDocs({"include_docs": true});
}
function listDocumentsWithUnavailableStorageTest(answer) {
deepEqual(answer, {
"data": {
"total_rows": 1,
"rows": [
{
"id": "{\"identifier\":[\"b\"]}",
"doc": {
"_id": "{\"identifier\":[\"b\"]}",
"identifier": "b",
"modified": shared.modified_date_list[0].toJSON()
},
"value": {}
}
]
},
"method": "allDocs",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Document list with only one available storage");
}
function unexpectedError(error) {
if (error instanceof Error) {
deepEqual([
error.name + ": " + error.message,
error
], "NO ERROR", "Unexpected error");
} else {
deepEqual(error, "NO ERROR", "Unexpected error");
}
}
chain().
// list documents
then(postSomeDocuments).
then(listDocuments).
then(listDocumentsTest).
// set fake storage
then(setFakeStorage).
// list documents with unavailable storage
then(listDocumentsWithUnavailableStorage).
then(listDocumentsWithUnavailableStorageTest).
// End of scenario
then(null, unexpectedError).
then(start);
}); });
test("Repair", function () { test("remote document modification", function () {
var shared = {}, i, jio_list, replicate_jio; stop();
expect(2);
// this test can work with at least 2 sub storages
shared.gid_description = { var id,
"type": "gid", context = this;
"constraints": {
"default": { context.jio.post({"title": "foo"})
"identifier": "list" .then(function (result) {
} id = result;
}, return context.jio.repair();
"sub_storage": null })
}; .then(function () {
return context.jio.__storage._remote_sub_storage.put(
shared.storage_description_list = []; id,
for (i = 0; i < 4; i += 1) { {"title": "foo3"}
shared.storage_description_list[i] = jsonClone(shared.gid_description); );
shared.storage_description_list[i].sub_storage = { })
"type": "local", .then(function () {
"username": "replicate scenario test for repair method - " + (i + 1), return context.jio.repair();
"mode": "memory" })
}; .then(function () {
} return context.jio.get(id);
})
shared.replicate_storage_description = { .then(function (result) {
"type": "replicate", deepEqual(result, {
"storage_list": shared.storage_description_list title: "foo3"
}; });
})
.then(function () {
return context.jio.__storage._signature_sub_storage.get(id);
})
.then(function (result) {
deepEqual(result, {
hash: "4b1dde0f80ac38514771a9d25b5278e38f560e0f"
});
})
.fail(function (error) {
ok(false, error);
})
.always(function () {
start();
});
});
shared.workspace = {}; test("local and remote document modifications", function () {
shared.jio_option = { stop();
"workspace": shared.workspace, expect(4);
"max_retry": 0
}; var id,
context = this;
context.jio.post({"title": "foo"})
.then(function (result) {
id = result;
return context.jio.repair();
})
.then(function () {
return RSVP.all([
context.jio.put(id, {"title": "foo4"}),
context.jio.__storage._remote_sub_storage.put(id, {"title": "foo5"})
]);
})
.then(function () {
return context.jio.repair();
})
.then(function () {
ok(false);
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
equal(error.message, "Conflict on '" + id + "'");
equal(error.status_code, 409);
})
.then(function () {
return context.jio.__storage._signature_sub_storage.get(id);
})
.then(function (result) {
deepEqual(result, {
hash: "5ea9013447539ad65de308cbd75b5826a2ae30e5"
});
})
.always(function () {
start();
});
});
jio_list = shared.storage_description_list.map(function (description) { test("local and remote document same modifications", function () {
return jIO.createJIO(description, shared.jio_option); stop();
}); expect(1);
replicate_jio = jIO.createJIO(
shared.replicate_storage_description, var id,
shared.jio_option context = this;
);
context.jio.post({"title": "foo"})
.then(function (result) {
id = result;
return context.jio.repair();
})
.then(function () {
return RSVP.all([
context.jio.put(id, {"title": "foo99"}),
context.jio.__storage._remote_sub_storage.put(id, {"title": "foo99"})
]);
})
.then(function () {
return context.jio.repair();
})
.then(function () {
return context.jio.__storage._signature_sub_storage.get(id);
})
.then(function (result) {
deepEqual(result, {
hash: "8ed3a474128b6e0c0c7d3dd51b1a06ebfbf6722f"
});
})
.fail(function (error) {
ok(false, error);
})
.always(function () {
start();
});
});
test("local document deletion", function () {
stop(); stop();
expect(6);
var id,
context = this;
context.jio.post({"title": "foo"})
.then(function (result) {
id = result;
return context.jio.repair();
})
.then(function () {
return context.jio.remove(id);
})
.then(function () {
return context.jio.repair();
})
.then(function () {
ok(true, "Removal correctly synced");
})
.then(function () {
return context.jio.__storage._remote_sub_storage.get(id);
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
equal(error.message, "Cannot find document: " + id);
equal(error.status_code, 404);
})
.then(function () {
return context.jio.__storage._signature_sub_storage.get(id)
.then(function () {
ok(false, "Signature should be deleted");
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
// equal(error.message, "Cannot find document: " + id);
equal(error.status_code, 404);
});
})
.always(function () {
start();
});
});
shared.modified_date_list = [ test("remote document deletion", function () {
new Date("1995"), stop();
new Date("2000"), expect(6);
null,
new Date("Invalid Date") var id,
]; context = this;
shared.winner_modified_date = shared.modified_date_list[1];
context.jio.post({"title": "foo"})
function setFakeStorage() { .then(function (result) {
setFakeStorage.original = shared.storage_description_list[0].sub_storage; id = result;
shared.storage_description_list[0].sub_storage = { return context.jio.repair();
"type": "fake", })
"id": "replicate scenario test for repair method - 1" .then(function () {
}; return context.jio.__storage._remote_sub_storage.remove(id);
jio_list[0] = jIO.createJIO( })
shared.storage_description_list[0], .then(function () {
shared.jio_option return context.jio.repair();
); })
replicate_jio = jIO.createJIO( .then(function () {
shared.replicate_storage_description, ok(true, "Removal correctly synced");
shared.jio_option })
); .then(function () {
} return context.jio.get(id);
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
equal(error.message, "Cannot find document: " + id);
equal(error.status_code, 404);
})
.then(function () {
return context.jio.__storage._signature_sub_storage.get(id)
.then(function () {
ok(false, "Signature should be deleted");
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
// equal(error.message, "Cannot find document: " + id);
equal(error.status_code, 404);
});
})
.always(function () {
start();
});
});
function unsetFakeStorage() { test("local and remote document deletions", function () {
shared.storage_description_list[0].sub_storage = setFakeStorage.original; stop();
jio_list[0] = jIO.createJIO( expect(8);
shared.storage_description_list[0],
shared.jio_option var id,
); context = this;
replicate_jio = jIO.createJIO(
shared.replicate_storage_description, context.jio.post({"title": "foo"})
shared.jio_option .then(function (result) {
); id = result;
} return context.jio.repair();
})
.then(function () {
return RSVP.all([
context.jio.remove(id),
context.jio.__storage._remote_sub_storage.remove(id)
]);
})
.then(function () {
return context.jio.repair();
})
.then(function () {
return context.jio.get(id)
.then(function () {
ok(false, "Document should be locally deleted");
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
equal(error.message, "Cannot find document: " + id);
equal(error.status_code, 404);
});
})
.then(function () {
return context.jio.__storage._remote_sub_storage.get(id)
.then(function () {
ok(false, "Document should be remotely deleted");
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
equal(error.message, "Cannot find document: " + id);
equal(error.status_code, 404);
});
})
.then(function () {
return context.jio.__storage._signature_sub_storage.get(id)
.then(function () {
ok(false, "Signature should be deleted");
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
// equal(error.message, "Cannot find document: " + id);
equal(error.status_code, 404);
});
})
.fail(function (error) {
ok(false, error);
})
.always(function () {
start();
});
});
function putSimilarDocuments() { test("local deletion and remote modifications", function () {
return all(jio_list.map(function (jio) { stop();
return jio.post({ expect(2);
"identifier": "a",
"modified": shared.modified_date_list[0] var id,
context = this;
context.jio.post({"title": "foo"})
.then(function (result) {
id = result;
return context.jio.repair();
})
.then(function () {
return RSVP.all([
context.jio.remove(id),
context.jio.__storage._remote_sub_storage.put(id, {"title": "foo99"})
]);
})
.then(function () {
return context.jio.repair();
})
.then(function () {
return context.jio.get(id);
})
.then(function (result) {
deepEqual(result, {
title: "foo99"
}); });
})); })
} .then(function () {
return context.jio.__storage._signature_sub_storage.get(id);
function repairDocumentNothingToSynchronize() { })
return replicate_jio.repair({"_id": "{\"identifier\":[\"a\"]}"}); .then(function (result) {
} deepEqual(result, {
hash: "8ed3a474128b6e0c0c7d3dd51b1a06ebfbf6722f"
function repairDocumentNothingToSynchronizeTest(answer) {
deepEqual(answer, {
"id": "{\"identifier\":[\"a\"]}",
"method": "repair",
"result": "success",
"status": 204,
"statusText": "No Content"
}, "Repair document, nothing to synchronize.");
// check storage state
return all(jio_list.map(function (jio) {
return jio.get({"_id": "{\"identifier\":[\"a\"]}"});
})).then(function (answers) {
answers.forEach(function (answer) {
deepEqual(answer, {
"data": {
"_id": "{\"identifier\":[\"a\"]}",
"identifier": "a",
"modified": shared.modified_date_list[0].toJSON()
},
"id": "{\"identifier\":[\"a\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Check storage content");
}); });
})
.fail(function (error) {
ok(false, error);
})
.always(function () {
start();
}); });
} });
function putDifferentDocuments() { test("local modifications and remote deletion", function () {
return all(jio_list.map(function (jio, i) { stop();
return jio.post({ expect(2);
"identifier": "b",
"modified": shared.modified_date_list[i] var id,
context = this;
context.jio.post({"title": "foo"})
.then(function (result) {
id = result;
return context.jio.repair();
})
.then(function () {
return RSVP.all([
context.jio.put(id, {"title": "foo99"}),
context.jio.__storage._remote_sub_storage.remove(id)
]);
})
.then(function () {
return context.jio.repair();
})
.then(function () {
return context.jio.__storage._remote_sub_storage.get(id);
})
.then(function (result) {
deepEqual(result, {
title: "foo99"
}); });
})); })
} .then(function () {
return context.jio.__storage._signature_sub_storage.get(id);
function repairDocumentWithSynchronization() { })
return replicate_jio.repair({"_id": "{\"identifier\":[\"b\"]}"}); .then(function (result) {
} deepEqual(result, {
hash: "8ed3a474128b6e0c0c7d3dd51b1a06ebfbf6722f"
function repairDocumentWithSynchronizationTest(answer) {
deepEqual(answer, {
"id": "{\"identifier\":[\"b\"]}",
"method": "repair",
"result": "success",
"status": 204,
"statusText": "No Content"
}, "Repair document, synchronization should be done.");
// check storage state
return all(jio_list.map(function (jio) {
return jio.get({"_id": "{\"identifier\":[\"b\"]}"});
})).then(function (answers) {
answers.forEach(function (answer) {
deepEqual(answer, {
"data": {
"_id": "{\"identifier\":[\"b\"]}",
"identifier": "b",
"modified": shared.winner_modified_date.toJSON()
},
"id": "{\"identifier\":[\"b\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Check storage content");
}); });
})
.fail(function (error) {
ok(false, error);
})
.always(function () {
start();
}); });
} });
function putOneDocument() { test("signature document is not synced", function () {
return jio_list[1].post({ stop();
"identifier": "c", expect(6);
"modified": shared.modified_date_list[1]
var context = this;
// Uses sessionstorage substorage, so that signature are stored
// in the same local sub storage
this.jio = jIO.createJIO({
type: "replicate",
local_sub_storage: {
type: "uuid",
sub_storage: {
type: "document",
document_id: "/",
sub_storage: {
type: "local",
sessiononly: true
}
}
},
remote_sub_storage: {
type: "memory"
}
});
context.jio.post({"title": "foo"})
.then(function () {
return context.jio.repair();
})
.then(function () {
return context.jio.__storage._remote_sub_storage.get(
context.jio.__storage._signature_hash
);
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
equal(error.message, "Cannot find document: " +
"_replicate_2be6c0851d60bcd9afe829e7133a136d266c779c");
equal(error.status_code, 404);
})
.then(function () {
return context.jio.repair();
})
.then(function () {
return context.jio.__storage._remote_sub_storage.get(
context.jio.__storage._signature_hash
);
})
.fail(function (error) {
ok(error instanceof jIO.util.jIOError);
equal(error.message, "Cannot find document: " +
"_replicate_2be6c0851d60bcd9afe829e7133a136d266c779c");
equal(error.status_code, 404);
})
.fail(function (error) {
ok(false, error);
})
.always(function () {
start();
}); });
} });
function repairDocumentWith404Synchronization() { test("substorages are repaired too", function () {
return replicate_jio.repair({"_id": "{\"identifier\":[\"c\"]}"}); stop();
} expect(9);
function repairDocumentWith404SynchronizationTest(answer) { var context = this,
deepEqual(answer, { first_call = true,
"id": "{\"identifier\":[\"c\"]}", options = {foo: "bar"};
"method": "repair",
"result": "success",
"status": 204,
"statusText": "No Content"
}, "Repair document, synchronizing with not found document.");
// check storage state
return all(jio_list.map(function (jio) {
return jio.get({"_id": "{\"identifier\":[\"c\"]}"});
})).then(function (answers) {
answers.forEach(function (answer) {
deepEqual(answer, {
"data": {
"_id": "{\"identifier\":[\"c\"]}",
"identifier": "c",
"modified": shared.winner_modified_date.toJSON()
},
"id": "{\"identifier\":[\"c\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Check storage content");
});
});
}
function putDifferentDocuments2() { function Storage200CheckRepair() {
return all(jio_list.map(function (jio, i) { return this;
return jio.post({
"identifier": "d",
"modified": shared.modified_date_list[i]
});
}));
} }
Storage200CheckRepair.prototype.get = function () {
ok(true, "get 200 check repair called");
return {};
};
Storage200CheckRepair.prototype.hasCapacity = function () {
return true;
};
Storage200CheckRepair.prototype.buildQuery = function () {
ok(true, "buildQuery 200 check repair called");
return [];
};
Storage200CheckRepair.prototype.allAttachments = function () {
ok(true, "allAttachments 200 check repair called");
return {};
};
Storage200CheckRepair.prototype.repair = function (kw) {
if (first_call) {
deepEqual(
this,
context.jio.__storage._local_sub_storage.__storage,
"local substorage repair"
);
first_call = false;
} else {
deepEqual(
this,
context.jio.__storage._remote_sub_storage.__storage,
"remote substorage repair"
);
}
deepEqual(kw, options, "substorage repair parameters provided");
};
function repairDocumentWithUnavailableStorage() { jIO.addStorage(
setFakeStorage(); 'replicatestorage200chechrepair',
setTimeout(function () { Storage200CheckRepair
fake_storage.commands[ );
"replicate scenario test for repair method - 1/allDocs"
].error({"status": 0});
}, 250);
setTimeout(function () {
fake_storage.commands[
"replicate scenario test for repair method - 1/allDocs"
].error({"status": 0});
}, 500);
return replicate_jio.repair({"_id": "{\"identifier\":[\"d\"]}"});
}
function repairDocumentWithUnavailableStorageTest(answer) {
deepEqual(answer, {
"id": "{\"identifier\":[\"d\"]}",
"method": "repair",
"result": "success",
"status": 204,
"statusText": "No Content"
}, "Repair document, synchronizing with unavailable storage.");
unsetFakeStorage();
// check storage state
return all(jio_list.map(function (jio) {
return jio.get({"_id": "{\"identifier\":[\"d\"]}"});
})).then(function (answers) {
deepEqual(answers[0], {
"data": {
"_id": "{\"identifier\":[\"d\"]}",
"identifier": "d",
"modified": shared.modified_date_list[0].toJSON()
},
"id": "{\"identifier\":[\"d\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Check storage content");
answers.slice(1).forEach(function (answer) {
deepEqual(answer, {
"data": {
"_id": "{\"identifier\":[\"d\"]}",
"identifier": "d",
"modified": shared.winner_modified_date.toJSON()
},
"id": "{\"identifier\":[\"d\"]}",
"method": "get",
"result": "success",
"status": 200,
"statusText": "Ok"
}, "Check storage content");
});
});
}
function unexpectedError(error) { this.jio = jIO.createJIO({
if (error instanceof Error) { type: "replicate",
deepEqual([ local_sub_storage: {
error.name + ": " + error.message, type: "replicatestorage200chechrepair"
error },
], "NO ERROR", "Unexpected error"); remote_sub_storage: {
} else { type: "replicatestorage200chechrepair"
deepEqual(error, "NO ERROR", "Unexpected error");
} }
} });
chain(). context.jio.repair(options)
// get without synchronizing anything .fail(function (error) {
then(putSimilarDocuments). ok(false, error);
then(repairDocumentNothingToSynchronize). })
then(repairDocumentNothingToSynchronizeTest). .always(function () {
// repair with synchronization start();
then(putDifferentDocuments). });
then(repairDocumentWithSynchronization).
then(repairDocumentWithSynchronizationTest).
// repair with 404 synchronization
then(putOneDocument).
then(repairDocumentWith404Synchronization).
then(repairDocumentWith404SynchronizationTest).
// XXX repair with attachment synchronization
// repair with unavailable storage
then(putDifferentDocuments2).
then(repairDocumentWithUnavailableStorage).
then(repairDocumentWithUnavailableStorageTest).
// End of scenario
then(null, unexpectedError).
then(start, start);
}); });
})); }(jIO, QUnit));
test/tests.html
View file @ 122da4b3
...@@ -38,6 +38,7 @@ ...@@ -38,6 +38,7 @@
<script src="jio.storage/erp5storage.tests.js"></script> <script src="jio.storage/erp5storage.tests.js"></script>
<script src="jio.storage/indexeddbstorage.tests.js"></script> <script src="jio.storage/indexeddbstorage.tests.js"></script>
<script src="jio.storage/uuidstorage.tests.js"></script> <script src="jio.storage/uuidstorage.tests.js"></script>
<script src="jio.storage/replicatestorage.tests.js"></script>
<!--script src="jio.storage/indexstorage.tests.js"></script--> <!--script src="jio.storage/indexstorage.tests.js"></script-->
<!--script src="jio.storage/dropboxstorage.tests.js"></script--> <!--script src="jio.storage/dropboxstorage.tests.js"></script-->
...@@ -58,11 +59,7 @@ ...@@ -58,11 +59,7 @@
<script src="../test/jio.storage/replicaterevisionstorage.tests.js"></script> <script src="../test/jio.storage/replicaterevisionstorage.tests.js"></script>
<script src="../src/jio.storage/splitstorage.js"></script> <script src="../src/jio.storage/splitstorage.js"></script>
<script src="../test/jio.storage/splitstorage.tests.js"></script> <script src="../test/jio.storage/splitstorage.tests.js"></script-->
<script src="../src/jio.storage/replicatestorage.js"></script>
<script src="../test/jio.storage/replicatestorage.tests.js"></script-->
</head> </head>
<body> <body>
<h1 id="qunit-header">jIO Tests</h1> <h1 id="qunit-header">jIO Tests</h1>
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7