1
0
mirror of https://github.com/laurent22/joplin.git synced 2024-12-15 09:04:04 +02:00
joplin/CliClient/tests/synchronizer.js

504 lines
12 KiB
JavaScript
Raw Normal View History

2017-06-24 20:06:28 +02:00
import { time } from 'lib/time-utils.js';
2017-06-18 22:19:13 +02:00
import { setupDatabase, setupDatabaseAndSynchronizer, db, synchronizer, fileApi, sleep, clearDatabase, switchClient } from 'test-utils.js';
2017-06-15 01:14:15 +02:00
import { createFoldersAndNotes } from 'test-data.js';
2017-06-24 20:06:28 +02:00
import { Folder } from 'lib/models/folder.js';
import { Note } from 'lib/models/note.js';
2017-07-03 20:29:19 +02:00
import { Tag } from 'lib/models/tag.js';
2017-06-24 20:06:28 +02:00
import { Setting } from 'lib/models/setting.js';
import { BaseItem } from 'lib/models/base-item.js';
import { BaseModel } from 'lib/base-model.js';
2017-06-18 22:19:13 +02:00
2017-06-19 00:06:10 +02:00
process.on('unhandledRejection', (reason, p) => {
console.log('Unhandled Rejection at: Promise', p, 'reason:', reason);
});
2017-06-29 22:52:52 +02:00
jasmine.DEFAULT_TIMEOUT_INTERVAL = 9000; // The first test is slow because the database needs to be built
2017-06-25 17:17:40 +02:00
async function allItems() {
let folders = await Folder.all();
let notes = await Note.all();
return folders.concat(notes);
}
2017-06-18 22:19:13 +02:00
async function localItemsSameAsRemote(locals, expect) {
try {
2017-06-19 00:06:10 +02:00
let files = await fileApi().list();
2017-06-29 20:03:16 +02:00
files = files.items;
2017-07-01 00:53:22 +02:00
2017-06-19 00:06:10 +02:00
expect(locals.length).toBe(files.length);
2017-06-18 22:19:13 +02:00
for (let i = 0; i < locals.length; i++) {
let dbItem = locals[i];
let path = BaseItem.systemPath(dbItem);
let remote = await fileApi().stat(path);
expect(!!remote).toBe(true);
2017-07-01 00:53:22 +02:00
if (!remote) continue;
2017-06-19 00:06:10 +02:00
expect(remote.updated_time).toBe(dbItem.updated_time);
2017-06-18 22:19:13 +02:00
let remoteContent = await fileApi().get(path);
2017-07-03 21:50:45 +02:00
remoteContent = dbItem.type_ == BaseModel.TYPE_NOTE ? await Note.unserialize(remoteContent) : await Folder.unserialize(remoteContent);
2017-06-18 22:19:13 +02:00
expect(remoteContent.title).toBe(dbItem.title);
}
} catch (error) {
console.error(error);
}
}
2017-06-15 01:14:15 +02:00
2017-06-18 01:49:52 +02:00
describe('Synchronizer', function() {
2017-06-14 00:39:45 +02:00
2017-06-18 01:49:52 +02:00
beforeEach( async (done) => {
2017-06-18 22:19:13 +02:00
await setupDatabaseAndSynchronizer(1);
await setupDatabaseAndSynchronizer(2);
2017-06-20 21:18:19 +02:00
await switchClient(1);
2017-06-18 01:49:52 +02:00
done();
2017-06-14 00:39:45 +02:00
});
2017-07-01 12:30:50 +02:00
it('should create remote items', async (done) => {
let folder = await Folder.save({ title: "folder1" });
await Note.save({ title: "un", parent_id: folder.id });
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
let all = await allItems();
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
await localItemsSameAsRemote(all, expect);
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
it('should update remote item', async (done) => {
let folder = await Folder.save({ title: "folder1" });
let note = await Note.save({ title: "un", parent_id: folder.id });
await synchronizer().start();
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
await Note.save({ title: "un UPDATE", id: note.id });
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
let all = await allItems();
await synchronizer().start();
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
await localItemsSameAsRemote(all, expect);
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
it('should create local items', async (done) => {
let folder = await Folder.save({ title: "folder1" });
await Note.save({ title: "un", parent_id: folder.id });
await synchronizer().start();
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(2);
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
let all = await allItems();
await localItemsSameAsRemote(all, expect);
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
it('should update local items', async (done) => {
let folder1 = await Folder.save({ title: "folder1" });
let note1 = await Note.save({ title: "un", parent_id: folder1.id });
await synchronizer().start();
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(2);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
let note2 = await Note.load(note1.id);
note2.title = "Updated on client 2";
await Note.save(note2);
note2 = await Note.load(note2.id);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(1);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
let all = await allItems();
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await localItemsSameAsRemote(all, expect);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
it('should resolve note conflicts', async (done) => {
let folder1 = await Folder.save({ title: "folder1" });
let note1 = await Note.save({ title: "un", parent_id: folder1.id });
await synchronizer().start();
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(2);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
let note2 = await Note.load(note1.id);
note2.title = "Updated on client 2";
await Note.save(note2);
note2 = await Note.load(note2.id);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(1);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
let note2conf = await Note.load(note1.id);
note2conf.title = "Updated on client 1";
await Note.save(note2conf);
note2conf = await Note.load(note1.id);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
let conflictedNotes = await Note.conflictedNotes();
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
expect(conflictedNotes.length).toBe(1);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
// Other than the id (since the conflicted note is a duplicate), and the is_conflict property
// the conflicted and original note must be the same in every way, to make sure no data has been lost.
let conflictedNote = conflictedNotes[0];
expect(conflictedNote.id == note2conf.id).toBe(false);
for (let n in conflictedNote) {
if (!conflictedNote.hasOwnProperty(n)) continue;
if (n == 'id' || n == 'is_conflict') continue;
expect(conflictedNote[n]).toBe(note2conf[n], 'Property: ' + n);
}
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
let noteUpdatedFromRemote = await Note.load(note1.id);
for (let n in noteUpdatedFromRemote) {
if (!noteUpdatedFromRemote.hasOwnProperty(n)) continue;
if (n == 'sync_time') continue;
expect(noteUpdatedFromRemote[n]).toBe(note2[n], 'Property: ' + n);
}
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
it('should resolve folders conflicts', async (done) => {
let folder1 = await Folder.save({ title: "folder1" });
let note1 = await Note.save({ title: "un", parent_id: folder1.id });
await synchronizer().start();
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(2); // ----------------------------------
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-06-19 00:06:10 +02:00
2017-07-01 12:30:50 +02:00
let folder1_modRemote = await Folder.load(folder1.id);
folder1_modRemote.title = "folder1 UPDATE CLIENT 2";
await Folder.save(folder1_modRemote);
folder1_modRemote = await Folder.load(folder1_modRemote.id);
2017-06-14 00:39:45 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-14 00:39:45 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(1); // ----------------------------------
2017-06-19 00:06:10 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
let folder1_modLocal = await Folder.load(folder1.id);
folder1_modLocal.title = "folder1 UPDATE CLIENT 1";
await Folder.save(folder1_modLocal);
folder1_modLocal = await Folder.load(folder1.id);
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-18 22:19:13 +02:00
2017-07-01 12:30:50 +02:00
let folder1_final = await Folder.load(folder1.id);
expect(folder1_final.title).toBe(folder1_modRemote.title);
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
it('should delete remote notes', async (done) => {
let folder1 = await Folder.save({ title: "folder1" });
let note1 = await Note.save({ title: "un", parent_id: folder1.id });
await synchronizer().start();
2017-06-19 21:18:22 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(2);
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await Note.delete(note1.id);
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
let files = await fileApi().list();
files = files.items;
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
expect(files.length).toBe(1);
expect(files[0].path).toBe(Folder.systemPath(folder1));
2017-06-20 00:18:24 +02:00
2017-07-03 21:50:45 +02:00
let deletedItems = await BaseItem.deletedItems();
2017-07-01 12:30:50 +02:00
expect(deletedItems.length).toBe(0);
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
it('should delete local notes', async (done) => {
let folder1 = await Folder.save({ title: "folder1" });
let note1 = await Note.save({ title: "un", parent_id: folder1.id });
await synchronizer().start();
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(2);
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await Note.delete(note1.id);
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(1);
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
let items = await allItems();
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
expect(items.length).toBe(1);
2017-06-20 00:18:24 +02:00
2017-07-03 21:50:45 +02:00
let deletedItems = await BaseItem.deletedItems();
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
expect(deletedItems.length).toBe(0);
2017-06-20 21:18:19 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
it('should delete remote folder', async (done) => {
let folder1 = await Folder.save({ title: "folder1" });
let folder2 = await Folder.save({ title: "folder2" });
await synchronizer().start();
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(2);
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await Folder.delete(folder2.id);
2017-06-20 00:18:24 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
let all = await allItems();
localItemsSameAsRemote(all, expect);
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-07-01 00:53:22 +02:00
it('should delete local folder', async (done) => {
2017-06-20 21:25:01 +02:00
let folder1 = await Folder.save({ title: "folder1" });
2017-07-01 00:53:22 +02:00
let folder2 = await Folder.save({ title: "folder2" });
2017-06-20 21:25:01 +02:00
await synchronizer().start();
2017-06-20 00:18:24 +02:00
2017-06-20 21:25:01 +02:00
await switchClient(2);
2017-06-20 00:18:24 +02:00
2017-06-20 21:25:01 +02:00
await synchronizer().start();
2017-06-20 00:18:24 +02:00
2017-06-20 21:25:01 +02:00
await sleep(0.1);
2017-06-20 00:18:24 +02:00
2017-07-01 00:53:22 +02:00
await Folder.delete(folder2.id);
2017-06-20 00:18:24 +02:00
2017-06-20 21:25:01 +02:00
await synchronizer().start();
2017-06-20 00:18:24 +02:00
2017-06-20 21:25:01 +02:00
await switchClient(1);
2017-06-20 00:18:24 +02:00
2017-06-20 21:25:01 +02:00
await synchronizer().start();
2017-06-20 00:18:24 +02:00
2017-07-01 00:53:22 +02:00
let items = await allItems();
localItemsSameAsRemote(items, expect);
2017-06-20 21:18:19 +02:00
2017-06-20 21:25:01 +02:00
done();
});
2017-06-20 00:18:24 +02:00
it('should cross delete all folders', async (done) => {
// If client1 and 2 have two folders, client 1 deletes item 1 and client
// 2 deletes item 2, they should both end up with no items after sync.
let folder1 = await Folder.save({ title: "folder1" });
let folder2 = await Folder.save({ title: "folder2" });
await synchronizer().start();
await switchClient(2);
await synchronizer().start();
await sleep(0.1);
await Folder.delete(folder1.id);
await switchClient(1);
await Folder.delete(folder2.id);
await synchronizer().start();
await switchClient(2);
await synchronizer().start();
let items2 = await allItems();
await switchClient(1);
await synchronizer().start();
let items1 = await allItems();
expect(items1.length).toBe(0);
expect(items1.length).toBe(items2.length);
done();
});
2017-07-01 12:30:50 +02:00
it('should handle conflict when remote note is deleted then local note is modified', async (done) => {
let folder1 = await Folder.save({ title: "folder1" });
let note1 = await Note.save({ title: "un", parent_id: folder1.id });
await synchronizer().start();
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(2);
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
await Note.delete(note1.id);
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(1);
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
let newTitle = 'Modified after having been deleted';
await Note.save({ id: note1.id, title: newTitle });
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
let conflictedNotes = await Note.conflictedNotes();
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
expect(conflictedNotes.length).toBe(1);
expect(conflictedNotes[0].title).toBe(newTitle);
2017-07-02 23:01:37 +02:00
let unconflictedNotes = await Note.unconflictedNotes();
expect(unconflictedNotes.length).toBe(0);
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
it('should handle conflict when remote folder is deleted then local folder is renamed', async (done) => {
let folder1 = await Folder.save({ title: "folder1" });
let folder2 = await Folder.save({ title: "folder2" });
let note1 = await Note.save({ title: "un", parent_id: folder1.id });
await synchronizer().start();
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(2);
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await Folder.delete(folder1.id);
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(1);
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
let newTitle = 'Modified after having been deleted';
await Folder.save({ id: folder1.id, title: newTitle });
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
let items = await allItems();
2017-07-01 00:53:22 +02:00
2017-07-01 12:30:50 +02:00
expect(items.length).toBe(1);
2017-06-20 22:31:12 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-06-20 22:31:12 +02:00
it('should allow duplicate folder titles', async (done) => {
2017-07-01 12:30:50 +02:00
let localF1 = await Folder.save({ title: "folder" });
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(2);
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
let remoteF2 = await Folder.save({ title: "folder" });
await synchronizer().start();
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(1);
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
await sleep(0.1);
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
let localF2 = await Folder.load(remoteF2.id);
2017-06-30 20:19:30 +02:00
expect(localF2.title == remoteF2.title).toBe(true);
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
// Then that folder that has been renamed locally should be set in such a way
// that synchronizing it applies the title change remotely, and that new title
// should be retrieved by client 2.
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
await switchClient(2);
await sleep(0.1);
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
await synchronizer().start();
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
remoteF2 = await Folder.load(remoteF2.id);
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
expect(remoteF2.title == localF2.title).toBe(true);
2017-06-30 20:19:30 +02:00
2017-07-01 12:30:50 +02:00
done();
});
2017-07-03 20:29:19 +02:00
it('should sync tags', async (done) => {
let f1 = await Folder.save({ title: "folder" });
let n1 = await Note.save({ title: "mynote" });
let n2 = await Note.save({ title: "mynote2" });
let tag = await Tag.save({ title: 'mytag' });
await synchronizer().start();
await switchClient(2);
await synchronizer().start();
let remoteTag = await Tag.loadByTitle(tag.title);
expect(!!remoteTag).toBe(true);
expect(remoteTag.id).toBe(tag.id);
await Tag.addNote(remoteTag.id, n1.id);
await Tag.addNote(remoteTag.id, n2.id);
let noteIds = await Tag.tagNoteIds(tag.id);
expect(noteIds.length).toBe(2);
await synchronizer().start();
await switchClient(1);
await synchronizer().start();
let remoteNoteIds = await Tag.tagNoteIds(tag.id);
expect(remoteNoteIds.length).toBe(2);
2017-07-04 00:08:14 +02:00
await Tag.removeNote(tag.id, n1.id);
2017-07-03 20:29:19 +02:00
remoteNoteIds = await Tag.tagNoteIds(tag.id);
expect(remoteNoteIds.length).toBe(1);
await synchronizer().start();
await switchClient(2);
await synchronizer().start();
noteIds = await Tag.tagNoteIds(tag.id);
expect(noteIds.length).toBe(1);
expect(remoteNoteIds[0]).toBe(noteIds[0]);
done();
});
2017-06-19 00:06:10 +02:00
});