core-3nweb-client-lib 0.44.11 → 0.45.0

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

@@ -0,0 +1,90 @@
+"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: '.writableSubRoot',
+    its: []
+};
+let it = { expectation: 'creates sub-root based on existing folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const path = 'sub-root';
+    await testFS.makeFolder(path);
+    expect(await testFS.checkFolderPresence(path)).toBe(true);
+    const subRoot = await testFS.writableSubRoot(path);
+    expect(subRoot).toBeTruthy();
+    expect(subRoot.writable).toBe(true);
+    expect(!!subRoot.v).toBe(!!testFS.v);
+    const lst = await subRoot.listFolder('');
+    expect(Array.isArray(lst)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates new folder for a sub-root' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const path = 'sub-root2';
+    expect(await testFS.checkFolderPresence(path)).toBe(false);
+    const subRoot = await testFS.writableSubRoot(path);
+    expect(subRoot).toBeTruthy();
+    expect(subRoot.writable).toBe(true);
+    expect(!!subRoot.v).toBe(!!testFS.v);
+    const lst = await subRoot.listFolder('');
+    expect(Array.isArray(lst)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates parent folder(s) on the way' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'sub-root';
+    const grParent = 'grand-parent';
+    const parent = 'grand-parent/parent';
+    const path = `${parent}/${fName}`;
+    expect(await testFS.checkFolderPresence(grParent)).toBe(false);
+    expect(await testFS.checkFolderPresence(parent)).toBe(false);
+    expect(await testFS.checkFolderPresence(path)).toBe(false);
+    const subRoot = await testFS.writableSubRoot(path);
+    expect(subRoot).toBeTruthy();
+    expect(subRoot.writable).toBe(true);
+    expect(!!subRoot.v).toBe(!!testFS.v);
+    const lst = await subRoot.listFolder('');
+    expect(Array.isArray(lst)).toBe(true);
+    expect(await testFS.checkFolderPresence(path)).toBe(true);
+};
+exports.specs.its.push(it);
+it = {
+    expectation: `concurrently created (on the same folder) sub-roots access the same file tree`
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    const subRootFolder = 'sub-root';
+    const promise1 = testFS.writableSubRoot(subRootFolder);
+    const promise2 = testFS.writableSubRoot(subRootFolder);
+    // create file in one fs
+    const fName = 'file 1';
+    const fileContent = `Sub-roots to the same folder should display same thing`;
+    const subRoot1 = await promise1;
+    await subRoot1.writeTxtFile(fName, fileContent);
+    // see that file is present via another fs
+    const subRoot2 = await promise2;
+    expect(await subRoot2.checkFilePresence(fName)).toBe(true);
+    const readContent = await subRoot2.readTxtFile(fName);
+    expect(readContent).toBe(fileContent);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/not-versioned/writeBytes.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/not-versioned/writeBytes.js

@@ -0,0 +1,137 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2018, 2020, 2022 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 bytes_equal_1 = require("../../../libs-for-tests/bytes-equal");
+exports.specs = {
+    description: '.writeBytes',
+    its: []
+};
+let it = { expectation: 'if not allowed to create, fails for missing file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    await testFS.writeBytes('non-existing-file', (0, random_node_1.bytesSync)(123), {})
+        .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 content = (0, random_node_1.bytesSync)(2 * 1024);
+    expect(await testFS.checkFilePresence(path)).toBe(false);
+    await testFS.writeBytes(path, content);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let bytes = await testFS.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(content, bytes)).toBe(true);
+};
+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 content = (0, random_node_1.bytesSync)(2 * 1024);
+    await testFS.writeBytes(path, content);
+    expect(await testFS.checkFolderPresence(grParent)).toBe(true);
+    expect(await testFS.checkFolderPresence(parent2)).toBe(true);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let bytes = await testFS.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(content, bytes)).toBe(true);
+};
+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 initBytes = (0, random_node_1.bytesSync)(123);
+    await testFS.writeBytes(path, initBytes);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let bytes = await testFS.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(initBytes, bytes)).toBe(true);
+    // write new file content
+    let newContent = (0, random_node_1.bytesSync)(3223);
+    await testFS.writeBytes(path, newContent);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    bytes = await testFS.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(newContent, bytes)).toBe(true);
+};
+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 initBytes = (0, random_node_1.bytesSync)(123);
+    await testFS.writeBytes(path, initBytes);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    // try an exclusive write
+    let newContent = (0, random_node_1.bytesSync)(3223);
+    await testFS.writeBytes(path, newContent, { create: true, exclusive: true })
+        .then(() => {
+        fail('exclusive-create write operation must fail, when file exists.');
+    }, (exc) => {
+        expect(exc.alreadyExists).toBe(true);
+    });
+    let bytes = await testFS.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(initBytes, bytes)).withContext('initial file content stays intact').toBe(true);
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'write big-ish file',
+    timeout: 10 * 1000
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file5';
+    // write some bytes
+    let bytesToWrite = (0, random_node_1.bytesSync)(3000000);
+    await testFS.writeBytes(path, bytesToWrite);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    // check that same bytes are read
+    let readBytes = await testFS.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(bytesToWrite, readBytes)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'writes 4K-even content' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const kb4 = 4 * 1024;
+    for (const [fName, contentLen] of [
+        ['file-4kb', kb4],
+        ['file-16kb', 4 * kb4],
+        ['file-20kb', 5 * kb4],
+    ]) {
+        const content = (0, random_node_1.bytesSync)(contentLen);
+        await testFS.writeBytes(fName, content);
+        expect((0, bytes_equal_1.bytesEqual)((await testFS.readBytes(fName)), content)).toBeTrue();
+    }
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/not-versioned/writeJSONFile.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/not-versioned/writeJSONFile.js

@@ -0,0 +1,101 @@
+"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;
+const json_equal_1 = require("../../../libs-for-tests/json-equal");
+exports.specs = {
+    description: '.writeJSONFile',
+    its: []
+};
+let it = { expectation: 'if not allowed to create, fails for missing file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let json = { a: 1, b: 2 };
+    await testFS.writeJSONFile('non-existing-file', json, {})
+        .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 json = { a: 1, b: 2 };
+    expect(await testFS.checkFilePresence(path)).toBe(false);
+    await testFS.writeJSONFile(path, json);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect((0, json_equal_1.deepEqual)(json, await testFS.readJSONFile(path))).toBe(true);
+};
+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 json = { a: 'foo', b: true, 'df-df': 23 };
+    await testFS.writeJSONFile(path, json);
+    expect(await testFS.checkFolderPresence(grParent)).toBe(true);
+    expect(await testFS.checkFolderPresence(parent2)).toBe(true);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect((0, json_equal_1.deepEqual)(json, await testFS.readJSONFile(path))).toBe(true);
+};
+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 initJson = { a: 'foo', b: true, 'df-df': 23 };
+    await testFS.writeJSONFile(path, initJson);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect((0, json_equal_1.deepEqual)(initJson, await testFS.readJSONFile(path))).toBe(true);
+    // write new file content
+    let newJson = null;
+    await testFS.writeJSONFile(path, newJson);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect((0, json_equal_1.deepEqual)(newJson, await testFS.readJSONFile(path))).toBe(true);
+};
+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 initJson = { a: 'foo', b: true, 'df-df': 23 };
+    await testFS.writeJSONFile(path, initJson);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    // try an exclusive write
+    let newJson = null;
+    await testFS.writeJSONFile(path, newJson, { create: true, exclusive: true })
+        .then(() => {
+        fail('exclusive-create write operation must fail, when file exists.');
+    }, (exc) => {
+        expect(exc.alreadyExists).toBe(true);
+    });
+    expect((0, json_equal_1.deepEqual)(initJson, await testFS.readJSONFile(path))).withContext('initial file content stays intact').toBe(true);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/not-versioned/writeTxtFile.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/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;