core-3nweb-client-lib 0.44.12 → 0.45.1

package/build/tests/caps-api/fs-checks/not-versioned/writeTxtFile.js

@@ -0,0 +1,100 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2018, 2020 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;
+exports.specs = {
+    description: '.writeTxtFile',
+    its: []
+};
+let it = { expectation: 'if not allowed to create, fails for missing file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let txt = 'Should I be at BlackHat conference or working?';
+    await testFS.writeTxtFile('non-existing-file', txt, {})
+        .then(() => {
+        fail('should fail for missing file');
+    }, (e) => {
+        expect(e.notFound).toBe(true);
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates file in existing folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file1';
+    let txt = 'Should I be at BlackHat conference or working?';
+    expect(await testFS.checkFilePresence(path)).toBe(false);
+    await testFS.writeTxtFile(path, txt);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect(await testFS.readTxtFile(path)).toBe(txt);
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates parent folder(s) on the way' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'file2';
+    let grParent = 'grand-parent';
+    let parent2 = 'grand-parent/parent2';
+    let path = `${parent2}/${fName}`;
+    expect(await testFS.checkFolderPresence(grParent)).toBe(false);
+    expect(await testFS.checkFolderPresence(parent2)).toBe(false);
+    expect(await testFS.checkFolderPresence(path)).toBe(false);
+    let txt = 'Should I be at BlackHat conference or working?';
+    await testFS.writeTxtFile(path, txt);
+    expect(await testFS.checkFolderPresence(grParent)).toBe(true);
+    expect(await testFS.checkFolderPresence(parent2)).toBe(true);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect(await testFS.readTxtFile(path)).toBe(txt);
+};
+exports.specs.its.push(it);
+it = { expectation: 'over-writes existing file with a non-exclusive call' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file3';
+    // setup initial file
+    let initTxt = 'Should I be at BlackHat conference or working?';
+    await testFS.writeTxtFile(path, initTxt);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect(await testFS.readTxtFile(path)).toBe(initTxt);
+    // write new file content
+    let newTxt = 'Work gives tangible benefits.\nRetire and go anywhere.';
+    await testFS.writeTxtFile(path, newTxt);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect(await testFS.readTxtFile(path)).toBe(newTxt);
+};
+exports.specs.its.push(it);
+it = { expectation: 'exclusive-create write throws when file already exists' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file4';
+    // setup initial file
+    let initTxt = 'Should I be at BlackHat conference or working?';
+    await testFS.writeTxtFile(path, initTxt);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    // try an exclusive write
+    let newTxt = 'Work gives tangible benefits.\nRetire and go anywhere.';
+    await testFS.writeTxtFile(path, newTxt, { create: true, exclusive: true })
+        .then(() => {
+        fail('exclusive-create write operation must fail, when file exists.');
+    }, (exc) => {
+        expect(exc.alreadyExists).toBe(true);
+    });
+    expect(await testFS.readTxtFile(path)).withContext('initial file content stays intact').toBe(initTxt);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/sync-on-one-dev/startUpload.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-on-one-dev/startUpload.js

@@ -0,0 +1,187 @@
+"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 random_node_1 = require("../../../../lib-common/random-node");
+const json_equal_1 = require("../../../libs-for-tests/json-equal");
+const deferred_1 = require("../../../../lib-common/processes/deferred");
+exports.specs = {
+    description: '.v.sync.startedUpload',
+    its: []
+};
+let it = { expectation: 'fails to read non-existent path' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'unknown-file';
+    expect(await testFS.checkFilePresence(fName)).toBe(false);
+    await testFS.v.sync.startUpload(fName)
+        .then(() => {
+        fail('reading status must fail, when path does not exist');
+    }, (err) => {
+        expect(err.notFound).toBeTrue();
+        if (!err.notFound) {
+            throw err;
+        }
+    });
+};
+exports.specs.its.push(it);
+function collectFileUploadEvents(fs, path) {
+    const startEvent = (0, deferred_1.defer)();
+    const doneEvent = (0, deferred_1.defer)();
+    const unsub = fs.watchFile(path, {
+        next: ev => {
+            switch (ev.type) {
+                case 'upload-started':
+                    startEvent.resolve(ev);
+                    break;
+                case 'upload-done':
+                    doneEvent.resolve(ev);
+                    unsub();
+                    break;
+            }
+        }
+    });
+    return {
+        startEvent: startEvent.promise,
+        doneEvent: doneEvent.promise
+    };
+}
+it = { expectation: 'uploads versions' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const file1 = 'some folder/file 1';
+    const v1 = await testFS.v.writeBytes(file1, await (0, random_node_1.bytes)(10));
+    let syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.state).toBe('unsynced');
+    expect(syncStatus.synced).toBeUndefined();
+    expect(syncStatus.local).toBeDefined();
+    expect(syncStatus.local.latest).toBe(v1);
+    // file version written as a whole
+    const v2 = await testFS.v.writeBytes(file1, await (0, random_node_1.bytes)(10));
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.local.latest).toBe(v2);
+    try {
+        await testFS.v.sync.startUpload(file1, { localVersion: v1 });
+        fail(`Version ${v1} is not current can't be upload`);
+    }
+    catch (exc) {
+        expect(exc.type).toBe('fs-sync');
+    }
+    let events = collectFileUploadEvents(testFS, file1);
+    let startedUpload = await testFS.v.sync.startUpload(file1, { localVersion: v2 });
+    expect(startedUpload).withContext(`upload should be started`).toBeDefined();
+    expect(startedUpload.uploadVersion).withContext(`first uploaded version should be equal to 1`).toBe(1);
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.uploading).toBeDefined();
+    expect(syncStatus.uploading.localVersion).toBe(v2);
+    expect(syncStatus.uploading.remoteVersion).toBe(startedUpload.uploadVersion);
+    // await upload events and completion
+    let startEvent = await events.startEvent;
+    expect(startEvent.type).toBe('upload-started');
+    expect(startEvent.uploadTaskId).toBe(startedUpload.uploadTaskId);
+    expect(startEvent.localVersion).toBe(v2);
+    expect(startEvent.uploadVersion).toBe(startedUpload.uploadVersion);
+    expect(startEvent.totalBytesToUpload).toBeGreaterThan(10);
+    await events.doneEvent;
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.state).toBe('synced');
+    expect(syncStatus.uploading).toBeUndefined();
+    expect(syncStatus.synced).toBeDefined();
+    expect(syncStatus.local).toBeUndefined();
+    expect(syncStatus.synced.latest).toBe(startedUpload.uploadVersion);
+    expect((await testFS.stat(file1)).version).toBe(startedUpload.uploadVersion);
+    // file version written as a diff from a synced version
+    const { sink: sink3, version: v3 } = await testFS.v.getByteSink(file1, { truncate: false });
+    expect(v3).withContext(`normal increase of version by 1`).toBe(2);
+    await sink3.splice(10, 0, await (0, random_node_1.bytes)(10));
+    await sink3.done();
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.local.latest).toBe(v3);
+    expect(syncStatus.uploading).toBeUndefined();
+    events = collectFileUploadEvents(testFS, file1);
+    // note upload of latest version, when version isn't given
+    startedUpload = await testFS.v.sync.startUpload(file1);
+    expect(startedUpload.uploadVersion)
+        .withContext(`next uploaded version increases by 1`)
+        .toBe(2);
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.uploading)
+        .withContext(`started upload normally won't be fast to complete by this point`)
+        .toBeDefined();
+    expect(syncStatus.uploading.localVersion).toBe(v3);
+    expect(syncStatus.uploading.remoteVersion).toBe(2);
+    // watch and await upload completion
+    await events.doneEvent;
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.uploading)
+        .withContext(`upload must be complete after watch end`)
+        .toBeUndefined();
+    // file version written as a diff from a synced version and diff of that
+    let sink = (await testFS.v.getByteSink(file1, { truncate: false })).sink;
+    await sink.splice(20, 0, await (0, random_node_1.bytes)(10));
+    await sink.done();
+    sink = (await testFS.v.getByteSink(file1, { truncate: false })).sink;
+    await sink.splice(25, 0, await (0, random_node_1.bytes)(10));
+    await sink.done();
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.local.latest).toBe(v3 + 2);
+    events = collectFileUploadEvents(testFS, file1);
+    startedUpload = await testFS.v.sync.startUpload(file1);
+    expect(startedUpload.uploadVersion)
+        .withContext(`next uploaded version increases by 1`)
+        .toBe(3);
+    await events.doneEvent;
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.uploading)
+        .withContext(`upload must be complete after watch end`)
+        .toBeUndefined();
+    // upload of uploaded is a noop
+    startedUpload = await testFS.v.sync.startUpload(file1);
+    expect(startedUpload)
+        .withContext(`noop returns undefined, as upload wasn't started`)
+        .toBeUndefined();
+    expect((0, json_equal_1.deepEqual)(syncStatus, await testFS.v.sync.status(file1, true)))
+        .withContext(`nothing changed with noop`)
+        .toBeTrue();
+};
+exports.specs.its.push(it);
+const mb = 1024 * 1024;
+it = { expectation: 'uploads big file versions', timeout: 10000 };
+it.func = async function (s) {
+    const { testFS } = s;
+    const file1 = 'some folder/file 1';
+    // file version written as a whole
+    await testFS.v.writeBytes(file1, await (0, random_node_1.bytes)(3 * mb));
+    await testFS.v.sync.upload(file1);
+    let syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.synced.latest)
+        .withContext(`first uploaded version should be equal to 1`).toBe(1);
+    expect((await testFS.stat(file1)).version).toBe(1);
+    // file version written as a diff from a synced version
+    const { sink: sinkForV2, version: v2 } = await testFS.v.getByteSink(file1, { truncate: false });
+    expect(v2).withContext(`normal increase of version by 1`).toBe(2);
+    await sinkForV2.splice(2 * mb, 0, await (0, random_node_1.bytes)(2 * mb));
+    await sinkForV2.done();
+    await testFS.v.sync.upload(file1);
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.synced.latest)
+        .withContext(`next uploaded version increases by 1`).toBe(2);
+};
+// XXX add this, when changed to proper event checking
+// specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/sync-on-one-dev/stat.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-on-one-dev/stat.js

@@ -0,0 +1,70 @@
+"use strict";
+/*
+ Copyright (C) 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 sleep_1 = require("../../../../lib-common/processes/sleep");
+const random_node_1 = require("../../../../lib-common/random-node");
+exports.specs = {
+    description: '.v.stat',
+    its: []
+};
+let it = { expectation: 'fails to read non-existent path' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'unknown-file';
+    expect(await testFS.checkFilePresence(fName)).toBe(false);
+    await testFS.v.stat(fName)
+        .then(() => {
+        fail('reading status must fail, when path does not exist');
+    }, (err) => {
+        expect(err.notFound).toBe(true);
+        if (!err.notFound) {
+            throw err;
+        }
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: `gets stats` };
+it.func = async function (s) {
+    var _a, _b, _c;
+    const { testFS } = s;
+    const file1 = 'some folder/file 1';
+    const fstSize = 10;
+    await testFS.v.writeBytes(file1, await (0, random_node_1.bytes)(fstSize));
+    const v1stats = await testFS.stat(file1);
+    expect(v1stats.versionSyncBranch).toBe('local');
+    await (0, sleep_1.sleep)(10);
+    await testFS.v.sync.upload(file1);
+    await (0, sleep_1.sleep)(10);
+    const sndSize = 20;
+    await testFS.v.writeBytes(file1, await (0, random_node_1.bytes)(sndSize));
+    const syncStatus = await testFS.v.sync.status(file1, true);
+    const statsLocal = await testFS.v.stat(file1);
+    expect(statsLocal.version).toBe((_a = syncStatus.local) === null || _a === void 0 ? void 0 : _a.latest);
+    expect(statsLocal.size).toBe(sndSize);
+    const statsSynced = await testFS.v.stat(file1, { remoteVersion: (_b = syncStatus.synced) === null || _b === void 0 ? void 0 : _b.latest });
+    expect(statsSynced.version).toBe((_c = syncStatus.synced) === null || _c === void 0 ? void 0 : _c.latest);
+    expect(statsSynced.size).toBe(fstSize);
+    expect(statsSynced.versionSyncBranch).toBe('synced');
+    expect(statsSynced.ctime.valueOf()).toBe(statsLocal.ctime.valueOf());
+    expect(statsSynced.mtime.valueOf()).toBeLessThan(statsLocal.mtime.valueOf());
+    expect(statsSynced.ctime.valueOf()).toBe(v1stats.ctime.valueOf());
+    expect(statsSynced.mtime.valueOf()).toBe(v1stats.mtime.valueOf());
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/sync-on-one-dev/status.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-on-one-dev/status.js

@@ -0,0 +1,53 @@
+"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 random_node_1 = require("../../../../lib-common/random-node");
+exports.specs = {
+    description: '.v.sync.status',
+    its: []
+};
+let it = { expectation: 'fails to read non-existent path' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'unknown-file';
+    expect(await testFS.checkFilePresence(fName)).toBe(false);
+    await testFS.v.sync.status(fName)
+        .then(() => {
+        fail('reading status must fail, when path does not exist');
+    }, (err) => {
+        expect(err.notFound).toBe(true);
+        if (!err.notFound) {
+            throw err;
+        }
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'gets synchronization status' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const file1 = 'some folder/file 1';
+    const v1 = await testFS.v.writeBytes(file1, await (0, random_node_1.bytes)(10));
+    const syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.state).toBe('unsynced');
+    expect(syncStatus.local.latest).toBe(v1);
+    expect(syncStatus.synced).toBeUndefined();
+    expect(syncStatus.remote).toBeUndefined();
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/sync-on-one-dev/upload.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-on-one-dev/upload.js

@@ -0,0 +1,194 @@
+"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 random_node_1 = require("../../../../lib-common/random-node");
+const json_equal_1 = require("../../../libs-for-tests/json-equal");
+const sleep_1 = require("../../../../lib-common/processes/sleep");
+exports.specs = {
+    description: '.v.sync.upload',
+    its: []
+};
+let it = { expectation: 'fails to read non-existent path' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'unknown-file';
+    expect(await testFS.checkFilePresence(fName)).toBe(false);
+    await testFS.v.sync.upload(fName)
+        .then(() => {
+        fail('reading status must fail, when path does not exist');
+    }, (err) => {
+        expect(err.notFound).toBeTrue();
+        if (!err.notFound) {
+            throw err;
+        }
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'uploads versions' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const file1 = 'some folder/file 1';
+    const v1 = await testFS.v.writeBytes(file1, await (0, random_node_1.bytes)(10));
+    let syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.state).toBe('unsynced');
+    expect(syncStatus.synced).toBeUndefined();
+    expect(syncStatus.local).toBeDefined();
+    expect(syncStatus.local.latest).toBe(v1);
+    // file version written as a whole
+    const v2 = await testFS.v.writeBytes(file1, await (0, random_node_1.bytes)(10));
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.local.latest).toBe(v2);
+    try {
+        await testFS.v.sync.upload(file1, { localVersion: v1 });
+        fail(`Version ${v1} is not current can't be upload`);
+    }
+    catch (exc) {
+        expect(exc.type).toBe('fs-sync');
+    }
+    let uploadedVersion = await testFS.v.sync.upload(file1, { localVersion: v2 });
+    expect(uploadedVersion)
+        .withContext(`first uploaded version should be equal to 1`)
+        .toBe(1);
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.state).toBe('synced');
+    expect(syncStatus.synced).toBeDefined();
+    expect(syncStatus.local).toBeUndefined();
+    expect(syncStatus.synced.latest).toBe(uploadedVersion);
+    expect((await testFS.stat(file1)).version).toBe(uploadedVersion);
+    // file version written as a diff from a synced version
+    const { sink: sink3, version: v3 } = await testFS.v.getByteSink(file1, { truncate: false });
+    expect(v3).withContext(`normal increase of version by 1`).toBe(2);
+    await sink3.splice(10, 0, await (0, random_node_1.bytes)(10));
+    await sink3.done();
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.local.latest).toBe(v3);
+    // note upload of latest version, when version isn't given
+    uploadedVersion = await testFS.v.sync.upload(file1);
+    expect(uploadedVersion)
+        .withContext(`next uploaded version increases by 1`)
+        .toBe(2);
+    // file version written as a diff from a synced version and diff of that
+    let sink = (await testFS.v.getByteSink(file1, { truncate: false })).sink;
+    await sink.splice(20, 0, await (0, random_node_1.bytes)(10));
+    await sink.done();
+    sink = (await testFS.v.getByteSink(file1, { truncate: false })).sink;
+    await sink.splice(25, 0, await (0, random_node_1.bytes)(10));
+    await sink.done();
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.local.latest).toBe(v3 + 2);
+    uploadedVersion = await testFS.v.sync.upload(file1);
+    expect(uploadedVersion)
+        .withContext(`next uploaded version increases by 1`)
+        .toBe(3);
+    syncStatus = await testFS.v.sync.status(file1, true);
+    // upload of uploaded is a noop
+    uploadedVersion = await testFS.v.sync.upload(file1);
+    expect(uploadedVersion)
+        .withContext(`noop returns no version, as nothing was uploaded`)
+        .toBeUndefined();
+    expect((0, json_equal_1.deepEqual)(syncStatus, await testFS.v.sync.status(file1, true)))
+        .withContext(`nothing changed with noop`)
+        .toBeTrue();
+};
+exports.specs.its.push(it);
+const mb = 1024 * 1024;
+it = { expectation: 'uploads big file versions', timeout: 10000 };
+it.func = async function (s) {
+    const { testFS } = s;
+    const file1 = 'some folder/file 1';
+    // file version written as a whole
+    await testFS.v.writeBytes(file1, await (0, random_node_1.bytes)(3 * mb));
+    await testFS.v.sync.upload(file1);
+    let syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.synced.latest)
+        .withContext(`first uploaded version should be equal to 1`).toBe(1);
+    expect((await testFS.stat(file1)).version).toBe(1);
+    // file version written as a diff from a synced version
+    const { sink: sinkForV2, version: v2 } = await testFS.v.getByteSink(file1, { truncate: false });
+    expect(v2).withContext(`normal increase of version by 1`).toBe(2);
+    await sinkForV2.splice(2 * mb, 0, await (0, random_node_1.bytes)(2 * mb));
+    await sinkForV2.done();
+    await testFS.v.sync.upload(file1);
+    syncStatus = await testFS.v.sync.status(file1, true);
+    expect(syncStatus.synced.latest)
+        .withContext(`next uploaded version increases by 1`).toBe(2);
+};
+exports.specs.its.push(it);
+it = { expectation: 'refuses to upload folder if any child is never uploaded' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const folder = 'folder-to-upload';
+    const childName = `child-file`;
+    const childPath = `${folder}/${childName}`;
+    expect(await testFS.checkFolderPresence(folder)).toBeFalse();
+    await testFS.writeBytes(childPath, await (0, random_node_1.bytes)(10));
+    expect(await testFS.checkFolderPresence(folder)).toBeTrue();
+    let syncStatus = await testFS.v.sync.status(childPath, true);
+    expect(syncStatus.synced).toBeUndefined();
+    expect(syncStatus.existsInSyncedParent).toBeFalsy();
+    // child never uploaded at this point
+    await testFS.v.sync.upload(folder).then(() => fail(`upload of folder must fail with child that was never uploaded`), (exc) => {
+        expect(exc.type).toBe('fs-sync');
+        expect(exc.childNeverUploaded).toBeTrue();
+        expect(exc.childName).toBe(childName);
+    });
+    // upload child and update into unsynced state
+    await testFS.v.sync.upload(childPath);
+    syncStatus = await testFS.v.sync.status(childPath, true);
+    expect(syncStatus.state).toBe('synced');
+    expect(syncStatus.existsInSyncedParent).toBeFalsy();
+    await testFS.writeBytes(childPath, await (0, random_node_1.bytes)(20));
+    syncStatus = await testFS.v.sync.status(childPath, true);
+    expect(syncStatus.synced).toBeDefined();
+    expect(syncStatus.state).toBe('unsynced');
+    expect(syncStatus.existsInSyncedParent).toBeFalsy();
+    await testFS.v.sync.upload(folder);
+    syncStatus = await testFS.v.sync.status(folder, true);
+    expect(syncStatus.state).toBe('synced');
+    // note again that upload is not uploading children
+    syncStatus = await testFS.v.sync.status(childPath, true);
+    expect(syncStatus.state).toBe('unsynced');
+    expect(syncStatus.existsInSyncedParent).toBeTruthy();
+};
+exports.specs.its.push(it);
+it = { expectation: `should do own concurrently` };
+it.func = async function (s) {
+    const { testFS } = s;
+    // let's make and upload folder
+    const folderName = 'folder-to-upload';
+    const folder = await testFS.writableSubRoot(folderName);
+    const fstUpload = folder.v.sync.upload('');
+    await (0, sleep_1.sleep)(0);
+    folder.v.sync.upload('').catch((exc) => {
+        expect(exc.alreadyUploading).withContext(`Upload and syncing better be a single non-concurrent process, that synchronizes itself, following its own logical context.`).toBeTrue();
+    });
+    await fstUpload;
+    // let's make child entries and upload them, one-by-one
+    const children = [1, 2, 3, 4, 5].map(i => `child-file-${i}`);
+    const someContent = await (0, random_node_1.bytes)(50);
+    await Promise.all(children.map(child => folder.writeBytes(child, someContent)));
+    await Promise.all(children.map(child => folder.v.sync.upload(child)));
+    await folder.v.sync.upload('');
+    expect(((await folder.listFolder('')).length)).toBe(children.length);
+    await Promise.all(children.map(child => folder.deleteFile(child)));
+    await folder.v.sync.upload('');
+    expect(((await folder.listFolder('')).length)).toBe(0);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

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