core-3nweb-client-lib 0.44.11 → 0.45.0

package/build/tests/caps-api/fs-checks/sync-with-two-devs/conflicts.js

@@ -0,0 +1,396 @@
+"use strict";
+/*
+ Copyright (C) 2022, 2025 - 2026 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specs = void 0;
+const random_node_1 = require("../../../../lib-common/random-node");
+const json_equal_1 = require("../../../libs-for-tests/json-equal");
+const watching_1 = require("../../../libs-for-tests/watching");
+exports.specs = {
+    description: '--',
+    its: []
+};
+let it = {
+    expectation: 'conflict in folder can be resolved by adopting remote version'
+};
+it.func = async function ({ dev1FS, dev2FS }) {
+    const file = 'file-for-conflict';
+    let folderStatus = await dev2FS().v.sync.status('');
+    expect(folderStatus.state).withContext(`from setup`).toBe('synced');
+    // make file simulatneously on both devices
+    await dev1FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(100));
+    await dev2FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(70));
+    folderStatus = await dev2FS().v.sync.status('');
+    expect(folderStatus.state).toBe('unsynced');
+    // and upload changes from dev1
+    await dev1FS().v.sync.upload(file);
+    await dev1FS().v.sync.upload('');
+    folderStatus = await dev2FS().v.sync.status('');
+    expect(folderStatus.state).toBe('conflicting');
+    expect(await dev2FS().readTxtFile(file))
+        .withContext(`we have placed a different content into these conflicting file versions`)
+        .not.toBe(await dev1FS().readTxtFile(file));
+    // folder versions diff is a tool for getting folder conflict details
+    const diff = await dev2FS().v.sync.diffCurrentAndRemoteFolderVersions('');
+    expect(diff).toBeDefined();
+    expect(diff.currentVersion).toBe(folderStatus.local.latest);
+    expect(diff.remoteVersion).toBe(folderStatus.remote.latest);
+    expect(diff.added.inLocal.includes(file)).toBeTrue();
+    expect(diff.added.inRemote.includes(file)).toBeTrue();
+    expect(diff.nameOverlaps).toContain(file);
+    const syncEvents = (0, watching_1.watchForEvents)(obs => dev2FS().watchFolder('', obs), 2, ev => (ev.src === 'sync'));
+    // adopt remote in a conflict state
+    await dev2FS().v.sync.adoptRemote('').then(() => fail(``), (exc) => {
+        expect(exc.type).toBe('fs-sync');
+        expect(exc.conflict).toBeTrue();
+    });
+    await dev2FS().v.sync.adoptRemote('', { remoteVersion: folderStatus.remote.latest });
+    await syncEvents.completion;
+    expect(syncEvents.collectedEvents.find(ev => ((ev.type === 'entry-removal') && (ev.name === file))))
+        .withContext(`Different object on the same path is removed`)
+        .toBeDefined();
+    expect(syncEvents.collectedEvents.find(ev => ((ev.type === 'entry-addition') && (ev.entry.name === file))))
+        .withContext(`Element from remote version is added`)
+        .toBeDefined();
+    folderStatus = await dev2FS().v.sync.status('');
+    expect(folderStatus.state).toBe('synced');
+    // we have also adopted here new file object on the same path
+    expect(await dev2FS().readTxtFile(file))
+        .withContext(`after adoption of folder dev2 reads correct file object`)
+        .toBe(await dev1FS().readTxtFile(file));
+    let fileStatus = await dev2FS().v.sync.status(file);
+    expect(fileStatus.state)
+        .withContext(`when a file system item is brought the first time from a server, its state should necessarily be synced`)
+        .toBe('synced');
+};
+exports.specs.its.push(it);
+it = {
+    expectation: `conflict in folder can be resolved by uploading local version, assembled from elements on both sides of the conflict`
+};
+it.func = async function ({ dev1FS, dev2FS }) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const file = 'file-for-conflict';
+    const fileFromDev1 = 'file-from-dev1';
+    const fileFromDev2 = 'file-from-dev2';
+    let folderStatus = await dev2FS().v.sync.status('');
+    expect(folderStatus.state).withContext(`from setup`).toBe('synced');
+    expect((_a = folderStatus.synced) === null || _a === void 0 ? void 0 : _a.latest).withContext(`from setup`).toBe(1);
+    // make file simulatneously on both devices
+    await dev1FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(100));
+    await dev1FS().writeTxtFile(fileFromDev1, (0, random_node_1.stringOfB64CharsSync)(100));
+    await dev2FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(70));
+    await dev2FS().writeTxtFile(fileFromDev2, (0, random_node_1.stringOfB64CharsSync)(70));
+    folderStatus = await dev2FS().v.sync.status('');
+    expect(folderStatus.state).toBe('unsynced');
+    // and upload changes from dev1
+    await dev1FS().v.sync.upload(file);
+    await dev1FS().v.sync.upload(fileFromDev1);
+    await dev1FS().v.sync.upload('');
+    // and upload on dev2 files, one will be adopted later, another removed
+    await dev2FS().v.sync.upload(file);
+    await dev2FS().v.sync.upload(fileFromDev2);
+    folderStatus = await dev2FS().v.sync.status('');
+    expect(folderStatus.state).toBe('conflicting');
+    expect((_b = folderStatus.remote) === null || _b === void 0 ? void 0 : _b.latest).toBe(2);
+    // folder versions diff is a tool for getting folder conflict details
+    const diff = await dev2FS().v.sync.diffCurrentAndRemoteFolderVersions('');
+    expect(diff).toBeDefined();
+    expect(diff.currentVersion).toBe(folderStatus.local.latest);
+    expect(diff.remoteVersion).toBe(folderStatus.remote.latest);
+    expect(diff.added.inLocal.includes(file)).toBeTrue();
+    expect(diff.added.inLocal.includes(fileFromDev2)).toBeTrue();
+    expect(diff.added.inRemote.includes(file)).toBeTrue();
+    expect(diff.added.inRemote.includes(fileFromDev1)).toBeTrue();
+    expect(diff.nameOverlaps).toContain(file);
+    // we can stat remote child
+    let statsRemote = await dev2FS().v.sync.statRemoteItem('', file, diff.remoteVersion);
+    let statsLocal = await dev2FS().stat(file);
+    let statsOn1 = await dev1FS().stat(file);
+    expect((_c = statsRemote.mtime) === null || _c === void 0 ? void 0 : _c.valueOf()).not.toBe((_d = statsLocal.mtime) === null || _d === void 0 ? void 0 : _d.valueOf());
+    expect((_e = statsRemote.mtime) === null || _e === void 0 ? void 0 : _e.valueOf()).toBe((_f = statsOn1.mtime) === null || _f === void 0 ? void 0 : _f.valueOf());
+    expect(statsRemote.size).not.toBe(statsLocal.size);
+    expect(statsRemote.size).toBe(statsOn1.size);
+    // we can read remote child
+    let remoteChild = await dev2FS().v.sync.getRemoteFileItem('', file, diff.remoteVersion);
+    expect(await remoteChild.readTxt()).toBe(await dev1FS().readTxtFile(file));
+    expect((await remoteChild.stat()).size).toBe(statsOn1.size);
+    // adopt on dev2 some remote elements from dev1
+    await dev2FS().v.sync.adoptRemoteFolderItem('', file, { replaceLocalItem: true });
+    await dev2FS().v.sync.adoptRemoteFolderItem('', fileFromDev1);
+    expect(await dev2FS().readTxtFile(file))
+        .toBe(await dev1FS().readTxtFile(file));
+    expect(await dev2FS().readTxtFile(fileFromDev1))
+        .toBe(await dev1FS().readTxtFile(fileFromDev1));
+    expect(await dev1FS().checkFilePresence(fileFromDev2)).toBeFalse();
+    // note need of explicit parameters when uploading from conflict state
+    folderStatus = await dev2FS().v.sync.status('');
+    expect(folderStatus.state).toBe('conflicting');
+    await dev2FS().v.sync.upload('').then(() => fail(`Upload in conflict must require explicit parameters`), (exc) => {
+        expect(exc.type).toBe('fs-sync');
+        expect(exc.versionMismatch).toBeTrue();
+    });
+    // upload new version, now from dev2
+    await dev2FS().v.sync.upload('', { uploadVersion: folderStatus.remote.latest + 1 });
+    folderStatus = await dev2FS().v.sync.status('');
+    expect(folderStatus.state).toBe('synced');
+    expect((_g = folderStatus.synced) === null || _g === void 0 ? void 0 : _g.latest).toBe(3);
+    // get new version on dev1 and check contents
+    await dev1FS().v.sync.adoptRemote('');
+    const lst = await dev1FS().listFolder('');
+    expect(lst.find(e => ((e.name === file) && e.isFile))).toBeDefined();
+    expect(lst.find(e => ((e.name === fileFromDev1) && e.isFile))).toBeDefined();
+    expect(lst.find(e => ((e.name === fileFromDev2) && e.isFile))).toBeDefined();
+    expect(await dev2FS().readTxtFile(fileFromDev2))
+        .toBe(await dev1FS().readTxtFile(fileFromDev2));
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'conflict in file can be resolved by adopting remote version'
+};
+it.func = async function ({ dev1FS, dev2FS }) {
+    const file = 'file-for-conflict';
+    // create file on dev1 and upload, so that dev2 can get it
+    await dev1FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(100));
+    await dev1FS().v.sync.upload(file);
+    await dev1FS().v.sync.upload('');
+    await dev2FS().v.sync.status(''); // implicit check of server
+    await dev2FS().v.sync.adoptRemote('');
+    let fileStatus = await dev2FS().v.sync.status(file);
+    expect(fileStatus.state).withContext(`when a file system item is brought the first time from a server, its state should necessarily be synced`)
+        .toBe('synced');
+    const fstObservedVersion = fileStatus.synced.latest;
+    // change file on dev1 and propagate
+    await dev1FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(200));
+    await dev1FS().v.sync.upload(file);
+    fileStatus = await dev2FS().v.sync.status(file);
+    expect(fileStatus.state).withContext(`changes to a file system item that come from a server can be adopted only explicitly, and state should indicate that current version is behind remote one`).toBe('behind');
+    expect(fileStatus.remote.latest).toBeGreaterThan(fstObservedVersion);
+    // change file on dev2 to reach conflict state
+    await dev2FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(150));
+    fileStatus = await dev2FS().v.sync.status(file);
+    expect(fileStatus.state).toBe('conflicting');
+    const syncEvents = (0, watching_1.watchForEvents)(obs => dev2FS().watchFile(file, obs), 1, ev => (ev.src === 'sync'));
+    // adopt remote in a conflict state
+    await dev2FS().v.sync.adoptRemote(file).then(() => fail(``), (exc) => {
+        expect(exc.type).toBe('fs-sync');
+        expect(exc.conflict).toBeTrue();
+    });
+    await dev2FS().v.sync.adoptRemote(file, { remoteVersion: fileStatus.remote.latest });
+    await syncEvents.completion;
+    expect(syncEvents.collectedEvents.find(ev => (ev.type === 'file-change')))
+        .withContext(``)
+        .toBeDefined();
+    fileStatus = await dev2FS().v.sync.status('');
+    expect(fileStatus.state).toBe('synced');
+    expect(await dev2FS().readTxtFile(file))
+        .toBe(await dev1FS().readTxtFile(file));
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'conflict in file can be resolved by uploading local version'
+};
+it.func = async function ({ dev1FS, dev2FS }) {
+    const file = 'file-for-conflict';
+    // create file on dev1 and upload, so that dev2 can get it
+    await dev1FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(100));
+    await dev1FS().v.sync.upload(file);
+    await dev1FS().v.sync.upload('');
+    await dev2FS().v.sync.status(''); // implicit check of server
+    await dev2FS().v.sync.adoptRemote('');
+    // change file on dev1 and dev2
+    await dev1FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(200));
+    await dev2FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(150));
+    // and upload changes from dev1 to reach conflict on dev2
+    await dev1FS().v.sync.upload(file);
+    let fileStatusOnDev2 = await dev2FS().v.sync.status(file);
+    expect(fileStatusOnDev2.state).toBe('conflicting');
+    // push version on dev2 higher to see it going down to uploaded level
+    for (let i = 0; i < 3; i += 1) {
+        await dev2FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(151 + i));
+    }
+    const remoteVersionBeforeUpload = fileStatusOnDev2.remote.latest;
+    expect((await dev2FS().stat(file)).version)
+        .toBeGreaterThan(remoteVersionBeforeUpload + 1);
+    await dev2FS().v.sync.upload(file).then(() => fail(`Upload in conflicting state should require explicit versioning`), (exc) => {
+        expect(exc.versionMismatch).toBeTrue();
+    });
+    await dev2FS().v.sync.upload(file, { uploadVersion: fileStatusOnDev2.remote.latest + 1 });
+    fileStatusOnDev2 = await dev2FS().v.sync.status(file);
+    expect(fileStatusOnDev2.state).toBe('synced');
+    expect(fileStatusOnDev2.synced.latest).toBe(remoteVersionBeforeUpload + 1);
+    await dev1FS().v.sync.status(file); // implicit check of server
+    await dev1FS().v.sync.adoptRemote(file);
+    expect(await dev2FS().readTxtFile(file))
+        .toBe(await dev1FS().readTxtFile(file));
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'upload over conflict concurrent with file write via sink'
+};
+it.func = async function ({ dev1FS, dev2FS }) {
+    const file = 'file-for-conflict';
+    // create file on dev1 and upload, so that dev2 can get it
+    await dev1FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(100));
+    await dev1FS().v.sync.upload(file);
+    await dev1FS().v.sync.upload('');
+    await dev2FS().v.sync.status(''); // implicit check of server
+    await dev2FS().v.sync.adoptRemote('');
+    // change file on dev1 and dev2
+    await dev1FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(200));
+    await dev2FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(150));
+    // and upload changes from dev1 to reach conflict on dev2
+    await dev1FS().v.sync.upload(file);
+    let fileStatusOnDev2 = await dev2FS().v.sync.status(file);
+    expect(fileStatusOnDev2.state).toBe('conflicting');
+    expect(fileStatusOnDev2.remote.latest).toBe(2);
+    // push version on dev2 higher to see it going down to uploaded level
+    let contentBeforeUpload = undefined;
+    for (let i = 0; i < 3; i += 1) {
+        contentBeforeUpload = (0, random_node_1.stringOfB64CharsSync)(151 + i);
+        await dev2FS().writeTxtFile(file, contentBeforeUpload);
+    }
+    // start long write to run concurrent with upload
+    const longWrite = await dev2FS().v.getByteSink(file);
+    // make concurrent upload
+    const uploadCompletion = dev2FS().v.sync.upload(file, { uploadVersion: fileStatusOnDev2.remote.latest + 1 });
+    await longWrite.sink.truncate(20);
+    // complete the write
+    await longWrite.sink.done();
+    // upload was scheduled after write completion, hence, awaiting after it
+    await uploadCompletion;
+    fileStatusOnDev2 = await dev2FS().v.sync.status(file);
+    expect(fileStatusOnDev2.state).toBe('unsynced');
+    expect(fileStatusOnDev2.synced.latest).toBe(3);
+    expect(fileStatusOnDev2.local.latest).toBe(longWrite.version);
+    await dev1FS().v.sync.status(file);
+    await dev1FS().v.sync.adoptRemote(file);
+    expect(await dev1FS().readTxtFile(file)).toBe(contentBeforeUpload);
+    await dev2FS().v.sync.upload(file);
+    fileStatusOnDev2 = await dev2FS().v.sync.status(file);
+    expect(fileStatusOnDev2.state).toBe('synced');
+    expect(fileStatusOnDev2.synced.latest).toBe(4);
+    await dev1FS().v.sync.status(file);
+    await dev1FS().v.sync.adoptRemote(file);
+    expect(await dev2FS().readTxtFile(file))
+        .toBe(await dev1FS().readTxtFile(file));
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'viewing and adopting remote folder item'
+};
+it.func = async function ({ dev1FS, dev2FS }) {
+    const fileA = `file-a`;
+    const folder = 'folder-for-conflict';
+    const file1 = `file-1`;
+    const file1path = `${folder}/${file1}`;
+    const file2 = `file-2`;
+    const file2path = `${folder}/${file2}`;
+    // create tree on dev1 and upload
+    for (const path of [file1path, file2path, fileA]) {
+        await dev1FS().writeTxtFile(path, (0, random_node_1.stringOfB64CharsSync)(100));
+    }
+    for (const path of [file1path, file2path, folder, fileA, '']) {
+        await dev1FS().v.sync.upload(path);
+    }
+    // tree is not local on dev2
+    let syncStatus = await dev2FS().v.sync.status(''); // implicit check of server
+    expect(syncStatus.state).toBe('behind');
+    expect(await dev2FS().checkFolderPresence(folder)).toBeFalse();
+    // can read remote items
+    let lst = await dev2FS().v.sync.listRemoteFolderItem('', folder);
+    let remoteFS = await dev2FS().v.sync.getRemoteFolderItem('', folder);
+    expect((0, json_equal_1.deepEqual)(lst, await remoteFS.listFolder(''))).toBeTrue();
+    expect(remoteFS.writable).toBeFalse();
+    expect(await remoteFS.readTxtFile(file1)).toBe(await dev1FS().readTxtFile(file1path));
+    expect(await remoteFS.readTxtFile(file2)).toBe(await dev1FS().readTxtFile(file2path));
+    // making a conflicting folder on dev2
+    const fileB = `file-b`;
+    const file3 = `file-3`;
+    const file3path = `${folder}/${file3}`;
+    for (const path of [file1path, file3path, fileB]) {
+        await dev2FS().writeTxtFile(path, (0, random_node_1.stringOfB64CharsSync)(100));
+    }
+    for (const path of [file1path, file3path, folder, fileB]) {
+        await dev2FS().v.sync.upload(path);
+    }
+    syncStatus = await dev2FS().v.sync.status(''); // implicit check of server
+    expect(syncStatus.state).toBe('conflicting');
+    const diff = await dev2FS().v.sync.diffCurrentAndRemoteFolderVersions('', syncStatus.remote.latest);
+    expect(diff.added.inLocal.includes(folder)).toBeTrue();
+    expect(diff.added.inLocal.includes(fileB)).toBeTrue();
+    expect(diff.added.inRemote.includes(folder)).toBeTrue();
+    expect(diff.added.inRemote.includes(fileA)).toBeTrue();
+    expect(diff.nameOverlaps).toContain(folder);
+    await dev2FS().v.sync.absorbRemoteFolderChanges('').then(() => fail(`Overlapping names require presence of prefix`), (exc) => {
+        expect(exc.type).toBe('fs-sync');
+        expect(Array.isArray(exc.nameOverlaps)).toBeTrue();
+    });
+    const postfixForNameOverlaps = `-remote`;
+    let version = await dev2FS().v.sync.absorbRemoteFolderChanges('', { postfixForNameOverlaps });
+    expect(version).toBe(diff.currentVersion + 1);
+    expect(await dev2FS().checkFilePresence(fileA)).toBeTrue();
+    expect(await dev2FS().readTxtFile(fileA)).toBe(await dev1FS().readTxtFile(fileA));
+    expect((0, json_equal_1.deepEqual)(await dev2FS().listFolder(`${folder}${postfixForNameOverlaps}`), await dev1FS().listFolder(folder))).toBeTrue();
+};
+exports.specs.its.push(it);
+it = {
+    expectation: `viewing remote folder items when it wasn't local or was removed locally`
+};
+it.func = async function ({ dev1FS, dev2FS }) {
+    const file = `file_to_remove`;
+    const folder = `folder_to_remove`;
+    const fileA = `file-A`;
+    const folderA = `folder-A`;
+    // make file on dev1 and upload
+    await dev1FS().writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(100));
+    await dev1FS().v.sync.upload(file);
+    await dev1FS().makeFolder(folder);
+    await dev1FS().v.sync.upload(folder);
+    await dev1FS().v.sync.upload('');
+    await dev2FS().v.sync.adoptRemote('');
+    expect(await dev2FS().checkFilePresence(file, true)).toBeTrue();
+    // change dev1 for conflict condition on folder path
+    await dev1FS().writeTxtFile(fileA, (0, random_node_1.stringOfB64CharsSync)(50));
+    await dev1FS().v.sync.upload(fileA);
+    await dev1FS().makeFolder(folderA);
+    await dev1FS().v.sync.upload(folderA);
+    await dev1FS().v.sync.upload('');
+    // remove file on dev2
+    await dev2FS().deleteFile(file);
+    await dev2FS().deleteFolder(folder);
+    const diff = await dev2FS().v.sync.diffCurrentAndRemoteFolderVersions('');
+    expect((await dev2FS().v.sync.statRemoteItem('', fileA, diff.remoteVersion)).size)
+        .toBe((await dev1FS().stat(fileA)).size);
+    expect((await dev2FS().v.sync.statRemoteItem('', file, diff.remoteVersion)).size)
+        .toBe((await dev1FS().stat(file)).size);
+    expect((await dev2FS().v.sync.statRemoteItem('', folderA, diff.remoteVersion)).mtime.valueOf())
+        .toBe((await dev1FS().stat(folderA)).mtime.valueOf());
+    expect((await dev2FS().v.sync.statRemoteItem('', folder, diff.remoteVersion)).mtime.valueOf())
+        .toBe((await dev1FS().stat(folder)).mtime.valueOf());
+    let fileObj = await dev2FS().v.sync.getRemoteFileItem('', file, diff.remoteVersion);
+    expect((await fileObj.readTxt())).toBe(await dev1FS().readTxtFile(file));
+    fileObj = await dev2FS().v.sync.getRemoteFileItem('', fileA, diff.remoteVersion);
+    expect((await fileObj.readTxt())).toBe(await dev1FS().readTxtFile(fileA));
+    let folderObj = await dev2FS().v.sync.getRemoteFolderItem('', folder, diff.remoteVersion);
+    expect((0, json_equal_1.deepEqual)(await folderObj.listFolder(''), await dev1FS().listFolder(folder))).toBeTrue();
+    expect(folderObj.v).toBeUndefined();
+    folderObj = await dev2FS().v.sync.getRemoteFolderItem('', folderA, diff.remoteVersion);
+    expect((0, json_equal_1.deepEqual)(await folderObj.listFolder(''), await dev1FS().listFolder(folderA))).toBeTrue();
+    expect(folderObj.v).toBeUndefined();
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/sync-with-two-devs/update-propagation.d.ts

@@ -0,0 +1,2 @@
+import { SpecDescribe } from '../../../libs-for-tests/spec-module';
+export declare const specs: SpecDescribe;

package/build/tests/caps-api/fs-checks/sync-with-two-devs/update-propagation.js

@@ -0,0 +1,229 @@
+"use strict";
+/*
+ Copyright (C) 2022, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specs = void 0;
+const buffer_utils_1 = require("../../../../lib-common/buffer-utils");
+const deferred_1 = require("../../../../lib-common/processes/deferred");
+const random_node_1 = require("../../../../lib-common/random-node");
+const bytes_equal_1 = require("../../../libs-for-tests/bytes-equal");
+const json_equal_1 = require("../../../libs-for-tests/json-equal");
+const test_utils_1 = require("../test-utils");
+exports.specs = {
+    description: '--',
+    its: []
+};
+let it = {
+    expectation: 'when online, other device observes events'
+};
+it.func = async function ({ dev1FS, dev2FS }) {
+    const file = 'file-1';
+    let fs1 = dev1FS();
+    let fs2 = dev2FS();
+    const evAtDev2 = (0, test_utils_1.observeFolderForOneEvent)(fs2);
+    let status = await fs2.v.sync.status('');
+    expect(status.state).withContext(`from setup`).toBe('synced');
+    await fs1.writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(100));
+    await fs1.v.sync.upload(file);
+    await fs1.v.sync.upload('');
+    const folderChangeEvent = await evAtDev2;
+    expect(folderChangeEvent.type).toBe('remote-change');
+    status = await fs2.v.sync.status('');
+    expect(status.state).toBe('behind');
+    await fs2.readTxtFile(file).then(() => fail(`There should be no file still in folder on dev 2`), (exc) => expect(exc.notFound).toBeTrue());
+    await fs2.v.sync.adoptRemote('');
+    status = await fs2.v.sync.status('');
+    const statusOnDev1 = await fs1.v.sync.status('');
+    expect(status.state).toBe('synced');
+    expect(status.synced.latest).toBe(statusOnDev1.synced.latest);
+    expect(await fs2.readTxtFile(file))
+        .toBe(await fs1.readTxtFile(file));
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'other device should check updates when coming online'
+};
+it.func = async function ({ dev1FS, dev2FS, dev2 }) {
+    const file = 'file-1';
+    let fs1 = dev1FS();
+    let fs2 = dev2FS();
+    let status = await fs2.v.sync.status('');
+    expect(status.state).withContext(`from setup`).toBe('synced');
+    await dev2.stop();
+    await fs1.writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(100));
+    await fs1.v.sync.upload(file);
+    await fs1.v.sync.upload('');
+    await dev2.start();
+    fs2 = dev2FS();
+    status = await fs2.v.sync.status('', true);
+    expect(status.state).toBe('synced');
+    status = await fs2.v.sync.status('');
+    expect(status.state).toBe('behind');
+    await fs2.v.sync.adoptRemote('');
+    status = await fs2.v.sync.status('');
+    const statusOnDev1 = await fs1.v.sync.status('');
+    expect(status.state).toBe('synced');
+    expect(status.synced.latest).toBe(statusOnDev1.synced.latest);
+    expect(await fs2.readTxtFile(file))
+        .toBe(await fs1.readTxtFile(file));
+};
+exports.specs.its.push(it);
+function collectFileDownloadEvents(fs, path) {
+    const startEvent = (0, deferred_1.defer)();
+    const doneEvent = (0, deferred_1.defer)();
+    const progressEvents = [];
+    const unsub = fs.watchFile(path, {
+        next: ev => {
+            switch (ev.type) {
+                case 'download-started':
+                    startEvent.resolve(ev);
+                    break;
+                case 'download-done':
+                    doneEvent.resolve(ev);
+                    unsub();
+                    break;
+                case 'download-progress':
+                    progressEvents.push(ev);
+                    break;
+            }
+        }
+    });
+    return {
+        startEvent: startEvent.promise,
+        doneEvent: doneEvent.promise,
+        progressEvents
+    };
+}
+it = {
+    expectation: 'remote version is downloaded non-automatically'
+};
+it.func = async function ({ dev1FS, dev2FS }) {
+    const file = 'file-1';
+    let fs1 = dev1FS();
+    let fs2 = dev2FS();
+    // case 1: remote version of folder
+    const folderEventAt2 = (0, test_utils_1.observeFolderForOneEvent)(fs2);
+    await fs1.writeTxtFile(file, (0, random_node_1.stringOfB64CharsSync)(100));
+    await fs1.v.sync.upload(file);
+    await fs1.v.sync.upload('');
+    const folderEv = await folderEventAt2;
+    expect(folderEv.type).toBe('remote-change');
+    expect((0, json_equal_1.deepEqual)(folderEv.syncStatus, await fs2.v.sync.status(''))).toBeTrue();
+    expect(await fs2.v.sync.isRemoteVersionOnDisk('', folderEv.newRemoteVersion)).toBe('none');
+    let startedDownload = await fs2.v.sync.startDownload('', folderEv.newRemoteVersion);
+    expect(startedDownload)
+        .withContext(`long download is not started, cause small entity is completely downloaded in the first request`)
+        .toBeUndefined();
+    expect(await fs2.v.sync.isRemoteVersionOnDisk('', folderEv.newRemoteVersion))
+        .withContext(`expect to see entity completely on a disk, when download has started, as not being needed`)
+        .toBe('complete');
+    expect((await fs2.v.listFolder('', { remoteVersion: folderEv.newRemoteVersion })).lst.map(({ name }) => name)).toContain(file);
+    // case 2: remote version of file
+    expect(await fs2.checkFilePresence(file)).toBeFalse();
+    await fs2.v.sync.adoptRemote('');
+    expect(await fs2.readTxtFile(file)).toBe(await fs1.readTxtFile(file));
+    let fileEventAt2 = (0, test_utils_1.observeFileForOneEvent)(fs2, file);
+    await fs1.writeBytes(file, await (0, random_node_1.bytes)(88000000));
+    await fs1.v.sync.upload(file);
+    let fileEv = await fileEventAt2;
+    expect(fileEv.type).toBe('remote-change');
+    expect((0, json_equal_1.deepEqual)(fileEv.syncStatus, await fs2.v.sync.status(file))).toBeTrue();
+    expect(await fs2.v.sync.isRemoteVersionOnDisk(file, fileEv.newRemoteVersion)).toBe('none');
+    let events = collectFileDownloadEvents(fs2, file);
+    startedDownload = await fs2.v.sync.startDownload(file, fileEv.newRemoteVersion);
+    expect(await fs2.v.sync.isRemoteVersionOnDisk(file, fileEv.newRemoteVersion)).toBe('partial');
+    expect(startedDownload).toBeDefined();
+    expect((await events.startEvent).downloadTaskId).toBe(startedDownload.downloadTaskId);
+    expect((await events.doneEvent).downloadTaskId).toBe(startedDownload.downloadTaskId);
+    expect(events.progressEvents.length).toBeGreaterThan(0);
+    expect(await fs2.v.sync.isRemoteVersionOnDisk(file, fileEv.newRemoteVersion)).toBe('complete');
+    expect((0, bytes_equal_1.bytesEqual)((await fs2.v.readBytes(file, undefined, undefined, { remoteVersion: fileEv.newRemoteVersion })).bytes, (await fs1.readBytes(file)))).toBeTrue();
+    // case 3: reading remote version of file without adopting it and without explicit download
+    fileEventAt2 = (0, test_utils_1.observeFileForOneEvent)(fs2, file);
+    await fs1.writeBytes(file, await (0, random_node_1.bytes)(770000));
+    await fs1.v.sync.upload(file);
+    fileEv = await fileEventAt2;
+    expect(await fs2.v.sync.isRemoteVersionOnDisk(file, fileEv.newRemoteVersion)).toBe('none');
+    expect((0, bytes_equal_1.bytesEqual)((await fs2.v.readBytes(file, undefined, undefined, { remoteVersion: fileEv.newRemoteVersion })).bytes, (await fs1.readBytes(file)))).toBeTrue();
+    expect(await fs2.v.sync.isRemoteVersionOnDisk(file, fileEv.newRemoteVersion)).toBe('complete');
+};
+it.timeout = 30000;
+exports.specs.its.push(it);
+it = {
+    expectation: 'file incrementally written and uploaded, then read on a second device'
+};
+it.func = async function ({ dev1FS, dev2FS }) {
+    const file = 'incremental-file';
+    let fs1 = dev1FS();
+    let fs2 = dev2FS();
+    const COMMA_BYTE = buffer_utils_1.utf8.pack(',');
+    const SQ_BRACKET_BYTE = buffer_utils_1.utf8.pack(']');
+    const completeContent = [
+        {
+            type: "addition",
+            record: {
+                msgId: "F-vo1A4zInEBGq994-e3KvrE9a8QXLcr",
+                msgType: "mail",
+                deliveryTS: 1664923830399,
+                key: "0Uz7wGW4P7hdik7fuStC+avi7iXk7AZ5B1KxJCxIOQk=",
+                keyStatus: "published_intro",
+                mainObjHeaderOfs: 72,
+                removeAfter: 0
+            }
+        },
+        {
+            type: "addition",
+            record: {
+                msgId: "JYXfEEcg3-iX7UDjG3BU0Jha9DYX_Jt-",
+                msgType: "mail",
+                deliveryTS: 1664923830658,
+                key: "gjArW3Mr3ACnoFds/wKFZJm+pp9De1TlNhWIkpyd4Ow=",
+                keyStatus: "published_intro",
+                mainObjHeaderOfs: 72,
+                removeAfter: 0
+            }
+        }
+    ];
+    // we do this file writing and uploading, cause this pattern hit an error,
+    // hence, we add this test with this seemingly out of the blue setup
+    await fs1.writeTxtFile(file, `[]`);
+    await fs1.v.sync.upload(file);
+    await fs1.v.sync.upload('');
+    let sink = await fs1.getByteSink(file, { truncate: false });
+    await sink.splice(1, 1);
+    let bytes = buffer_utils_1.utf8.pack(JSON.stringify(completeContent[0]));
+    await sink.splice(1, 0, bytes);
+    await sink.splice(1 + bytes.length, 0, SQ_BRACKET_BYTE);
+    await sink.done();
+    await fs1.v.sync.upload(file);
+    sink = await fs1.getByteSink(file, { truncate: false });
+    const len = await sink.getSize();
+    await sink.splice(len - 1, 1, COMMA_BYTE);
+    bytes = buffer_utils_1.utf8.pack(JSON.stringify(completeContent[1]));
+    await sink.splice(len, 0, bytes);
+    await sink.splice(len + bytes.length, 0, SQ_BRACKET_BYTE);
+    await sink.done();
+    expect((0, json_equal_1.deepEqual)(completeContent, await fs1.readJSONFile(file))).toBeTrue();
+    await fs1.v.sync.upload(file);
+    // and on the second device
+    expect((await fs2.v.sync.status('')).state).toBe('behind');
+    await fs2.v.sync.adoptRemote('');
+    expect((await fs2.v.sync.status(file)).state).toBe('synced');
+    expect((0, json_equal_1.deepEqual)(completeContent, await fs2.readJSONFile(file))).toBeTrue();
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/test-utils.d.ts

@@ -0,0 +1,34 @@
+import { MultiUserSetup } from "../../libs-for-tests/setups";
+import { SpecIt as GenericSpecIt } from "../../libs-for-tests/spec-module";
+type WritableFS = web3n.files.WritableFS;
+type ReadonlyFS = web3n.files.ReadonlyFS;
+export interface SetupWithTestFS {
+    isUp: boolean;
+    testFS: web3n.files.WritableFS;
+}
+export type SpecIt = GenericSpecIt<SetupWithTestFS>;
+export declare function clearFS(fs: WritableFS): Promise<void>;
+export interface SetupWithTwoFSs {
+    isUp: boolean;
+    syncedTestFS: WritableFS;
+    localTestFS: WritableFS;
+}
+export type SpecItWithTwoFSs = GenericSpecIt<SetupWithTwoFSs>;
+export interface SetupWithTwoDevsFSs {
+    isUp: boolean;
+    dev1FS: () => WritableFS;
+    dev2: {
+        stop(): Promise<void>;
+        start(): Promise<void>;
+    };
+    dev2FS: () => WritableFS;
+    resetFS: () => Promise<void>;
+}
+export type SpecItWithTwoDevsFSs = GenericSpecIt<SetupWithTwoDevsFSs>;
+export declare function makeSetupWithTwoDevsFSs(testFolder: string): {
+    fsSetup: SetupWithTwoDevsFSs;
+    setupDevsAndFSs: (baseSetup: MultiUserSetup) => Promise<void>;
+};
+export declare function observeFolderForOneEvent<T>(fs: ReadonlyFS, path?: string): Promise<T>;
+export declare function observeFileForOneEvent<T>(fs: ReadonlyFS, path: string): Promise<T>;
+export {};