ZFS file sync overhaul for API syncing
This mostly gets ZFS file syncing and file conflict resolution working with the API sync process. WebDAV will need to be updated separately. Known issues: - File sync progress is temporarily gone - File uploads can result in an unnecessary 412 loop on the next data sync - This causes Firefox to crash on one of my computers during tests, which would be easier to debug if it produced a crash log. Also: - Adds httpd.js for use in tests when FakeXMLHttpRequest can't be used (e.g., saveURI()). - Adds some additional test data files for attachment tests
This commit is contained in:
Dan Stillman
parent
6d46b06617
commit
73f4d28ab2
44 changed files with 11226 additions and 5239 deletions
5356
test/resource/httpd.js
Normal file
5356
test/resource/httpd.js
Normal file
File diff suppressed because it is too large
Load diff
BIN
test/tests/data/snapshot/img.gif
Normal file
BIN
test/tests/data/snapshot/img.gif
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 42 B |
8
test/tests/data/test.html
Normal file
8
test/tests/data/test.html
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8"/>
|
||||
</head>
|
||||
<body>
|
||||
<p>This is a test.</p>
|
||||
</body>
|
||||
</html>
|
||||
1
test/tests/data/test.txt
Normal file
1
test/tests/data/test.txt
Normal file
|
|
@ -0,0 +1 @@
|
|||
This is a test file.
|
||||
|
|
@ -537,6 +537,10 @@ describe("Zotero.Item", function () {
|
|||
file.append(filename);
|
||||
assert.equal(item.getFilePath(), file.path);
|
||||
});
|
||||
|
||||
it.skip("should get and set a filename for a base-dir-relative file", function* () {
|
||||
|
||||
})
|
||||
})
|
||||
|
||||
describe("#attachmentPath", function () {
|
||||
|
|
@ -608,11 +612,13 @@ describe("Zotero.Item", function () {
|
|||
assert.equal(OS.Path.basename(path), newName)
|
||||
yield OS.File.exists(path);
|
||||
|
||||
// File should be flagged for upload
|
||||
// DEBUG: Is this necessary?
|
||||
assert.equal(
|
||||
(yield Zotero.Sync.Storage.getSyncState(item.id)),
|
||||
(yield Zotero.Sync.Storage.Local.getSyncState(item.id)),
|
||||
Zotero.Sync.Storage.SYNC_STATE_TO_UPLOAD
|
||||
);
|
||||
assert.isNull(yield Zotero.Sync.Storage.getSyncedHash(item.id));
|
||||
assert.isNull(yield Zotero.Sync.Storage.Local.getSyncedHash(item.id));
|
||||
})
|
||||
})
|
||||
|
||||
|
|
|
|||
822
test/tests/storageEngineTest.js
Normal file
822
test/tests/storageEngineTest.js
Normal file
|
|
@ -0,0 +1,822 @@
|
|||
"use strict";
|
||||
|
||||
describe("Zotero.Sync.Storage.Engine", function () {
|
||||
Components.utils.import("resource://zotero-unit/httpd.js");
|
||||
|
||||
var win;
|
||||
var apiKey = Zotero.Utilities.randomString(24);
|
||||
var port = 16213;
|
||||
var baseURL = `http://localhost:${port}/`;
|
||||
var server;
|
||||
|
||||
var responses = {};
|
||||
|
||||
var setup = Zotero.Promise.coroutine(function* (options = {}) {
|
||||
server = sinon.fakeServer.create();
|
||||
server.autoRespond = true;
|
||||
|
||||
Components.utils.import("resource://zotero/concurrentCaller.js");
|
||||
var caller = new ConcurrentCaller(1);
|
||||
caller.setLogger(msg => Zotero.debug(msg));
|
||||
caller.stopOnError = true;
|
||||
|
||||
Components.utils.import("resource://zotero/config.js");
|
||||
var client = new Zotero.Sync.APIClient({
|
||||
baseURL,
|
||||
apiVersion: options.apiVersion || ZOTERO_CONFIG.API_VERSION,
|
||||
apiKey,
|
||||
caller,
|
||||
background: options.background || true
|
||||
});
|
||||
|
||||
var engine = new Zotero.Sync.Storage.Engine({
|
||||
apiClient: client,
|
||||
libraryID: options.libraryID || Zotero.Libraries.userLibraryID,
|
||||
stopOnError: true
|
||||
});
|
||||
|
||||
return { engine, client, caller };
|
||||
});
|
||||
|
||||
function setResponse(response) {
|
||||
setHTTPResponse(server, baseURL, response, responses);
|
||||
}
|
||||
|
||||
function parseQueryString(str) {
|
||||
var queryStringParams = str.split('&');
|
||||
var params = {};
|
||||
for (let param of queryStringParams) {
|
||||
let [ key, val ] = param.split('=');
|
||||
params[key] = decodeURIComponent(val);
|
||||
}
|
||||
return params;
|
||||
}
|
||||
|
||||
function assertAPIKey(request) {
|
||||
assert.equal(request.requestHeaders["Zotero-API-Key"], apiKey);
|
||||
}
|
||||
|
||||
//
|
||||
// Tests
|
||||
//
|
||||
before(function* () {
|
||||
})
|
||||
beforeEach(function* () {
|
||||
Zotero.debug("BEFORE HERE");
|
||||
yield resetDB({
|
||||
thisArg: this,
|
||||
skipBundledFiles: true
|
||||
});
|
||||
Zotero.debug("DONE RESET");
|
||||
win = yield loadZoteroPane();
|
||||
|
||||
Zotero.HTTP.mock = sinon.FakeXMLHttpRequest;
|
||||
|
||||
this.httpd = new HttpServer();
|
||||
this.httpd.start(port);
|
||||
|
||||
yield Zotero.Users.setCurrentUserID(1);
|
||||
yield Zotero.Users.setCurrentUsername("testuser");
|
||||
|
||||
// Set download-on-sync by default
|
||||
Zotero.Sync.Storage.Local.downloadOnSync(
|
||||
Zotero.Libraries.userLibraryID, true
|
||||
);
|
||||
Zotero.debug("DONE BEFORE");
|
||||
})
|
||||
afterEach(function* () {
|
||||
var defer = new Zotero.Promise.defer();
|
||||
this.httpd.stop(() => defer.resolve());
|
||||
yield defer.promise;
|
||||
win.close();
|
||||
})
|
||||
after(function* () {
|
||||
this.timeout(60000);
|
||||
//yield resetDB();
|
||||
win.close();
|
||||
})
|
||||
|
||||
|
||||
describe("ZFS", function () {
|
||||
describe("Syncing", function () {
|
||||
it("should skip downloads if no last storage sync time", function* () {
|
||||
var { engine, client, caller } = yield setup();
|
||||
|
||||
setResponse({
|
||||
method: "GET",
|
||||
url: "users/1/laststoragesync",
|
||||
status: 404
|
||||
});
|
||||
var result = yield engine.start();
|
||||
|
||||
assert.isFalse(result.localChanges);
|
||||
assert.isFalse(result.remoteChanges);
|
||||
assert.isFalse(result.syncRequired);
|
||||
|
||||
// Check last sync time
|
||||
assert.isFalse(Zotero.Libraries.userLibrary.lastStorageSync);
|
||||
})
|
||||
|
||||
it("should skip downloads if unchanged last storage sync time", function* () {
|
||||
var { engine, client, caller } = yield setup();
|
||||
|
||||
var newStorageSyncTime = Math.round(new Date().getTime() / 1000);
|
||||
var library = Zotero.Libraries.userLibrary;
|
||||
library.lastStorageSync = newStorageSyncTime;
|
||||
yield library.saveTx();
|
||||
setResponse({
|
||||
method: "GET",
|
||||
url: "users/1/laststoragesync",
|
||||
status: 200,
|
||||
text: "" + newStorageSyncTime
|
||||
});
|
||||
var result = yield engine.start();
|
||||
|
||||
assert.isFalse(result.localChanges);
|
||||
assert.isFalse(result.remoteChanges);
|
||||
assert.isFalse(result.syncRequired);
|
||||
|
||||
// Check last sync time
|
||||
assert.equal(library.lastStorageSync, newStorageSyncTime);
|
||||
})
|
||||
|
||||
it("should ignore a remotely missing file", function* () {
|
||||
var { engine, client, caller } = yield setup();
|
||||
|
||||
var item = new Zotero.Item("attachment");
|
||||
item.attachmentLinkMode = 'imported_file';
|
||||
item.attachmentPath = 'storage:test.txt';
|
||||
yield item.saveTx();
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item.id, Zotero.Sync.Storage.SYNC_STATE_TO_DOWNLOAD
|
||||
);
|
||||
|
||||
var newStorageSyncTime = Math.round(new Date().getTime() / 1000);
|
||||
setResponse({
|
||||
method: "GET",
|
||||
url: "users/1/laststoragesync",
|
||||
status: 200,
|
||||
text: "" + newStorageSyncTime
|
||||
});
|
||||
this.httpd.registerPathHandler(
|
||||
`/users/1/items/${item.key}/file`,
|
||||
{
|
||||
handle: function (request, response) {
|
||||
response.setStatusLine(null, 404, null);
|
||||
}
|
||||
}
|
||||
);
|
||||
var result = yield engine.start();
|
||||
|
||||
assert.isFalse(result.localChanges);
|
||||
assert.isFalse(result.remoteChanges);
|
||||
assert.isFalse(result.syncRequired);
|
||||
|
||||
// Check last sync time
|
||||
assert.equal(Zotero.Libraries.userLibrary.lastStorageSync, newStorageSyncTime);
|
||||
})
|
||||
|
||||
it("should handle a remotely failing file", function* () {
|
||||
var { engine, client, caller } = yield setup();
|
||||
|
||||
var item = new Zotero.Item("attachment");
|
||||
item.attachmentLinkMode = 'imported_file';
|
||||
item.attachmentPath = 'storage:test.txt';
|
||||
yield item.saveTx();
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item.id, Zotero.Sync.Storage.SYNC_STATE_TO_DOWNLOAD
|
||||
);
|
||||
|
||||
var newStorageSyncTime = Math.round(new Date().getTime() / 1000);
|
||||
setResponse({
|
||||
method: "GET",
|
||||
url: "users/1/laststoragesync",
|
||||
status: 200,
|
||||
text: "" + newStorageSyncTime
|
||||
});
|
||||
this.httpd.registerPathHandler(
|
||||
`/users/1/items/${item.key}/file`,
|
||||
{
|
||||
handle: function (request, response) {
|
||||
response.setStatusLine(null, 500, null);
|
||||
}
|
||||
}
|
||||
);
|
||||
// TODO: In stopOnError mode, this the promise is rejected.
|
||||
// This should probably test with stopOnError mode turned off instead.
|
||||
var e = yield getPromiseError(engine.start());
|
||||
assert.equal(e.message, Zotero.Sync.Storage.defaultError);
|
||||
})
|
||||
|
||||
it("should download a missing file", function* () {
|
||||
var { engine, client, caller } = yield setup();
|
||||
|
||||
var item = new Zotero.Item("attachment");
|
||||
item.attachmentLinkMode = 'imported_file';
|
||||
item.attachmentPath = 'storage:test.txt';
|
||||
// TODO: Test binary data
|
||||
var text = Zotero.Utilities.randomString();
|
||||
yield item.saveTx();
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item.id, Zotero.Sync.Storage.SYNC_STATE_TO_DOWNLOAD
|
||||
);
|
||||
|
||||
var mtime = "1441252524905";
|
||||
var md5 = Zotero.Utilities.Internal.md5(text)
|
||||
|
||||
var newStorageSyncTime = Math.round(new Date().getTime() / 1000);
|
||||
setResponse({
|
||||
method: "GET",
|
||||
url: "users/1/laststoragesync",
|
||||
status: 200,
|
||||
text: "" + newStorageSyncTime
|
||||
});
|
||||
var s3Path = `pretend-s3/${item.key}`;
|
||||
this.httpd.registerPathHandler(
|
||||
`/users/1/items/${item.key}/file`,
|
||||
{
|
||||
handle: function (request, response) {
|
||||
if (!request.hasHeader('Zotero-API-Key')) {
|
||||
response.setStatusLine(null, 403, "Forbidden");
|
||||
return;
|
||||
}
|
||||
var key = request.getHeader('Zotero-API-Key');
|
||||
if (key != apiKey) {
|
||||
response.setStatusLine(null, 403, "Invalid key");
|
||||
return;
|
||||
}
|
||||
response.setStatusLine(null, 302, "Found");
|
||||
response.setHeader("Zotero-File-Modification-Time", mtime, false);
|
||||
response.setHeader("Zotero-File-MD5", md5, false);
|
||||
response.setHeader("Zotero-File-Compressed", "No", false);
|
||||
response.setHeader("Location", baseURL + s3Path, false);
|
||||
}
|
||||
}
|
||||
);
|
||||
this.httpd.registerPathHandler(
|
||||
"/" + s3Path,
|
||||
{
|
||||
handle: function (request, response) {
|
||||
response.setStatusLine(null, 200, "OK");
|
||||
response.write(text);
|
||||
}
|
||||
}
|
||||
);
|
||||
var result = yield engine.start();
|
||||
|
||||
assert.isTrue(result.localChanges);
|
||||
assert.isFalse(result.remoteChanges);
|
||||
assert.isFalse(result.syncRequired);
|
||||
|
||||
// Check last sync time
|
||||
assert.equal(Zotero.Libraries.userLibrary.lastStorageSync, newStorageSyncTime);
|
||||
var contents = yield Zotero.File.getContentsAsync(yield item.getFilePathAsync());
|
||||
assert.equal(contents, text);
|
||||
})
|
||||
|
||||
it("should upload new files", function* () {
|
||||
var { engine, client, caller } = yield setup();
|
||||
|
||||
// Single file
|
||||
var file1 = getTestDataDirectory();
|
||||
file1.append('test.png');
|
||||
var item1 = yield Zotero.Attachments.importFromFile({ file: file1 });
|
||||
var mtime1 = yield item1.attachmentModificationTime;
|
||||
var hash1 = yield item1.attachmentHash;
|
||||
var path1 = item1.getFilePath();
|
||||
var filename1 = 'test.png';
|
||||
var size1 = (yield OS.File.stat(path1)).size;
|
||||
var contentType1 = 'image/png';
|
||||
var prefix1 = Zotero.Utilities.randomString();
|
||||
var suffix1 = Zotero.Utilities.randomString();
|
||||
var uploadKey1 = Zotero.Utilities.randomString(32, 'abcdef0123456789');
|
||||
|
||||
// HTML file with auxiliary image
|
||||
var file2 = OS.Path.join(getTestDataDirectory().path, 'snapshot', 'index.html');
|
||||
var parentItem = yield createDataObject('item');
|
||||
var item2 = yield Zotero.Attachments.importSnapshotFromFile({
|
||||
file: file2,
|
||||
url: 'http://example.com/',
|
||||
parentItemID: parentItem.id,
|
||||
title: 'Test',
|
||||
contentType: 'text/html',
|
||||
charset: 'utf-8'
|
||||
});
|
||||
var mtime2 = yield item2.attachmentModificationTime;
|
||||
var hash2 = yield item2.attachmentHash;
|
||||
var path2 = item2.getFilePath();
|
||||
var filename2 = 'index.html';
|
||||
var size2 = (yield OS.File.stat(path2)).size;
|
||||
var contentType2 = 'text/html';
|
||||
var charset2 = 'utf-8';
|
||||
var prefix2 = Zotero.Utilities.randomString();
|
||||
var suffix2 = Zotero.Utilities.randomString();
|
||||
var uploadKey2 = Zotero.Utilities.randomString(32, 'abcdef0123456789');
|
||||
|
||||
var deferreds = [];
|
||||
|
||||
setResponse({
|
||||
method: "GET",
|
||||
url: "users/1/laststoragesync",
|
||||
status: 404
|
||||
});
|
||||
// https://github.com/cjohansen/Sinon.JS/issues/607
|
||||
let fixSinonBug = ";charset=utf-8";
|
||||
server.respond(function (req) {
|
||||
// Get upload authorization for single file
|
||||
if (req.method == "POST"
|
||||
&& req.url == `${baseURL}users/1/items/${item1.key}/file`
|
||||
&& req.requestBody.indexOf('upload=') == -1) {
|
||||
assertAPIKey(req);
|
||||
assert.equal(req.requestHeaders["If-None-Match"], "*");
|
||||
assert.equal(
|
||||
req.requestHeaders["Content-Type"],
|
||||
"application/x-www-form-urlencoded" + fixSinonBug
|
||||
);
|
||||
|
||||
let parts = req.requestBody.split('&');
|
||||
let params = {};
|
||||
for (let part of parts) {
|
||||
let [key, val] = part.split('=');
|
||||
params[key] = decodeURIComponent(val);
|
||||
}
|
||||
assert.equal(params.md5, hash1);
|
||||
assert.equal(params.mtime, mtime1);
|
||||
assert.equal(params.filename, filename1);
|
||||
assert.equal(params.filesize, size1);
|
||||
assert.equal(params.contentType, contentType1);
|
||||
|
||||
req.respond(
|
||||
200,
|
||||
{
|
||||
"Content-Type": "application/json"
|
||||
},
|
||||
JSON.stringify({
|
||||
url: baseURL + "pretend-s3/1",
|
||||
contentType: contentType1,
|
||||
prefix: prefix1,
|
||||
suffix: suffix1,
|
||||
uploadKey: uploadKey1
|
||||
})
|
||||
);
|
||||
}
|
||||
// Get upload authorization for multi-file zip
|
||||
else if (req.method == "POST"
|
||||
&& req.url == `${baseURL}users/1/items/${item2.key}/file`
|
||||
&& req.requestBody.indexOf('upload=') == -1) {
|
||||
assertAPIKey(req);
|
||||
assert.equal(req.requestHeaders["If-None-Match"], "*");
|
||||
assert.equal(
|
||||
req.requestHeaders["Content-Type"],
|
||||
"application/x-www-form-urlencoded" + fixSinonBug
|
||||
);
|
||||
|
||||
// Verify ZIP hash
|
||||
let tmpZipPath = OS.Path.join(
|
||||
Zotero.getTempDirectory().path,
|
||||
item2.key + '.zip'
|
||||
);
|
||||
deferreds.push({
|
||||
promise: Zotero.Utilities.Internal.md5Async(tmpZipPath)
|
||||
.then(function (md5) {
|
||||
assert.equal(params.zipMD5, md5);
|
||||
})
|
||||
});
|
||||
|
||||
let parts = req.requestBody.split('&');
|
||||
let params = {};
|
||||
for (let part of parts) {
|
||||
let [key, val] = part.split('=');
|
||||
params[key] = decodeURIComponent(val);
|
||||
}
|
||||
Zotero.debug(params);
|
||||
assert.equal(params.md5, hash2);
|
||||
assert.notEqual(params.zipMD5, hash2);
|
||||
assert.equal(params.mtime, mtime2);
|
||||
assert.equal(params.filename, filename2);
|
||||
assert.equal(params.zipFilename, item2.key + ".zip");
|
||||
assert.isTrue(parseInt(params.filesize) == params.filesize);
|
||||
assert.equal(params.contentType, contentType2);
|
||||
assert.equal(params.charset, charset2);
|
||||
|
||||
req.respond(
|
||||
200,
|
||||
{
|
||||
"Content-Type": "application/json"
|
||||
},
|
||||
JSON.stringify({
|
||||
url: baseURL + "pretend-s3/2",
|
||||
contentType: 'application/zip',
|
||||
prefix: prefix2,
|
||||
suffix: suffix2,
|
||||
uploadKey: uploadKey2
|
||||
})
|
||||
);
|
||||
}
|
||||
// Upload single file to S3
|
||||
else if (req.method == "POST" && req.url == baseURL + "pretend-s3/1") {
|
||||
assert.equal(req.requestHeaders["Content-Type"], contentType1 + fixSinonBug);
|
||||
assert.equal(req.requestBody.size, (new Blob([prefix1, File(file1), suffix1]).size));
|
||||
req.respond(201, {}, "");
|
||||
}
|
||||
// Upload multi-file ZIP to S3
|
||||
else if (req.method == "POST" && req.url == baseURL + "pretend-s3/2") {
|
||||
assert.equal(req.requestHeaders["Content-Type"], "application/zip" + fixSinonBug);
|
||||
|
||||
// Verify uploaded ZIP file
|
||||
let tmpZipPath = OS.Path.join(
|
||||
Zotero.getTempDirectory().path,
|
||||
Zotero.Utilities.randomString() + '.zip'
|
||||
);
|
||||
|
||||
let deferred = Zotero.Promise.defer();
|
||||
deferreds.push(deferred);
|
||||
var reader = new FileReader();
|
||||
reader.addEventListener("loadend", Zotero.Promise.coroutine(function* () {
|
||||
try {
|
||||
|
||||
let file = yield OS.File.open(tmpZipPath, {
|
||||
create: true
|
||||
});
|
||||
|
||||
var contents = new Uint8Array(reader.result);
|
||||
contents = contents.slice(prefix2.length, suffix2.length * -1);
|
||||
yield file.write(contents);
|
||||
yield file.close();
|
||||
|
||||
var zr = Components.classes["@mozilla.org/libjar/zip-reader;1"]
|
||||
.createInstance(Components.interfaces.nsIZipReader);
|
||||
zr.open(Zotero.File.pathToFile(tmpZipPath));
|
||||
zr.test(null);
|
||||
var entries = zr.findEntries('*');
|
||||
var entryNames = [];
|
||||
while (entries.hasMore()) {
|
||||
entryNames.push(entries.getNext());
|
||||
}
|
||||
assert.equal(entryNames.length, 2);
|
||||
assert.sameMembers(entryNames, ['index.html', 'img.gif']);
|
||||
assert.equal(zr.getEntry('index.html').realSize, size2);
|
||||
assert.equal(zr.getEntry('img.gif').realSize, 42);
|
||||
|
||||
deferred.resolve();
|
||||
}
|
||||
catch (e) {
|
||||
deferred.reject(e);
|
||||
}
|
||||
}));
|
||||
reader.readAsArrayBuffer(req.requestBody);
|
||||
|
||||
req.respond(201, {}, "");
|
||||
}
|
||||
// Register single-file upload
|
||||
else if (req.method == "POST"
|
||||
&& req.url == `${baseURL}users/1/items/${item1.key}/file`
|
||||
&& req.requestBody.indexOf('upload=') != -1) {
|
||||
assertAPIKey(req);
|
||||
assert.equal(req.requestHeaders["If-None-Match"], "*");
|
||||
assert.equal(
|
||||
req.requestHeaders["Content-Type"],
|
||||
"application/x-www-form-urlencoded" + fixSinonBug
|
||||
);
|
||||
|
||||
let parts = req.requestBody.split('&');
|
||||
let params = {};
|
||||
for (let part of parts) {
|
||||
let [key, val] = part.split('=');
|
||||
params[key] = decodeURIComponent(val);
|
||||
}
|
||||
assert.equal(params.upload, uploadKey1);
|
||||
|
||||
req.respond(
|
||||
204,
|
||||
{
|
||||
"Last-Modified-Version": 10
|
||||
},
|
||||
""
|
||||
);
|
||||
}
|
||||
// Register multi-file upload
|
||||
else if (req.method == "POST"
|
||||
&& req.url == `${baseURL}users/1/items/${item2.key}/file`
|
||||
&& req.requestBody.indexOf('upload=') != -1) {
|
||||
assertAPIKey(req);
|
||||
assert.equal(req.requestHeaders["If-None-Match"], "*");
|
||||
assert.equal(
|
||||
req.requestHeaders["Content-Type"],
|
||||
"application/x-www-form-urlencoded" + fixSinonBug
|
||||
);
|
||||
|
||||
let parts = req.requestBody.split('&');
|
||||
let params = {};
|
||||
for (let part of parts) {
|
||||
let [key, val] = part.split('=');
|
||||
params[key] = decodeURIComponent(val);
|
||||
}
|
||||
assert.equal(params.upload, uploadKey2);
|
||||
|
||||
req.respond(
|
||||
204,
|
||||
{
|
||||
"Last-Modified-Version": 15
|
||||
},
|
||||
""
|
||||
);
|
||||
}
|
||||
})
|
||||
var newStorageSyncTime = Math.round(new Date().getTime() / 1000);
|
||||
setResponse({
|
||||
method: "POST",
|
||||
url: "users/1/laststoragesync",
|
||||
status: 200,
|
||||
text: "" + newStorageSyncTime
|
||||
});
|
||||
|
||||
// TODO: One-step uploads
|
||||
/*// https://github.com/cjohansen/Sinon.JS/issues/607
|
||||
let fixSinonBug = ";charset=utf-8";
|
||||
server.respond(function (req) {
|
||||
if (req.method == "POST" && req.url == `${baseURL}users/1/items/${item.key}/file`) {
|
||||
assert.equal(req.requestHeaders["If-None-Match"], "*");
|
||||
assert.equal(
|
||||
req.requestHeaders["Content-Type"],
|
||||
"application/json" + fixSinonBug
|
||||
);
|
||||
|
||||
let params = JSON.parse(req.requestBody);
|
||||
assert.equal(params.md5, hash);
|
||||
assert.equal(params.mtime, mtime);
|
||||
assert.equal(params.filename, filename);
|
||||
assert.equal(params.size, size);
|
||||
assert.equal(params.contentType, contentType);
|
||||
|
||||
req.respond(
|
||||
200,
|
||||
{
|
||||
"Content-Type": "application/json"
|
||||
},
|
||||
JSON.stringify({
|
||||
url: baseURL + "pretend-s3",
|
||||
headers: {
|
||||
"Content-Type": contentType,
|
||||
"Content-MD5": hash,
|
||||
//"Content-Length": params.size, process but don't return
|
||||
//"x-amz-meta-"
|
||||
},
|
||||
uploadKey
|
||||
})
|
||||
);
|
||||
}
|
||||
else if (req.method == "PUT" && req.url == baseURL + "pretend-s3") {
|
||||
assert.equal(req.requestHeaders["Content-Type"], contentType + fixSinonBug);
|
||||
assert.instanceOf(req.requestBody, File);
|
||||
req.respond(201, {}, "");
|
||||
}
|
||||
})*/
|
||||
var result = yield engine.start();
|
||||
|
||||
yield Zotero.Promise.all(deferreds.map(d => d.promise));
|
||||
|
||||
assert.isTrue(result.localChanges);
|
||||
assert.isTrue(result.remoteChanges);
|
||||
assert.isFalse(result.syncRequired);
|
||||
|
||||
// Check local objects
|
||||
assert.equal((yield Zotero.Sync.Storage.Local.getSyncedModificationTime(item1.id)), mtime1);
|
||||
assert.equal((yield Zotero.Sync.Storage.Local.getSyncedHash(item1.id)), hash1);
|
||||
assert.equal(item1.version, 10);
|
||||
assert.equal((yield Zotero.Sync.Storage.Local.getSyncedModificationTime(item2.id)), mtime2);
|
||||
assert.equal((yield Zotero.Sync.Storage.Local.getSyncedHash(item2.id)), hash2);
|
||||
assert.equal(item2.version, 15);
|
||||
|
||||
// Check last sync time
|
||||
assert.equal(Zotero.Libraries.userLibrary.lastStorageSync, newStorageSyncTime);
|
||||
})
|
||||
|
||||
it("should update local info for file that already exists on the server", function* () {
|
||||
var { engine, client, caller } = yield setup();
|
||||
|
||||
var file = getTestDataDirectory();
|
||||
file.append('test.png');
|
||||
var item = yield Zotero.Attachments.importFromFile({ file: file });
|
||||
item.version = 5;
|
||||
yield item.saveTx();
|
||||
var json = yield item.toJSON();
|
||||
yield Zotero.Sync.Data.Local.saveCacheObject('item', item.libraryID, json);
|
||||
|
||||
var mtime = yield item.attachmentModificationTime;
|
||||
var hash = yield item.attachmentHash;
|
||||
var path = item.getFilePath();
|
||||
var filename = 'test.png';
|
||||
var size = (yield OS.File.stat(path)).size;
|
||||
var contentType = 'image/png';
|
||||
|
||||
var newVersion = 10;
|
||||
setResponse({
|
||||
method: "POST",
|
||||
url: "users/1/laststoragesync",
|
||||
status: 200,
|
||||
text: "" + (Math.round(new Date().getTime() / 1000) - 50000)
|
||||
});
|
||||
// https://github.com/cjohansen/Sinon.JS/issues/607
|
||||
let fixSinonBug = ";charset=utf-8";
|
||||
server.respond(function (req) {
|
||||
// Get upload authorization for single file
|
||||
if (req.method == "POST"
|
||||
&& req.url == `${baseURL}users/1/items/${item.key}/file`
|
||||
&& req.requestBody.indexOf('upload=') == -1) {
|
||||
assertAPIKey(req);
|
||||
assert.equal(req.requestHeaders["If-None-Match"], "*");
|
||||
assert.equal(
|
||||
req.requestHeaders["Content-Type"],
|
||||
"application/x-www-form-urlencoded" + fixSinonBug
|
||||
);
|
||||
|
||||
req.respond(
|
||||
200,
|
||||
{
|
||||
"Content-Type": "application/json",
|
||||
"Last-Modified-Version": newVersion
|
||||
},
|
||||
JSON.stringify({
|
||||
exists: 1,
|
||||
})
|
||||
);
|
||||
}
|
||||
})
|
||||
var newStorageSyncTime = Math.round(new Date().getTime() / 1000);
|
||||
setResponse({
|
||||
method: "POST",
|
||||
url: "users/1/laststoragesync",
|
||||
status: 200,
|
||||
text: "" + newStorageSyncTime
|
||||
});
|
||||
|
||||
// TODO: One-step uploads
|
||||
var result = yield engine.start();
|
||||
|
||||
assert.isTrue(result.localChanges);
|
||||
assert.isTrue(result.remoteChanges);
|
||||
assert.isFalse(result.syncRequired);
|
||||
|
||||
// Check local objects
|
||||
assert.equal((yield Zotero.Sync.Storage.Local.getSyncedModificationTime(item.id)), mtime);
|
||||
assert.equal((yield Zotero.Sync.Storage.Local.getSyncedHash(item.id)), hash);
|
||||
assert.equal(item.version, newVersion);
|
||||
|
||||
// Check last sync time
|
||||
assert.equal(Zotero.Libraries.userLibrary.lastStorageSync, newStorageSyncTime);
|
||||
})
|
||||
})
|
||||
|
||||
describe("#_processUploadFile()", function () {
|
||||
it("should handle 412 with matching version and hash matching local file", function* () {
|
||||
var { engine, client, caller } = yield setup();
|
||||
var zfs = new Zotero.Sync.Storage.ZFS_Module({
|
||||
apiClient: client
|
||||
})
|
||||
|
||||
var filePath = OS.Path.join(getTestDataDirectory().path, 'test.png');
|
||||
var item = yield Zotero.Attachments.importFromFile({ file: filePath });
|
||||
item.version = 5;
|
||||
item.synced = true;
|
||||
yield item.saveTx();
|
||||
|
||||
var itemJSON = yield item.toResponseJSON();
|
||||
|
||||
// Set saved hash to a different value, which should be overwritten
|
||||
//
|
||||
// We're also testing cases where a hash isn't set for a file (e.g., if the
|
||||
// storage directory was transferred, the mtime doesn't match, but the file was
|
||||
// never downloaded), but there's no difference in behavior
|
||||
var dbHash = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
|
||||
yield Zotero.DB.executeTransaction(function* () {
|
||||
yield Zotero.Sync.Storage.Local.setSyncedHash(item.id, dbHash)
|
||||
});
|
||||
|
||||
server.respond(function (req) {
|
||||
if (req.method == "POST"
|
||||
&& req.url == `${baseURL}users/1/items/${item.key}/file`
|
||||
&& req.requestBody.indexOf('upload=') == -1
|
||||
&& req.requestHeaders["If-Match"] == dbHash) {
|
||||
req.respond(
|
||||
412,
|
||||
{
|
||||
"Content-Type": "application/json",
|
||||
"Last-Modified-Version": 5
|
||||
},
|
||||
"ETag does not match current version of file"
|
||||
);
|
||||
}
|
||||
})
|
||||
setResponse({
|
||||
method: "GET",
|
||||
url: `users/1/items?format=json&itemKey=${item.key}&includeTrashed=1`,
|
||||
status: 200,
|
||||
text: JSON.stringify([itemJSON])
|
||||
});
|
||||
|
||||
var result = yield zfs._processUploadFile({
|
||||
name: item.libraryKey
|
||||
});
|
||||
yield assert.eventually.equal(
|
||||
Zotero.Sync.Storage.Local.getSyncedHash(item.id), itemJSON.data.md5
|
||||
);
|
||||
assert.isFalse(result.localChanges);
|
||||
assert.isFalse(result.remoteChanges);
|
||||
assert.isFalse(result.syncRequired);
|
||||
assert.isFalse(result.fileSyncRequired);
|
||||
})
|
||||
|
||||
it("should handle 412 with matching version and hash not matching local file", function* () {
|
||||
var { engine, client, caller } = yield setup();
|
||||
var zfs = new Zotero.Sync.Storage.ZFS_Module({
|
||||
apiClient: client
|
||||
})
|
||||
|
||||
var filePath = OS.Path.join(getTestDataDirectory().path, 'test.png');
|
||||
var item = yield Zotero.Attachments.importFromFile({ file: filePath });
|
||||
item.version = 5;
|
||||
item.synced = true;
|
||||
yield item.saveTx();
|
||||
|
||||
var fileHash = yield item.attachmentHash;
|
||||
var itemJSON = yield item.toResponseJSON();
|
||||
itemJSON.data.md5 = 'aaaaaaaaaaaaaaaaaaaaaaaa'
|
||||
|
||||
server.respond(function (req) {
|
||||
if (req.method == "POST"
|
||||
&& req.url == `${baseURL}users/1/items/${item.key}/file`
|
||||
&& req.requestBody.indexOf('upload=') == -1
|
||||
&& req.requestHeaders["If-None-Match"] == "*") {
|
||||
req.respond(
|
||||
412,
|
||||
{
|
||||
"Content-Type": "application/json",
|
||||
"Last-Modified-Version": 5
|
||||
},
|
||||
"If-None-Match: * set but file exists"
|
||||
);
|
||||
}
|
||||
})
|
||||
setResponse({
|
||||
method: "GET",
|
||||
url: `users/1/items?format=json&itemKey=${item.key}&includeTrashed=1`,
|
||||
status: 200,
|
||||
text: JSON.stringify([itemJSON])
|
||||
});
|
||||
|
||||
var result = yield zfs._processUploadFile({
|
||||
name: item.libraryKey
|
||||
});
|
||||
yield assert.eventually.isNull(Zotero.Sync.Storage.Local.getSyncedHash(item.id));
|
||||
yield assert.eventually.equal(
|
||||
Zotero.Sync.Storage.Local.getSyncState(item.id),
|
||||
Zotero.Sync.Storage.SYNC_STATE_IN_CONFLICT
|
||||
);
|
||||
assert.isFalse(result.localChanges);
|
||||
assert.isFalse(result.remoteChanges);
|
||||
assert.isFalse(result.syncRequired);
|
||||
assert.isTrue(result.fileSyncRequired);
|
||||
})
|
||||
|
||||
it("should handle 412 with greater version", function* () {
|
||||
var { engine, client, caller } = yield setup();
|
||||
var zfs = new Zotero.Sync.Storage.ZFS_Module({
|
||||
apiClient: client
|
||||
})
|
||||
|
||||
var file = getTestDataDirectory();
|
||||
file.append('test.png');
|
||||
var item = yield Zotero.Attachments.importFromFile({ file });
|
||||
item.version = 5;
|
||||
item.synced = true;
|
||||
yield item.saveTx();
|
||||
|
||||
server.respond(function (req) {
|
||||
if (req.method == "POST"
|
||||
&& req.url == `${baseURL}users/1/items/${item.key}/file`
|
||||
&& req.requestBody.indexOf('upload=') == -1
|
||||
&& req.requestHeaders["If-None-Match"] == "*") {
|
||||
req.respond(
|
||||
412,
|
||||
{
|
||||
"Content-Type": "application/json",
|
||||
"Last-Modified-Version": 10
|
||||
},
|
||||
"If-None-Match: * set but file exists"
|
||||
);
|
||||
}
|
||||
})
|
||||
|
||||
var result = yield zfs._processUploadFile({
|
||||
name: item.libraryKey
|
||||
});
|
||||
assert.equal(item.version, 5);
|
||||
assert.equal(item.synced, true);
|
||||
assert.isFalse(result.localChanges);
|
||||
assert.isFalse(result.remoteChanges);
|
||||
assert.isTrue(result.syncRequired);
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
329
test/tests/storageLocalTest.js
Normal file
329
test/tests/storageLocalTest.js
Normal file
|
|
@ -0,0 +1,329 @@
|
|||
"use strict";
|
||||
|
||||
describe("Zotero.Sync.Storage.Local", function () {
|
||||
var win;
|
||||
|
||||
before(function* () {
|
||||
win = yield loadBrowserWindow();
|
||||
});
|
||||
beforeEach(function* () {
|
||||
yield resetDB({
|
||||
thisArg: this
|
||||
})
|
||||
})
|
||||
after(function () {
|
||||
if (win) {
|
||||
win.close();
|
||||
}
|
||||
});
|
||||
|
||||
describe("#checkForUpdatedFiles()", function () {
|
||||
it("should flag modified file for upload and return it", function* () {
|
||||
// Create attachment
|
||||
let item = yield importFileAttachment('test.txt')
|
||||
var hash = yield item.attachmentHash;
|
||||
// Set file mtime to the past (without milliseconds, which aren't used on OS X)
|
||||
var mtime = (Math.floor(new Date().getTime() / 1000) * 1000) - 1000;
|
||||
yield OS.File.setDates((yield item.getFilePathAsync()), null, mtime);
|
||||
|
||||
// Mark as synced, so it will be checked
|
||||
yield Zotero.DB.executeTransaction(function* () {
|
||||
yield Zotero.Sync.Storage.Local.setSyncedHash(item.id, hash);
|
||||
yield Zotero.Sync.Storage.Local.setSyncedModificationTime(item.id, mtime);
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item.id, Zotero.Sync.Storage.SYNC_STATE_IN_SYNC
|
||||
);
|
||||
});
|
||||
|
||||
// Update mtime and contents
|
||||
var path = yield item.getFilePathAsync();
|
||||
yield OS.File.setDates(path);
|
||||
yield Zotero.File.putContentsAsync(path, Zotero.Utilities.randomString());
|
||||
|
||||
// File should be returned
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
var changed = yield Zotero.Sync.Storage.Local.checkForUpdatedFiles(libraryID);
|
||||
|
||||
yield item.eraseTx();
|
||||
|
||||
assert.equal(changed, true);
|
||||
assert.equal(
|
||||
(yield Zotero.Sync.Storage.Local.getSyncState(item.id)),
|
||||
Zotero.Sync.Storage.SYNC_STATE_TO_UPLOAD
|
||||
);
|
||||
})
|
||||
|
||||
it("should skip a file if mod time hasn't changed", function* () {
|
||||
// Create attachment
|
||||
let item = yield importFileAttachment('test.txt')
|
||||
var hash = yield item.attachmentHash;
|
||||
var mtime = yield item.attachmentModificationTime;
|
||||
|
||||
// Mark as synced, so it will be checked
|
||||
yield Zotero.DB.executeTransaction(function* () {
|
||||
yield Zotero.Sync.Storage.Local.setSyncedHash(item.id, hash);
|
||||
yield Zotero.Sync.Storage.Local.setSyncedModificationTime(item.id, mtime);
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item.id, Zotero.Sync.Storage.SYNC_STATE_IN_SYNC
|
||||
);
|
||||
});
|
||||
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
var changed = yield Zotero.Sync.Storage.Local.checkForUpdatedFiles(libraryID);
|
||||
var syncState = yield Zotero.Sync.Storage.Local.getSyncState(item.id);
|
||||
|
||||
yield item.eraseTx();
|
||||
|
||||
assert.isFalse(changed);
|
||||
assert.equal(syncState, Zotero.Sync.Storage.SYNC_STATE_IN_SYNC);
|
||||
})
|
||||
|
||||
it("should skip a file if mod time has changed but contents haven't", function* () {
|
||||
// Create attachment
|
||||
let item = yield importFileAttachment('test.txt')
|
||||
var hash = yield item.attachmentHash;
|
||||
// Set file mtime to the past (without milliseconds, which aren't used on OS X)
|
||||
var mtime = (Math.floor(new Date().getTime() / 1000) * 1000) - 1000;
|
||||
yield OS.File.setDates((yield item.getFilePathAsync()), null, mtime);
|
||||
|
||||
// Mark as synced, so it will be checked
|
||||
yield Zotero.DB.executeTransaction(function* () {
|
||||
yield Zotero.Sync.Storage.Local.setSyncedHash(item.id, hash);
|
||||
yield Zotero.Sync.Storage.Local.setSyncedModificationTime(item.id, mtime);
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item.id, Zotero.Sync.Storage.SYNC_STATE_IN_SYNC
|
||||
);
|
||||
});
|
||||
|
||||
// Update mtime, but not contents
|
||||
var path = yield item.getFilePathAsync();
|
||||
yield OS.File.setDates(path);
|
||||
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
var changed = yield Zotero.Sync.Storage.Local.checkForUpdatedFiles(libraryID);
|
||||
var syncState = yield Zotero.Sync.Storage.Local.getSyncState(item.id);
|
||||
var syncedModTime = yield Zotero.Sync.Storage.Local.getSyncedModificationTime(item.id);
|
||||
var newModTime = yield item.attachmentModificationTime;
|
||||
|
||||
yield item.eraseTx();
|
||||
|
||||
assert.isFalse(changed);
|
||||
assert.equal(syncState, Zotero.Sync.Storage.SYNC_STATE_IN_SYNC);
|
||||
assert.equal(syncedModTime, newModTime);
|
||||
})
|
||||
})
|
||||
|
||||
describe("#processDownload()", function () {
|
||||
var file1Name = 'index.html';
|
||||
var file1Contents = '<html><body>Test</body></html>';
|
||||
var file2Name = 'test.txt';
|
||||
var file2Contents = 'Test';
|
||||
|
||||
var createZIP = Zotero.Promise.coroutine(function* (zipFile) {
|
||||
var tmpDir = Zotero.getTempDirectory().path;
|
||||
var zipDir = OS.Path.join(tmpDir, Zotero.Utilities.randomString());
|
||||
yield OS.File.makeDir(zipDir);
|
||||
|
||||
yield Zotero.File.putContentsAsync(OS.Path.join(zipDir, file1Name), file1Contents);
|
||||
yield Zotero.File.putContentsAsync(OS.Path.join(zipDir, file2Name), file2Contents);
|
||||
|
||||
yield Zotero.File.zipDirectory(zipDir, zipFile);
|
||||
yield OS.File.removeDir(zipDir);
|
||||
});
|
||||
|
||||
it("should download and extract a ZIP file into the attachment directory", function* () {
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
var parentItem = yield createDataObject('item');
|
||||
var key = Zotero.DataObjectUtilities.generateKey();
|
||||
|
||||
var tmpDir = Zotero.getTempDirectory().path;
|
||||
var zipFile = OS.Path.join(tmpDir, key + '.tmp');
|
||||
yield createZIP(zipFile);
|
||||
|
||||
var md5 = Zotero.Utilities.Internal.md5(Zotero.File.pathToFile(zipFile));
|
||||
var mtime = 1445667239000;
|
||||
|
||||
var json = {
|
||||
key,
|
||||
version: 10,
|
||||
itemType: 'attachment',
|
||||
linkMode: 'imported_url',
|
||||
url: 'https://example.com',
|
||||
filename: file1Name,
|
||||
contentType: 'text/html',
|
||||
charset: 'utf-8',
|
||||
md5,
|
||||
mtime
|
||||
};
|
||||
yield Zotero.Sync.Data.Local.saveCacheObjects(
|
||||
'item', libraryID, [json]
|
||||
);
|
||||
yield Zotero.Sync.Data.Local.processSyncCacheForObjectType(
|
||||
libraryID, 'item', { stopOnError: true }
|
||||
);
|
||||
var item = yield Zotero.Items.getByLibraryAndKeyAsync(libraryID, key);
|
||||
yield Zotero.Sync.Storage.Local.processDownload({
|
||||
item,
|
||||
md5,
|
||||
mtime,
|
||||
compressed: true
|
||||
});
|
||||
yield OS.File.remove(zipFile);
|
||||
|
||||
yield assert.eventually.equal(
|
||||
item.attachmentHash, Zotero.Utilities.Internal.md5(file1Contents)
|
||||
);
|
||||
yield assert.eventually.equal(item.attachmentModificationTime, mtime);
|
||||
})
|
||||
})
|
||||
|
||||
describe("#_deleteExistingAttachmentFiles()", function () {
|
||||
it("should delete all files", function* () {
|
||||
var item = yield importFileAttachment('test.html');
|
||||
var path = OS.Path.dirname(item.getFilePath());
|
||||
var files = ['a', 'b', 'c', 'd'];
|
||||
for (let file of files) {
|
||||
yield Zotero.File.putContentsAsync(OS.Path.join(path, file), file);
|
||||
}
|
||||
yield Zotero.Sync.Storage.Local._deleteExistingAttachmentFiles(item);
|
||||
for (let file of files) {
|
||||
assert.isFalse(
|
||||
(yield OS.File.exists(OS.Path.join(path, file))),
|
||||
`File '${file}' doesn't exist`
|
||||
);
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
describe("#getConflicts()", function () {
|
||||
it("should return an array of objects for attachments in conflict", function* () {
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
|
||||
var item1 = yield importFileAttachment('test.png');
|
||||
item1.version = 10;
|
||||
yield item1.saveTx();
|
||||
var item2 = yield importFileAttachment('test.txt');
|
||||
var item3 = yield importFileAttachment('test.html');
|
||||
item3.version = 11;
|
||||
yield item3.saveTx();
|
||||
|
||||
var json1 = yield item1.toJSON();
|
||||
var json3 = yield item3.toJSON();
|
||||
// Change remote mtimes
|
||||
// Round to nearest second because OS X doesn't support ms resolution
|
||||
var now = Math.round(new Date().getTime() / 1000) * 1000;
|
||||
json1.mtime = now - 10000;
|
||||
json3.mtime = now - 20000;
|
||||
yield Zotero.Sync.Data.Local.saveCacheObjects('item', libraryID, [json1, json3]);
|
||||
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item1.id, Zotero.Sync.Storage.SYNC_STATE_IN_CONFLICT
|
||||
);
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item3.id, Zotero.Sync.Storage.SYNC_STATE_IN_CONFLICT
|
||||
);
|
||||
|
||||
var conflicts = yield Zotero.Sync.Storage.Local.getConflicts(libraryID);
|
||||
assert.lengthOf(conflicts, 2);
|
||||
|
||||
var item1Conflict = conflicts.find(x => x.left.key == item1.key);
|
||||
assert.equal(
|
||||
item1Conflict.left.dateModified,
|
||||
Zotero.Date.dateToISO(new Date(yield item1.attachmentModificationTime))
|
||||
);
|
||||
assert.equal(
|
||||
item1Conflict.right.dateModified,
|
||||
Zotero.Date.dateToISO(new Date(json1.mtime))
|
||||
);
|
||||
|
||||
var item3Conflict = conflicts.find(x => x.left.key == item3.key);
|
||||
assert.equal(
|
||||
item3Conflict.left.dateModified,
|
||||
Zotero.Date.dateToISO(new Date(yield item3.attachmentModificationTime))
|
||||
);
|
||||
assert.equal(
|
||||
item3Conflict.right.dateModified,
|
||||
Zotero.Date.dateToISO(new Date(json3.mtime))
|
||||
);
|
||||
})
|
||||
})
|
||||
|
||||
describe("#resolveConflicts()", function () {
|
||||
it("should show the conflict resolution window on attachment conflicts", function* () {
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
|
||||
var item1 = yield importFileAttachment('test.png');
|
||||
item1.version = 10;
|
||||
yield item1.saveTx();
|
||||
var item2 = yield importFileAttachment('test.txt');
|
||||
var item3 = yield importFileAttachment('test.html');
|
||||
item3.version = 11;
|
||||
yield item3.saveTx();
|
||||
|
||||
var json1 = yield item1.toJSON();
|
||||
var json3 = yield item3.toJSON();
|
||||
// Change remote mtimes
|
||||
json1.mtime = new Date().getTime() + 10000;
|
||||
json3.mtime = new Date().getTime() - 10000;
|
||||
yield Zotero.Sync.Data.Local.saveCacheObjects('item', libraryID, [json1, json3]);
|
||||
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item1.id, Zotero.Sync.Storage.SYNC_STATE_IN_CONFLICT
|
||||
);
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item3.id, Zotero.Sync.Storage.SYNC_STATE_IN_CONFLICT
|
||||
);
|
||||
|
||||
var promise = waitForWindow('chrome://zotero/content/merge.xul', function (dialog) {
|
||||
var doc = dialog.document;
|
||||
var wizard = doc.documentElement;
|
||||
var mergeGroup = wizard.getElementsByTagName('zoteromergegroup')[0];
|
||||
|
||||
// 1 (remote)
|
||||
// Later remote version should be selected
|
||||
assert.equal(mergeGroup.rightpane.getAttribute('selected'), 'true');
|
||||
|
||||
// Check checkbox text
|
||||
assert.equal(
|
||||
doc.getElementById('resolve-all').label,
|
||||
Zotero.getString('sync.conflict.resolveAllRemote')
|
||||
);
|
||||
|
||||
// Select local object
|
||||
mergeGroup.leftpane.click();
|
||||
assert.equal(mergeGroup.leftpane.getAttribute('selected'), 'true');
|
||||
|
||||
wizard.getButton('next').click();
|
||||
|
||||
// 2 (local)
|
||||
// Later local version should be selected
|
||||
assert.equal(mergeGroup.leftpane.getAttribute('selected'), 'true');
|
||||
// Select remote object
|
||||
mergeGroup.rightpane.click();
|
||||
assert.equal(mergeGroup.rightpane.getAttribute('selected'), 'true');
|
||||
|
||||
if (Zotero.isMac) {
|
||||
assert.isTrue(wizard.getButton('next').hidden);
|
||||
assert.isFalse(wizard.getButton('finish').hidden);
|
||||
}
|
||||
else {
|
||||
// TODO
|
||||
}
|
||||
wizard.getButton('finish').click();
|
||||
})
|
||||
yield Zotero.Sync.Storage.Local.resolveConflicts(libraryID);
|
||||
yield promise;
|
||||
|
||||
yield assert.eventually.equal(
|
||||
Zotero.Sync.Storage.Local.getSyncState(item1.id),
|
||||
Zotero.Sync.Storage.SYNC_STATE_FORCE_UPLOAD
|
||||
);
|
||||
yield assert.eventually.equal(
|
||||
Zotero.Sync.Storage.Local.getSyncState(item3.id),
|
||||
Zotero.Sync.Storage.SYNC_STATE_FORCE_DOWNLOAD
|
||||
);
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
})
|
||||
22
test/tests/storageRequestTest.js
Normal file
22
test/tests/storageRequestTest.js
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
"use strict";
|
||||
|
||||
describe("Zotero.Sync.Storage.Request", function () {
|
||||
describe("#run()", function () {
|
||||
it("should run a request and wait for it to complete", function* () {
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
var count = 0;
|
||||
var request = new Zotero.Sync.Storage.Request({
|
||||
type: 'download',
|
||||
libraryID,
|
||||
name: "1/AAAAAAAA",
|
||||
onStart: Zotero.Promise.coroutine(function* () {
|
||||
yield Zotero.Promise.delay(25);
|
||||
count++;
|
||||
return new Zotero.Sync.Storage.Result;
|
||||
})
|
||||
});
|
||||
var results = yield request.start();
|
||||
assert.equal(count, 1);
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
@ -19,28 +19,20 @@ describe("Zotero.Sync.Data.Engine", function () {
|
|||
var caller = new ConcurrentCaller(1);
|
||||
caller.setLogger(msg => Zotero.debug(msg));
|
||||
caller.stopOnError = true;
|
||||
caller.onError = function (e) {
|
||||
Zotero.logError(e);
|
||||
if (options.onError) {
|
||||
options.onError(e);
|
||||
}
|
||||
if (e.fatal) {
|
||||
caller.stop();
|
||||
throw e;
|
||||
}
|
||||
};
|
||||
|
||||
Components.utils.import("resource://zotero/config.js");
|
||||
var client = new Zotero.Sync.APIClient({
|
||||
baseURL: baseURL,
|
||||
baseURL,
|
||||
apiVersion: options.apiVersion || ZOTERO_CONFIG.API_VERSION,
|
||||
apiKey: apiKey,
|
||||
concurrentCaller: caller,
|
||||
apiKey,
|
||||
caller,
|
||||
background: options.background || true
|
||||
});
|
||||
|
||||
var engine = new Zotero.Sync.Data.Engine({
|
||||
apiClient: client,
|
||||
libraryID: options.libraryID || Zotero.Libraries.userLibraryID
|
||||
libraryID: options.libraryID || Zotero.Libraries.userLibraryID,
|
||||
stopOnError: true
|
||||
});
|
||||
|
||||
return { engine, client, caller };
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ describe("Zotero.Sync.Data.Local", function() {
|
|||
describe("#processSyncCacheForObjectType()", function () {
|
||||
var types = Zotero.DataObjectUtilities.getTypes();
|
||||
|
||||
it("should update local version number if remote version is identical", function* () {
|
||||
it("should update local version number and mark as synced if remote version is identical", function* () {
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
|
||||
for (let type of types) {
|
||||
|
|
@ -24,11 +24,167 @@ describe("Zotero.Sync.Data.Local", function() {
|
|||
yield Zotero.Sync.Data.Local.processSyncCacheForObjectType(
|
||||
libraryID, type, { stopOnError: true }
|
||||
);
|
||||
assert.equal(
|
||||
objectsClass.getByLibraryAndKey(libraryID, obj.key).version, 10
|
||||
);
|
||||
let localObj = objectsClass.getByLibraryAndKey(libraryID, obj.key);
|
||||
assert.equal(localObj.version, 10);
|
||||
assert.isTrue(localObj.synced);
|
||||
}
|
||||
})
|
||||
|
||||
it("should keep local item changes while applying non-conflicting remote changes", function* () {
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
|
||||
var type = 'item';
|
||||
let objectsClass = Zotero.DataObjectUtilities.getObjectsClassForObjectType(type);
|
||||
let obj = yield createDataObject(type, { version: 5 });
|
||||
let data = yield obj.toJSON();
|
||||
yield Zotero.Sync.Data.Local.saveCacheObjects(
|
||||
type, libraryID, [data]
|
||||
);
|
||||
|
||||
// Change local title
|
||||
yield modifyDataObject(obj)
|
||||
var changedTitle = obj.getField('title');
|
||||
|
||||
// Save remote version to cache without title but with changed place
|
||||
data.key = obj.key;
|
||||
data.version = 10;
|
||||
var changedPlace = data.place = 'New York';
|
||||
let json = {
|
||||
key: obj.key,
|
||||
version: 10,
|
||||
data: data
|
||||
};
|
||||
yield Zotero.Sync.Data.Local.saveCacheObjects(
|
||||
type, libraryID, [json]
|
||||
);
|
||||
|
||||
yield Zotero.Sync.Data.Local.processSyncCacheForObjectType(
|
||||
libraryID, type, { stopOnError: true }
|
||||
);
|
||||
assert.equal(obj.version, 10);
|
||||
assert.equal(obj.getField('title'), changedTitle);
|
||||
assert.equal(obj.getField('place'), changedPlace);
|
||||
})
|
||||
|
||||
it("should mark new attachment items for download", function* () {
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
Zotero.Sync.Storage.Local.setModeForLibrary(libraryID, 'zfs');
|
||||
|
||||
var key = Zotero.DataObjectUtilities.generateKey();
|
||||
var version = 10;
|
||||
var json = {
|
||||
key,
|
||||
version,
|
||||
data: {
|
||||
key,
|
||||
version,
|
||||
itemType: 'attachment',
|
||||
linkMode: 'imported_file',
|
||||
md5: '57f8a4fda823187b91e1191487b87fe6',
|
||||
mtime: 1442261130615
|
||||
}
|
||||
};
|
||||
|
||||
yield Zotero.Sync.Data.Local.saveCacheObjects(
|
||||
'item', Zotero.Libraries.userLibraryID, [json]
|
||||
);
|
||||
yield Zotero.Sync.Data.Local.processSyncCacheForObjectType(
|
||||
libraryID, 'item', { stopOnError: true }
|
||||
);
|
||||
var id = Zotero.Items.getIDFromLibraryAndKey(libraryID, key);
|
||||
assert.equal(
|
||||
(yield Zotero.Sync.Storage.Local.getSyncState(id)),
|
||||
Zotero.Sync.Storage.SYNC_STATE_TO_DOWNLOAD
|
||||
);
|
||||
})
|
||||
|
||||
it("should mark updated attachment items for download", function* () {
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
Zotero.Sync.Storage.Local.setModeForLibrary(libraryID, 'zfs');
|
||||
|
||||
var item = yield importFileAttachment('test.png');
|
||||
item.version = 5;
|
||||
item.synced = true;
|
||||
yield item.saveTx();
|
||||
|
||||
// Set file as synced
|
||||
yield Zotero.DB.executeTransaction(function* () {
|
||||
yield Zotero.Sync.Storage.Local.setSyncedModificationTime(
|
||||
item.id, (yield item.attachmentModificationTime)
|
||||
);
|
||||
yield Zotero.Sync.Storage.Local.setSyncedHash(
|
||||
item.id, (yield item.attachmentHash)
|
||||
);
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item.id, Zotero.Sync.Storage.SYNC_STATE_IN_SYNC
|
||||
);
|
||||
});
|
||||
|
||||
// Simulate download of version with updated attachment
|
||||
var json = yield item.toResponseJSON();
|
||||
json.version = 10;
|
||||
json.data.version = 10;
|
||||
json.data.md5 = '57f8a4fda823187b91e1191487b87fe6';
|
||||
json.data.mtime = new Date().getTime() + 10000;
|
||||
yield Zotero.Sync.Data.Local.saveCacheObjects(
|
||||
'item', Zotero.Libraries.userLibraryID, [json]
|
||||
);
|
||||
|
||||
yield Zotero.Sync.Data.Local.processSyncCacheForObjectType(
|
||||
libraryID, 'item', { stopOnError: true }
|
||||
);
|
||||
|
||||
assert.equal(
|
||||
(yield Zotero.Sync.Storage.Local.getSyncState(item.id)),
|
||||
Zotero.Sync.Storage.SYNC_STATE_TO_DOWNLOAD
|
||||
);
|
||||
})
|
||||
|
||||
it("should ignore attachment metadata when resolving metadata conflict", function* () {
|
||||
var libraryID = Zotero.Libraries.userLibraryID;
|
||||
Zotero.Sync.Storage.Local.setModeForLibrary(libraryID, 'zfs');
|
||||
|
||||
var item = yield importFileAttachment('test.png');
|
||||
item.version = 5;
|
||||
yield item.saveTx();
|
||||
var json = yield item.toResponseJSON();
|
||||
yield Zotero.Sync.Data.Local.saveCacheObjects('item', libraryID, [json]);
|
||||
|
||||
// Set file as synced
|
||||
yield Zotero.DB.executeTransaction(function* () {
|
||||
yield Zotero.Sync.Storage.Local.setSyncedModificationTime(
|
||||
item.id, (yield item.attachmentModificationTime)
|
||||
);
|
||||
yield Zotero.Sync.Storage.Local.setSyncedHash(
|
||||
item.id, (yield item.attachmentHash)
|
||||
);
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item.id, Zotero.Sync.Storage.SYNC_STATE_IN_SYNC
|
||||
);
|
||||
});
|
||||
|
||||
// Modify title locally, leaving item unsynced
|
||||
var newTitle = Zotero.Utilities.randomString();
|
||||
item.setField('title', newTitle);
|
||||
yield item.saveTx();
|
||||
|
||||
// Simulate download of version with original title but updated attachment
|
||||
json.version = 10;
|
||||
json.data.version = 10;
|
||||
json.data.md5 = '57f8a4fda823187b91e1191487b87fe6';
|
||||
json.data.mtime = new Date().getTime() + 10000;
|
||||
yield Zotero.Sync.Data.Local.saveCacheObjects('item', libraryID, [json]);
|
||||
|
||||
yield Zotero.Sync.Data.Local.processSyncCacheForObjectType(
|
||||
libraryID, 'item', { stopOnError: true }
|
||||
);
|
||||
|
||||
assert.equal(item.getField('title'), newTitle);
|
||||
assert.equal(
|
||||
(yield Zotero.Sync.Storage.Local.getSyncState(item.id)),
|
||||
Zotero.Sync.Storage.SYNC_STATE_TO_DOWNLOAD
|
||||
);
|
||||
})
|
||||
})
|
||||
|
||||
describe("Conflict Resolution", function () {
|
||||
|
|
@ -232,7 +388,10 @@ describe("Zotero.Sync.Data.Local", function() {
|
|||
jsonData.title = Zotero.Utilities.randomString();
|
||||
yield Zotero.Sync.Data.Local.saveCacheObjects(type, libraryID, [json]);
|
||||
|
||||
var windowOpened = false;
|
||||
waitForWindow('chrome://zotero/content/merge.xul', function (dialog) {
|
||||
windowOpened = true;
|
||||
|
||||
var doc = dialog.document;
|
||||
var wizard = doc.documentElement;
|
||||
var mergeGroup = wizard.getElementsByTagName('zoteromergegroup')[0];
|
||||
|
|
@ -240,12 +399,14 @@ describe("Zotero.Sync.Data.Local", function() {
|
|||
// Remote version should be selected by default
|
||||
assert.equal(mergeGroup.rightpane.getAttribute('selected'), 'true');
|
||||
assert.ok(mergeGroup.leftpane.pane.onclick);
|
||||
// Select local deleted version
|
||||
mergeGroup.leftpane.pane.click();
|
||||
wizard.getButton('finish').click();
|
||||
})
|
||||
yield Zotero.Sync.Data.Local.processSyncCacheForObjectType(
|
||||
libraryID, type, { stopOnError: true }
|
||||
);
|
||||
assert.isTrue(windowOpened);
|
||||
|
||||
obj = objectsClass.getByLibraryAndKey(libraryID, key);
|
||||
assert.isFalse(obj);
|
||||
|
|
@ -825,15 +986,28 @@ describe("Zotero.Sync.Data.Local", function() {
|
|||
assert.sameDeepMembers(
|
||||
result.conflicts,
|
||||
[
|
||||
{
|
||||
field: "place",
|
||||
op: "delete"
|
||||
},
|
||||
{
|
||||
field: "date",
|
||||
op: "add",
|
||||
value: "2015-05-15"
|
||||
}
|
||||
[
|
||||
{
|
||||
field: "place",
|
||||
op: "add",
|
||||
value: "Place"
|
||||
},
|
||||
{
|
||||
field: "place",
|
||||
op: "delete"
|
||||
}
|
||||
],
|
||||
[
|
||||
{
|
||||
field: "date",
|
||||
op: "delete"
|
||||
},
|
||||
{
|
||||
field: "date",
|
||||
op: "add",
|
||||
value: "2015-05-15"
|
||||
}
|
||||
]
|
||||
]
|
||||
);
|
||||
})
|
||||
|
|
@ -1296,4 +1470,68 @@ describe("Zotero.Sync.Data.Local", function() {
|
|||
})
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
describe("#reconcileChangesWithoutCache()", function () {
|
||||
it("should return conflict for conflicting fields", function () {
|
||||
var json1 = {
|
||||
key: "AAAAAAAA",
|
||||
version: 1234,
|
||||
title: "Title 1",
|
||||
pages: 10,
|
||||
dateModified: "2015-05-14 14:12:34"
|
||||
};
|
||||
var json2 = {
|
||||
key: "AAAAAAAA",
|
||||
version: 1235,
|
||||
title: "Title 2",
|
||||
place: "New York",
|
||||
dateModified: "2015-05-14 13:45:12"
|
||||
};
|
||||
var ignoreFields = ['dateAdded', 'dateModified'];
|
||||
var result = Zotero.Sync.Data.Local._reconcileChangesWithoutCache(
|
||||
'item', json1, json2, ignoreFields
|
||||
);
|
||||
assert.lengthOf(result.changes, 0);
|
||||
assert.sameDeepMembers(
|
||||
result.conflicts,
|
||||
[
|
||||
[
|
||||
{
|
||||
field: "title",
|
||||
op: "add",
|
||||
value: "Title 1"
|
||||
},
|
||||
{
|
||||
field: "title",
|
||||
op: "add",
|
||||
value: "Title 2"
|
||||
}
|
||||
],
|
||||
[
|
||||
{
|
||||
field: "pages",
|
||||
op: "add",
|
||||
value: 10
|
||||
},
|
||||
{
|
||||
field: "pages",
|
||||
op: "delete"
|
||||
}
|
||||
],
|
||||
[
|
||||
{
|
||||
field: "place",
|
||||
op: "delete"
|
||||
},
|
||||
{
|
||||
field: "place",
|
||||
op: "add",
|
||||
value: "New York"
|
||||
}
|
||||
]
|
||||
]
|
||||
);
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ describe("Zotero.Sync.Runner", function () {
|
|||
|
||||
var apiKey = Zotero.Utilities.randomString(24);
|
||||
var baseURL = "http://local.zotero/";
|
||||
var userLibraryID, publicationsLibraryID, runner, caller, server, client, stub, spy;
|
||||
var userLibraryID, publicationsLibraryID, runner, caller, server, stub, spy;
|
||||
|
||||
var responses = {
|
||||
keyInfo: {
|
||||
|
|
@ -129,15 +129,7 @@ describe("Zotero.Sync.Runner", function () {
|
|||
}
|
||||
};
|
||||
|
||||
var client = new Zotero.Sync.APIClient({
|
||||
baseURL: baseURL,
|
||||
apiVersion: options.apiVersion || ZOTERO_CONFIG.API_VERSION,
|
||||
apiKey: apiKey,
|
||||
concurrentCaller: caller,
|
||||
background: options.background || true
|
||||
});
|
||||
|
||||
return { runner, caller, client };
|
||||
return { runner, caller };
|
||||
})
|
||||
|
||||
function setResponse(response) {
|
||||
|
|
@ -160,7 +152,7 @@ describe("Zotero.Sync.Runner", function () {
|
|||
server = sinon.fakeServer.create();
|
||||
server.autoRespond = true;
|
||||
|
||||
({ runner, caller, client } = yield setup());
|
||||
({ runner, caller } = yield setup());
|
||||
|
||||
yield Zotero.Users.setCurrentUserID(1);
|
||||
yield Zotero.Users.setCurrentUsername("A");
|
||||
|
|
@ -180,7 +172,7 @@ describe("Zotero.Sync.Runner", function () {
|
|||
it("should check key access", function* () {
|
||||
spy = sinon.spy(runner, "checkUser");
|
||||
setResponse('keyInfo.fullAccess');
|
||||
var json = yield runner.checkAccess(client);
|
||||
var json = yield runner.checkAccess(runner.getAPIClient());
|
||||
sinon.assert.calledWith(spy, 1, "Username");
|
||||
var compare = {};
|
||||
Object.assign(compare, responses.keyInfo.fullAccess.json);
|
||||
|
|
@ -216,7 +208,7 @@ describe("Zotero.Sync.Runner", function () {
|
|||
|
||||
setResponse('userGroups.groupVersions');
|
||||
var libraries = yield runner.checkLibraries(
|
||||
client, false, responses.keyInfo.fullAccess.json
|
||||
runner.getAPIClient(), false, responses.keyInfo.fullAccess.json
|
||||
);
|
||||
assert.lengthOf(libraries, 4);
|
||||
assert.sameMembers(
|
||||
|
|
@ -240,19 +232,25 @@ describe("Zotero.Sync.Runner", function () {
|
|||
|
||||
setResponse('userGroups.groupVersions');
|
||||
var libraries = yield runner.checkLibraries(
|
||||
client, false, responses.keyInfo.fullAccess.json, [userLibraryID]
|
||||
runner.getAPIClient(), false, responses.keyInfo.fullAccess.json, [userLibraryID]
|
||||
);
|
||||
assert.lengthOf(libraries, 1);
|
||||
assert.sameMembers(libraries, [userLibraryID]);
|
||||
|
||||
var libraries = yield runner.checkLibraries(
|
||||
client, false, responses.keyInfo.fullAccess.json, [userLibraryID, publicationsLibraryID]
|
||||
runner.getAPIClient(),
|
||||
false,
|
||||
responses.keyInfo.fullAccess.json,
|
||||
[userLibraryID, publicationsLibraryID]
|
||||
);
|
||||
assert.lengthOf(libraries, 2);
|
||||
assert.sameMembers(libraries, [userLibraryID, publicationsLibraryID]);
|
||||
|
||||
var libraries = yield runner.checkLibraries(
|
||||
client, false, responses.keyInfo.fullAccess.json, [group1.libraryID]
|
||||
runner.getAPIClient(),
|
||||
false,
|
||||
responses.keyInfo.fullAccess.json,
|
||||
[group1.libraryID]
|
||||
);
|
||||
assert.lengthOf(libraries, 1);
|
||||
assert.sameMembers(libraries, [group1.libraryID]);
|
||||
|
|
@ -277,7 +275,7 @@ describe("Zotero.Sync.Runner", function () {
|
|||
setResponse('groups.ownerGroup');
|
||||
setResponse('groups.memberGroup');
|
||||
var libraries = yield runner.checkLibraries(
|
||||
client, false, responses.keyInfo.fullAccess.json
|
||||
runner.getAPIClient(), false, responses.keyInfo.fullAccess.json
|
||||
);
|
||||
assert.lengthOf(libraries, 4);
|
||||
assert.sameMembers(
|
||||
|
|
@ -318,7 +316,7 @@ describe("Zotero.Sync.Runner", function () {
|
|||
setResponse('groups.ownerGroup');
|
||||
setResponse('groups.memberGroup');
|
||||
var libraries = yield runner.checkLibraries(
|
||||
client,
|
||||
runner.getAPIClient(),
|
||||
false,
|
||||
responses.keyInfo.fullAccess.json,
|
||||
[group1.libraryID, group2.libraryID]
|
||||
|
|
@ -339,7 +337,7 @@ describe("Zotero.Sync.Runner", function () {
|
|||
setResponse('groups.ownerGroup');
|
||||
setResponse('groups.memberGroup');
|
||||
var libraries = yield runner.checkLibraries(
|
||||
client, false, responses.keyInfo.fullAccess.json
|
||||
runner.getAPIClient(), false, responses.keyInfo.fullAccess.json
|
||||
);
|
||||
assert.lengthOf(libraries, 4);
|
||||
var groupData1 = responses.groups.ownerGroup;
|
||||
|
|
@ -370,7 +368,7 @@ describe("Zotero.Sync.Runner", function () {
|
|||
assert.include(text, group1.name);
|
||||
});
|
||||
var libraries = yield runner.checkLibraries(
|
||||
client, false, responses.keyInfo.fullAccess.json
|
||||
runner.getAPIClient(), false, responses.keyInfo.fullAccess.json
|
||||
);
|
||||
assert.lengthOf(libraries, 3);
|
||||
assert.sameMembers(libraries, [userLibraryID, publicationsLibraryID, group2.libraryID]);
|
||||
|
|
@ -388,7 +386,7 @@ describe("Zotero.Sync.Runner", function () {
|
|||
assert.include(text, group.name);
|
||||
}, "extra1");
|
||||
var libraries = yield runner.checkLibraries(
|
||||
client, false, responses.keyInfo.fullAccess.json
|
||||
runner.getAPIClient(), false, responses.keyInfo.fullAccess.json
|
||||
);
|
||||
assert.lengthOf(libraries, 3);
|
||||
assert.sameMembers(libraries, [userLibraryID, publicationsLibraryID, group.libraryID]);
|
||||
|
|
@ -405,7 +403,7 @@ describe("Zotero.Sync.Runner", function () {
|
|||
assert.include(text, group.name);
|
||||
}, "cancel");
|
||||
var libraries = yield runner.checkLibraries(
|
||||
client, false, responses.keyInfo.fullAccess.json
|
||||
runner.getAPIClient(), false, responses.keyInfo.fullAccess.json
|
||||
);
|
||||
assert.lengthOf(libraries, 0);
|
||||
assert.isTrue(Zotero.Groups.exists(groupData.json.id));
|
||||
|
|
@ -656,6 +654,11 @@ describe("Zotero.Sync.Runner", function () {
|
|||
Zotero.Libraries.getVersion(Zotero.Groups.getLibraryIDFromGroupID(2694172)),
|
||||
20
|
||||
);
|
||||
|
||||
// Last sync time should be within the last second
|
||||
var lastSyncTime = Zotero.Sync.Data.Local.getLastSyncTime();
|
||||
assert.isAbove(lastSyncTime, new Date().getTime() - 1000);
|
||||
assert.isBelow(lastSyncTime, new Date().getTime());
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
"use strict";
|
||||
|
||||
describe("ZoteroPane", function() {
|
||||
var win, doc, zp;
|
||||
|
||||
|
|
@ -90,4 +92,96 @@ describe("ZoteroPane", function() {
|
|||
);
|
||||
})
|
||||
})
|
||||
|
||||
describe("#viewAttachment", function () {
|
||||
Components.utils.import("resource://zotero-unit/httpd.js");
|
||||
var apiKey = Zotero.Utilities.randomString(24);
|
||||
var port = 16213;
|
||||
var baseURL = `http://localhost:${port}/`;
|
||||
var server;
|
||||
var responses = {};
|
||||
|
||||
var setup = Zotero.Promise.coroutine(function* (options = {}) {
|
||||
server = sinon.fakeServer.create();
|
||||
server.autoRespond = true;
|
||||
});
|
||||
|
||||
function setResponse(response) {
|
||||
setHTTPResponse(server, baseURL, response, responses);
|
||||
}
|
||||
|
||||
before(function () {
|
||||
Zotero.HTTP.mock = sinon.FakeXMLHttpRequest;
|
||||
|
||||
Zotero.Sync.Runner.apiKey = apiKey;
|
||||
Zotero.Sync.Runner.baseURL = baseURL;
|
||||
})
|
||||
beforeEach(function* () {
|
||||
this.httpd = new HttpServer();
|
||||
this.httpd.start(port);
|
||||
|
||||
yield Zotero.Users.setCurrentUserID(1);
|
||||
yield Zotero.Users.setCurrentUsername("testuser");
|
||||
})
|
||||
afterEach(function* () {
|
||||
var defer = new Zotero.Promise.defer();
|
||||
this.httpd.stop(() => defer.resolve());
|
||||
yield defer.promise;
|
||||
})
|
||||
|
||||
it("should download an attachment on-demand", function* () {
|
||||
yield setup();
|
||||
Zotero.Sync.Storage.Local.downloadAsNeeded(Zotero.Libraries.userLibraryID, true);
|
||||
|
||||
var item = new Zotero.Item("attachment");
|
||||
item.attachmentLinkMode = 'imported_file';
|
||||
item.attachmentPath = 'storage:test.txt';
|
||||
// TODO: Test binary data
|
||||
var text = Zotero.Utilities.randomString();
|
||||
yield item.saveTx();
|
||||
yield Zotero.Sync.Storage.Local.setSyncState(
|
||||
item.id, Zotero.Sync.Storage.SYNC_STATE_TO_DOWNLOAD
|
||||
);
|
||||
|
||||
var mtime = "1441252524000";
|
||||
var md5 = Zotero.Utilities.Internal.md5(text)
|
||||
|
||||
var newStorageSyncTime = Math.round(new Date().getTime() / 1000);
|
||||
setResponse({
|
||||
method: "GET",
|
||||
url: "users/1/laststoragesync",
|
||||
status: 200,
|
||||
text: "" + newStorageSyncTime
|
||||
});
|
||||
var s3Path = `pretend-s3/${item.key}`;
|
||||
this.httpd.registerPathHandler(
|
||||
`/users/1/items/${item.key}/file`,
|
||||
{
|
||||
handle: function (request, response) {
|
||||
response.setStatusLine(null, 302, "Found");
|
||||
response.setHeader("Zotero-File-Modification-Time", mtime, false);
|
||||
response.setHeader("Zotero-File-MD5", md5, false);
|
||||
response.setHeader("Zotero-File-Compressed", "No", false);
|
||||
response.setHeader("Location", baseURL + s3Path, false);
|
||||
}
|
||||
}
|
||||
);
|
||||
this.httpd.registerPathHandler(
|
||||
"/" + s3Path,
|
||||
{
|
||||
handle: function (request, response) {
|
||||
response.setStatusLine(null, 200, "OK");
|
||||
response.write(text);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
yield zp.viewAttachment(item.id);
|
||||
|
||||
assert.equal((yield item.attachmentHash), md5);
|
||||
assert.equal((yield item.attachmentModificationTime), mtime);
|
||||
var path = yield item.getFilePathAsync();
|
||||
assert.equal((yield Zotero.File.getContentsAsync(path)), text);
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue