core-3nweb-client-lib 0.44.11 → 0.45.0

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

@@ -0,0 +1,95 @@
+"use strict";
+/*
+ Copyright 2019 - 2020, 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.clearFS = clearFS;
+exports.makeSetupWithTwoDevsFSs = makeSetupWithTwoDevsFSs;
+exports.observeFolderForOneEvent = observeFolderForOneEvent;
+exports.observeFileForOneEvent = observeFileForOneEvent;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+async function clearFS(fs) {
+    let items = await fs.listFolder('');
+    let delTasks = [];
+    for (let f of items) {
+        if (f.isFile) {
+            delTasks.push(fs.deleteFile(f.name));
+        }
+        else if (f.isFolder) {
+            delTasks.push(fs.deleteFolder(f.name, true));
+        }
+        else if (f.isLink) {
+            delTasks.push(fs.deleteLink(f.name));
+        }
+        else {
+            throw new Error(`File system item is neither file, nor folder, nor link`);
+        }
+    }
+    await Promise.all(delTasks);
+}
+function makeSetupWithTwoDevsFSs(testFolder) {
+    const fsSetup = {};
+    const setupDevsAndFSs = async (baseSetup) => {
+        if (!baseSetup.isUp) {
+            return;
+        }
+        const w3n1 = baseSetup.testAppCapsByUserIndex(0);
+        const dev2 = await baseSetup.sndDevByUserIndex(0);
+        const dev1AppFS = await w3n1.storage.getAppSyncedFS();
+        const dev2AppFS = () => dev2.w3n.storage.getAppSyncedFS();
+        let dev1FS;
+        let dev2FS;
+        fsSetup.dev1FS = () => dev1FS;
+        fsSetup.dev2FS = () => dev2FS;
+        fsSetup.dev2 = {
+            start: async () => {
+                await dev2.start();
+                dev2FS = await (await dev2AppFS()).writableSubRoot(testFolder);
+            },
+            stop: async () => {
+                dev2FS = undefined;
+                await dev2.stop();
+            }
+        };
+        fsSetup.resetFS = async () => {
+            await clearFS(dev1AppFS);
+            dev1FS = await dev1AppFS.writableSubRoot(testFolder, { create: true, exclusive: true });
+            await dev1AppFS.v.sync.upload(testFolder);
+            await dev1AppFS.v.sync.upload('');
+            const d2AppFS = await dev2AppFS();
+            const status = await d2AppFS.v.sync.status('');
+            if (status.state === 'behind') {
+                await d2AppFS.v.sync.adoptRemote('');
+            }
+            else if (status.state === 'conflicting') {
+                throw new Error(`Test file system on a second device has inconvenient conflicting sync state`);
+            }
+            dev2FS = await d2AppFS.writableSubRoot(testFolder, { create: false });
+        };
+        await fsSetup.resetFS();
+        fsSetup.isUp = true;
+    };
+    return { fsSetup, setupDevsAndFSs };
+}
+function observeFolderForOneEvent(fs, path = '') {
+    return (0, rxjs_1.lastValueFrom)((new rxjs_1.Observable(obs => fs.watchTree(path, 1, obs)))
+        .pipe((0, operators_1.take)(1)));
+}
+function observeFileForOneEvent(fs, path) {
+    return (0, rxjs_1.lastValueFrom)((new rxjs_1.Observable(obs => fs.watchFile(path, obs)))
+        .pipe((0, operators_1.take)(1)));
+}

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

@@ -0,0 +1,73 @@
+"use strict";
+/*
+ Copyright (C) 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");
+exports.specs = {
+    description: '.v.archiveCurrent',
+    its: []
+};
+let it = { expectation: 'fails on non-existing path' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'non-existing-path';
+    await testFS.v.archiveCurrent(fName).then(() => fail('should fail for non-existing folder'), exc => {
+        expect(exc.notFound).toBe(true);
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'archives current synced version' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const filePath = `with archived inside/file`;
+    const initFileTxt = await (0, random_node_1.stringOfB64Chars)(30);
+    await testFS.v.writeTxtFile(filePath, initFileTxt);
+    let versions = await testFS.v.listVersions(filePath);
+    expect(versions.archived).toBeUndefined();
+    if (testFS.v.sync) {
+        let syncStatus = await testFS.v.sync.status(filePath);
+        expect(syncStatus.state).toBe('unsynced');
+        await testFS.v.archiveCurrent(filePath).then(() => fail(`synced fs can archive only synced version`), (exc) => {
+            expect(exc.type).toBe('fs-sync');
+            expect(exc.notSynced).toBeTrue();
+        });
+        await testFS.v.sync.upload(filePath);
+        syncStatus = await testFS.v.sync.status(filePath);
+        expect(syncStatus.state).toBe('synced');
+        expect(syncStatus.synced.archived).toBeUndefined();
+        await testFS.v.archiveCurrent(filePath);
+        syncStatus = await testFS.v.sync.status(filePath);
+        expect(syncStatus.synced.archived).toContain(syncStatus.synced.latest);
+    }
+    else {
+        await testFS.v.archiveCurrent(filePath);
+    }
+    const fileVer = (await testFS.stat(filePath)).version;
+    versions = await testFS.v.listVersions(filePath);
+    expect(versions.archived).toContain(fileVer);
+    // after writing new version, archived version can be read
+    expect(await testFS.v.writeBytes(filePath, await (0, random_node_1.bytes)(60)))
+        .toBeGreaterThan(fileVer);
+    expect((await testFS.v.readTxtFile(filePath, { archivedVersion: fileVer })).txt).toBe(initFileTxt);
+    if (testFS.v.sync) {
+        await testFS.v.sync.upload(filePath);
+        expect((await testFS.v.readTxtFile(filePath, { archivedVersion: fileVer })).txt).toBe(initFileTxt);
+    }
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,122 @@
+"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 random_node_1 = require("../../../../lib-common/random-node");
+const bytes_equal_1 = require("../../../libs-for-tests/bytes-equal");
+const sink_utils_1 = require("../../../../lib-common/obj-streaming/sink-utils");
+exports.specs = {
+    description: '.v.getByteSink',
+    its: []
+};
+let it = {
+    expectation: 'if not allowed to create, fails for missing file'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    try {
+        await testFS.v.getByteSink('non-existing-file', {});
+        fail('should fail for missing file');
+    }
+    catch (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;
+    const path = 'file1';
+    const content = (0, random_node_1.bytesSync)(2 * 1024);
+    expect(await testFS.checkFilePresence(path)).toBe(false);
+    const { sink, version: v } = await testFS.v.getByteSink(path, { create: true });
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect(await sink.getSize()).toBe(0);
+    const continousSink = (0, sink_utils_1.makeContinuousSink)(sink);
+    for (let pointer = 0; pointer < content.length; pointer += 250) {
+        const chunkEnd = pointer + 250;
+        await continousSink(content.subarray(pointer, chunkEnd));
+        expect(await sink.getSize()).toBe(Math.min(chunkEnd, content.length));
+    }
+    expect(await sink.getSize()).toBe(content.length);
+    await continousSink(null);
+    const { bytes, version } = await testFS.v.readBytes(path);
+    expect(!!bytes).toBe(true);
+    expect((0, bytes_equal_1.bytesEqual)(content, bytes)).toBe(true);
+    expect(version).toBe(v);
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates parent folder(s) on the way' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'file2';
+    const grParent = 'grand-parent';
+    const parent2 = 'grand-parent/parent2';
+    const path = `${parent2}/${fName}`;
+    expect(await testFS.checkFolderPresence(grParent)).toBe(false);
+    expect(await testFS.checkFolderPresence(parent2)).toBe(false);
+    expect(await testFS.checkFolderPresence(path)).toBe(false);
+    const { sink } = await testFS.v.getByteSink(path, { create: true });
+    expect(await testFS.checkFolderPresence(grParent)).toBe(true);
+    expect(await testFS.checkFolderPresence(parent2)).toBe(true);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    // note that file existed before sink closing
+    await sink.done();
+};
+exports.specs.its.push(it);
+it = { expectation: 'opens existing file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const path = 'file2';
+    const bytes = (0, random_node_1.bytesSync)(2 * 1024);
+    const originalSize = bytes.length;
+    const v = await testFS.v.writeBytes(path, bytes);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    const { sink, version } = await testFS.v.getByteSink(path, { truncate: false });
+    expect(version).withContext('it should be next file version').toBeGreaterThan(v);
+    expect(await sink.getSize()).withContext('Existing file should be opened as is').toBe(originalSize);
+    const continousSink = (0, sink_utils_1.makeContinuousSink)(sink, originalSize);
+    await continousSink(bytes);
+    expect(await sink.getSize()).toBe(originalSize + bytes.length);
+    await continousSink(null);
+};
+exports.specs.its.push(it);
+it = { expectation: `doesn't advance file version when write is cancelled` };
+it.func = async function (s) {
+    const { testFS } = s;
+    const path = 'file2';
+    const bytes = (0, random_node_1.bytesSync)(2 * 1024);
+    const initVersion = await testFS.v.writeBytes(path, bytes);
+    let { sink, version } = await testFS.v.getByteSink(path, {});
+    expect(version).toBe(initVersion + 1);
+    await sink.splice(0, 20, bytes.subarray(100, 120));
+    await sink.done(new Error(`Cancelling write to sink process`));
+    ({ version } = await testFS.v.readBytes(path));
+    expect(version).toBe(initVersion);
+    ({ sink, version } = await testFS.v.getByteSink(path, {}));
+    expect(version).toBe(initVersion + 1);
+    await sink.splice(1000, 20, bytes.subarray(0, 20));
+    await sink.done();
+    const { version: finV, bytes: finB } = await testFS.v.readBytes(path);
+    expect(finV).toBe(version);
+    expect((0, bytes_equal_1.bytesEqual)(finB.subarray(0, 1000), bytes.subarray(0, 1000))).toBe(true);
+    expect((0, bytes_equal_1.bytesEqual)(finB.subarray(1000, 1020), bytes.subarray(0, 20))).toBe(true);
+    expect((0, bytes_equal_1.bytesEqual)(finB.subarray(1020), bytes.subarray(1020))).toBe(true);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,71 @@
+"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 random_node_1 = require("../../../../lib-common/random-node");
+const bytes_equal_1 = require("../../../libs-for-tests/bytes-equal");
+exports.specs = {
+    description: '.v.getByteSource',
+    its: []
+};
+let it = { expectation: 'fails to read non-existent file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    try {
+        await testFS.v.getByteSource('non-existing-file');
+        fail('should fail for missing file');
+    }
+    catch (e) {
+        expect(e.notFound).toBe(true);
+    }
+};
+exports.specs.its.push(it);
+it = { expectation: 'reads file bytes with seeking available' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let original = (0, random_node_1.bytesSync)(12 * 1024 + 3);
+    let fName = 'file1';
+    let v1 = await testFS.v.writeBytes(fName, original);
+    let { src, version } = await testFS.v.getByteSource(fName);
+    expect(version).toBe(v1);
+    expect(await src.getPosition()).toBe(0);
+    let chunk = await src.readNext(200);
+    expect((0, bytes_equal_1.bytesEqual)(chunk, original.subarray(0, 200))).toBe(true);
+    await src.seek(3000);
+    expect(await src.getPosition()).withContext('seek method changes position in file.').toBe(3000);
+    chunk = await src.readNext(200);
+    expect((0, bytes_equal_1.bytesEqual)(chunk, original.subarray(3000, 3200))).toBe(true);
+    await src.seek(11000);
+    expect(await src.getPosition()).withContext('seek method changes position in file.').toBe(11000);
+    chunk = await src.readNext(200);
+    expect((0, bytes_equal_1.bytesEqual)(chunk, original.subarray(11000, 11200))).toBe(true);
+    await src.seek(1000);
+    expect(await src.getPosition()).toBe(1000);
+    chunk = await src.readNext(200);
+    expect((0, bytes_equal_1.bytesEqual)(chunk, original.subarray(1000, 1200))).toBe(true);
+    chunk = await src.readNext(undefined);
+    expect((0, bytes_equal_1.bytesEqual)(chunk, original.subarray(1200))).withContext('read should be from current position to file\'s end').toBe(true);
+    expect(await src.readNext(100)).withContext('undefined is returned, when there are no more bytes to read').toBeUndefined();
+    let v2 = await testFS.v.writeBytes(fName, new Uint8Array(0));
+    expect(v2).toBeGreaterThan(v1);
+    ({ src, version } = await testFS.v.getByteSource(fName));
+    expect(await src.readNext(100)).withContext('reading empty file should produce undefined').toBeUndefined();
+    expect(version).toBe(v2);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,109 @@
+"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: '.v.listFolder',
+    its: []
+};
+let it = { expectation: 'lists root' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let { lst, version } = await testFS.v.listFolder('');
+    expect(Array.isArray(lst)).toBe(true);
+    expect(typeof version).toBe('number');
+    expect(lst.length).toBe(0);
+    const initVersion = version;
+    await testFS.makeFolder('folder1');
+    await testFS.writeTxtFile('file1', '');
+    await testFS.writeTxtFile('folder1/file2', '');
+    ({ lst, version } = await testFS.v.listFolder(''));
+    expect(lst.length).toBe(2);
+    expect(version).toBe(initVersion + 2);
+    for (let entry of lst) {
+        if (entry.isFile) {
+            expect(entry.name).toBe('file1');
+        }
+        else if (entry.isFolder) {
+            expect(entry.name).toBe('folder1');
+        }
+        else {
+            fail(`folder listing has unknown type: ${JSON.stringify(entry, null, '  ')}`);
+        }
+    }
+    let lst2 = (await testFS.v.listFolder('.')).lst;
+    expect((0, json_equal_1.deepEqual)(lst2, lst)).toBe(true);
+    lst2 = (await testFS.v.listFolder('/')).lst;
+    expect((0, json_equal_1.deepEqual)(lst2, lst)).toBe(true);
+    lst2 = (await testFS.v.listFolder('../../')).lst;
+    expect((0, json_equal_1.deepEqual)(lst2, lst)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'fails to list non-existing folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'non-existing-folder';
+    expect(await testFS.checkFolderPresence(fName)).toBe(false);
+    try {
+        await testFS.v.listFolder(fName);
+        fail('listing should fail for non-existing folder');
+    }
+    catch (exc) {
+        expect(exc.notFound).toBe(true);
+    }
+    await testFS.writeTxtFile(fName, '123');
+    expect(await testFS.checkFilePresence(fName)).toBe(true);
+    try {
+        await testFS.listFolder(fName);
+        fail('listing should fail on path that points to file');
+    }
+    catch (exc) {
+        expect(exc.notDirectory).toBe(true);
+    }
+};
+exports.specs.its.push(it);
+it = { expectation: 'lists folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'f1/f2';
+    await testFS.makeFolder('f1/f2');
+    await testFS.writeTxtFile(fName + '/file1', '');
+    await testFS.writeTxtFile(fName + '/folder1/file2', '');
+    await testFS.link(fName + '/link1', await testFS.readonlyFile(fName + '/folder1/file2'));
+    let { lst, version } = await testFS.v.listFolder(fName);
+    expect(Array.isArray(lst)).toBe(true);
+    expect(typeof version).toBe('number');
+    expect(lst.length).toBe(3);
+    for (let entry of lst) {
+        if (entry.isFile) {
+            expect(entry.name).toBe('file1');
+        }
+        else if (entry.isFolder) {
+            expect(entry.name).toBe('folder1');
+        }
+        else if (entry.isLink) {
+            expect(entry.name).toBe('link1');
+        }
+        else {
+            fail(`folder listing has unknown type: ${JSON.stringify(entry, null, '  ')}`);
+        }
+    }
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,48 @@
+"use strict";
+/*
+ Copyright (C) 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;
+exports.specs = {
+    description: '.v.listVersions',
+    its: []
+};
+let it = { expectation: 'fails on non-existing path' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'non-existing-path';
+    await testFS.v.listVersions(fName).then(() => fail('should fail for non-existing folder'), exc => {
+        expect(exc.notFound).toBe(true);
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: `shows item's versions` };
+it.func = async function (s) {
+    const { testFS } = s;
+    const folderPath = `some/dir`;
+    const filePath = `${folderPath}/file`;
+    const fileVer = await testFS.v.writeTxtFile(filePath, 'some');
+    let versions = await testFS.v.listVersions(filePath);
+    expect(versions.current).toBe(fileVer);
+    expect(versions.archived).toBeUndefined();
+    const folderVer = (await testFS.stat(folderPath)).version;
+    versions = await testFS.v.listVersions(folderPath);
+    expect(versions.current).toBe(folderVer);
+    expect(versions.archived).toBeUndefined();
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/versioned/readBytes.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/versioned/readBytes.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;
+const random_node_1 = require("../../../../lib-common/random-node");
+const bytes_equal_1 = require("../../../libs-for-tests/bytes-equal");
+exports.specs = {
+    description: '.v.readBytes',
+    its: []
+};
+let it = { expectation: 'fails to read non-existent file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'unknown-file';
+    expect(await testFS.checkFilePresence(fName)).toBe(false);
+    try {
+        await testFS.v.readBytes(fName);
+        fail('reading bytes must fail, when file does not exist');
+    }
+    catch (err) {
+        expect(err.notFound).toBe(true);
+        if (!err.notFound) {
+            throw err;
+        }
+    }
+};
+exports.specs.its.push(it);
+it = { expectation: 'reads whole file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let originalBytes = (0, random_node_1.bytesSync)(12 * 1024 + 3);
+    let fName = 'file1';
+    let v1 = await testFS.v.writeBytes(fName, originalBytes);
+    let { bytes, version } = await testFS.v.readBytes(fName);
+    expect((0, bytes_equal_1.bytesEqual)(bytes, originalBytes)).withContext('file read should produce array with all bytes').toBe(true);
+    expect(version).withContext('file version at reading should be exactly the same as that on respective write').toBe(v1);
+    let v2 = await testFS.v.writeBytes(fName, new Uint8Array(0));
+    expect(v2).toBeGreaterThan(v1);
+    ({ bytes, version } = await testFS.v.readBytes(fName));
+    expect(typeof bytes).withContext('reading empty file should produce undefined').toBe('undefined');
+    expect(version).withContext('file version at reading should be exactly the same as that on respective write').toBe(v2);
+};
+exports.specs.its.push(it);
+it = { expectation: 'reads part of the file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'file3';
+    let originalBytes = (0, random_node_1.bytesSync)(12 * 1024 + 333);
+    let v = await testFS.v.writeBytes(fName, originalBytes);
+    let { bytes, version } = await testFS.v.readBytes(fName, 12, 3456);
+    expect((0, bytes_equal_1.bytesEqual)(bytes, originalBytes.subarray(12, 3456))).withContext('should read from a proper file interior').toBe(true);
+    expect(version).toBe(v);
+    ({ bytes, version } = await testFS.v.readBytes(fName, 12 * 1024));
+    expect((0, bytes_equal_1.bytesEqual)(bytes, originalBytes.subarray(12 * 1024))).withContext('read should start from interior and go to file\'s end').toBe(true);
+    expect(version).toBe(v);
+    ({ bytes, version } = await testFS.v.readBytes(fName, 12 * 1024, 1024 * 1024));
+    expect((0, bytes_equal_1.bytesEqual)(bytes, originalBytes.subarray(12 * 1024))).withContext('when end parameter is greater than file size, bytes up to files end must be read').toBe(true);
+    expect(version).toBe(v);
+    ({ bytes, version } = await testFS.v.readBytes(fName, undefined, 123));
+    expect((0, bytes_equal_1.bytesEqual)(bytes, originalBytes)).withContext('when start parameter is not given, end should also be ignored').toBe(true);
+    expect(version).toBe(v);
+    ({ bytes, version } = await testFS.v.readBytes(fName, 1024 * 1024, 1024 * 1024 + 4));
+    expect(bytes).withContext('when start is greater than file size, undefined must be returned').toBeUndefined();
+    expect(version).toBe(v);
+    ({ bytes, version } = await testFS.v.readBytes(fName, 1024 * 1024));
+    expect(bytes).withContext('when start is greater than file size, undefined must be returned').toBeUndefined();
+    expect(version).toBe(v);
+    await testFS.readBytes(fName, -1).then(() => fail('negative parameters should cause throwing up'), () => { });
+    await testFS.readBytes(fName, 1, -2).then(() => fail('negative parameters should cause throwing up'), () => { });
+    ({ bytes, version } = await testFS.v.readBytes(fName, 1234, 100));
+    expect(bytes).withContext('when end is smaller than start , undefined must be returned').toBeUndefined();
+    expect(version).toBe(v);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/versioned/readJSONFile.d.ts

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