core-3nweb-client-lib 0.44.12 → 0.45.1

package/build/tests/caps-api/file-sink-checks/splice.js

@@ -0,0 +1,122 @@
+"use strict";
+/*
+ Copyright (C) 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: 'gives file sinks, able to splice file content',
+    its: []
+};
+let it = { expectation: 'of a newly created file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    function expectSection(l, sectionInd, src, ofs, len) {
+        const section = l.sections[sectionInd];
+        if (section) {
+            expect(section.src).withContext(`wrong source in section ${sectionInd}`).toBe(src);
+            expect(section.ofs).withContext(`wrong offset in section ${sectionInd}`).toBe(ofs);
+            expect(section.len).withContext(`wrong length in section ${sectionInd}`).toBe(len);
+        }
+        else {
+            fail(`section index ${sectionInd} is not in layout with ${l.sections.length} sections`);
+        }
+    }
+    const fName = 'file1';
+    const sink = await testFS.getByteSink(fName, { create: true, exclusive: true });
+    let size = await sink.getSize();
+    expect(size).toBe(0);
+    let layout = await sink.showLayout();
+    expect(Array.isArray(layout.sections)).toBeTruthy();
+    expect(layout.sections.length).toBe(0);
+    const chunk1 = (0, random_node_1.bytesSync)(10000);
+    await sink.splice(0, chunk1.length, chunk1);
+    size = await sink.getSize();
+    expect(size).toBe(10000);
+    layout = await sink.showLayout();
+    expect(layout.sections.length).toBe(1);
+    expectSection(layout, 0, 'new', 0, size);
+    const chunk2 = (0, random_node_1.bytesSync)(100);
+    await sink.splice(11000, 0, chunk2);
+    size = await sink.getSize();
+    layout = await sink.showLayout();
+    if (testFS.type === 'device') {
+        expect(layout.sections.length).toBe(1);
+        expectSection(layout, 0, 'new', 0, size);
+    }
+    else {
+        expect(layout.sections.length).toBe(3);
+        expectSection(layout, 0, 'new', 0, 10000);
+        expectSection(layout, 1, 'empty', 10000, 1000);
+        expectSection(layout, 2, 'new', 11000, 100);
+    }
+    await sink.done();
+    const content = await testFS.readBytes(fName);
+    expect(content.length).toBe(size);
+    expect((0, bytes_equal_1.bytesEqual)(content.subarray(0, 10000), chunk1)).toBe(true);
+    expect((0, bytes_equal_1.bytesEqual)(content.subarray(11000), chunk2)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'of an existing file without inserting new bytes' };
+it.func = async function (s) {
+    const { testFS } = s;
+    function expectSection(l, sectionInd, src, ofs, len) {
+        const section = l.sections[sectionInd];
+        if (section) {
+            expect(section.src).withContext(`source in section ${sectionInd}`).toBe(src);
+            expect(section.ofs).withContext(`offset in section ${sectionInd}`).toBe(ofs);
+            expect(section.len).withContext(`length in section ${sectionInd}`).toBe(len);
+        }
+        else {
+            fail(`section indexes ${sectionInd} is not in layout with ${l.sections.length} sections`);
+        }
+    }
+    // setup original file
+    const fName = 'file1';
+    let sink = await testFS.getByteSink(fName, { create: true, exclusive: true });
+    const chunk1 = (0, random_node_1.bytesSync)(10000);
+    await sink.splice(0, chunk1.length, chunk1);
+    const chunk2 = (0, random_node_1.bytesSync)(100);
+    await sink.splice(11000, 0, chunk2);
+    await sink.done();
+    const initSize = await sink.getSize();
+    // sink for this test
+    sink = await testFS.getByteSink(fName, { create: false });
+    await sink.splice(5000, 4000);
+    let size = await sink.getSize();
+    expect(size).toBe(initSize - 4000);
+    let layout = await sink.showLayout();
+    if (testFS.type === 'device') {
+        expect(layout.sections.length).toBe(1);
+        expectSection(layout, 0, 'new', 0, size);
+    }
+    else {
+        expect(layout.sections.length).toBe(3);
+        expectSection(layout, 0, 'base', 0, 6000);
+        expectSection(layout, 1, 'empty', 6000, 1000);
+        expectSection(layout, 2, 'base', 7000, 100);
+    }
+    await sink.done();
+    const content = await testFS.readBytes(fName);
+    expect(content.length).toBe(size);
+    expect((0, bytes_equal_1.bytesEqual)(content.subarray(0, 5000), chunk1.subarray(0, 5000))).toBe(true);
+    expect((0, bytes_equal_1.bytesEqual)(content.subarray(5000, 6000), chunk1.subarray(9000))).toBe(true);
+    expect((0, bytes_equal_1.bytesEqual)(content.subarray(7000), chunk2)).toBe(true);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/file-sink-checks/truncate.d.ts

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

package/build/tests/caps-api/file-sink-checks/truncate.js

@@ -0,0 +1,122 @@
+"use strict";
+/*
+ Copyright (C) 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: 'gives file sinks, able to truncate file content',
+    its: []
+};
+let it = { expectation: 'of a newly created file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    function expectSection(l, sectionInd, src, ofs, len) {
+        const section = l.sections[sectionInd];
+        if (section) {
+            expect(section.src).withContext(`source in section ${sectionInd}`).toBe(src);
+            expect(section.ofs).withContext(`offset in section ${sectionInd}`).toBe(ofs);
+            expect(section.len).withContext(`length in section ${sectionInd}`).toBe(len);
+        }
+        else {
+            fail(`section index ${sectionInd} is not in layout with ${l.sections.length} sections`);
+        }
+    }
+    const fName = 'file1';
+    const sink = await testFS.getByteSink(fName, { create: true, exclusive: true });
+    let size = await sink.getSize();
+    expect(size).toBe(0);
+    let layout = await sink.showLayout();
+    expect(Array.isArray(layout.sections)).toBeTruthy();
+    expect(layout.sections.length).toBe(0);
+    await sink.truncate(10000);
+    size = await sink.getSize();
+    expect(size).toBe(10000);
+    layout = await sink.showLayout();
+    expect(layout.sections.length).toBe(1);
+    if (testFS.type === 'device') {
+        expectSection(layout, 0, 'new', 0, 10000);
+    }
+    else {
+        expectSection(layout, 0, 'empty', 0, 10000);
+    }
+    const chunk = (0, random_node_1.bytesSync)(10000);
+    await sink.splice(0, chunk.length, chunk);
+    size = await sink.getSize();
+    expect(size).toBe(10000);
+    layout = await sink.showLayout();
+    expect(layout.sections.length).toBe(1);
+    expectSection(layout, 0, 'new', 0, size);
+    await sink.truncate(5000);
+    size = await sink.getSize();
+    expect(size).toBe(5000);
+    layout = await sink.showLayout();
+    expect(layout.sections.length).toBe(1);
+    expectSection(layout, 0, 'new', 0, size);
+    await sink.done();
+    const content = await testFS.readBytes(fName);
+    expect(content.length).toBe(size);
+    expect((0, bytes_equal_1.bytesEqual)(content, chunk.subarray(0, size))).toBe(true);
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'and supports truncating without writing to file (scenario 1), checking version',
+    notIncludedIn: 'device-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    async function checkSizeOf(file, expectedSize, expectedVersion) {
+        const { size, version } = await testFS.stat(file);
+        expect(size).withContext(`file size of "${file}"`).toBe(expectedSize);
+        expect(version).withContext(`file version`).toBe(expectedVersion);
+    }
+    const file = 'file to truncate';
+    let fileVersion = await testFS.v.writeTxtFile(file, '', { create: true, exclusive: true });
+    await checkSizeOf(file, 0, fileVersion);
+    let { sink, version } = await testFS.v.getByteSink(file, {});
+    await sink.truncate(500);
+    await sink.done();
+    await checkSizeOf(file, 500, version);
+    ({ sink, version } = await testFS.v.getByteSink(file, {}));
+    await sink.truncate(100);
+    await sink.done();
+    await checkSizeOf(file, 100, version);
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'and supports truncating without writing to file (scenario 1), without checking versions'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    async function checkSizeOf(file, expectedSize) {
+        const { size, version } = await testFS.stat(file);
+        expect(size).withContext(`file size of "${file}"`).toBe(expectedSize);
+    }
+    const file = 'file to truncate';
+    await testFS.writeTxtFile(file, '', { create: true, exclusive: true });
+    await checkSizeOf(file, 0);
+    let sink = await testFS.getByteSink(file, {});
+    await sink.truncate(500);
+    await sink.done();
+    await checkSizeOf(file, 500);
+    sink = await testFS.getByteSink(file, {});
+    await sink.truncate(100);
+    await sink.done();
+    await checkSizeOf(file, 100);
+};
+exports.specs.its.push(it);

package/build/tests/caps-api/fs-checks/local-to-synced-linking/link.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/local-to-synced-linking/link.js

@@ -0,0 +1,82 @@
+"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: '.link, when linking from local into synced storage,',
+    its: []
+};
+let it = { expectation: 'links readonly file' };
+it.func = async function (s) {
+    const { syncedTestFS, localTestFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const fName = 'file1';
+    await syncedTestFS.writeTxtFile(fName, original);
+    let file = await syncedTestFS.readonlyFile(fName);
+    const linkPath = 'link1';
+    await localTestFS.link(linkPath, file);
+    const link = await localTestFS.readLink(linkPath);
+    expect(link.isFile).withContext('this link should be for a file').toBe(true);
+    expect(link.readonly).withContext('this link should be readonly').toBe(true);
+    file = (await link.target());
+    expect(!!file).withContext('target should be instantiated').toBe(true);
+    expect(await file.readTxt()).toBe(original);
+    expect(file.writable).toBe(false);
+};
+exports.specs.its.push(it);
+it = { expectation: 'links writable file' };
+it.func = async function (s) {
+    const { syncedTestFS, localTestFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const fName = 'file1';
+    await syncedTestFS.writeTxtFile(fName, original);
+    let file = await syncedTestFS.writableFile(fName);
+    const linkPath = 'link1';
+    await localTestFS.link(linkPath, file);
+    const link = await localTestFS.readLink(linkPath);
+    expect(link.isFile).withContext('this link should be for a file').toBe(true);
+    expect(link.readonly).withContext('this link should be writable').toBe(false);
+    file = (await link.target());
+    expect(!!file).withContext('target should be instantiated').toBe(true);
+    expect(await file.readTxt()).toBe(original);
+    const newTxt = 'I better work. A-a-a!!!';
+    await file.writeTxt(newTxt);
+    expect(await file.readTxt()).toBe(newTxt);
+};
+exports.specs.its.push(it);
+it = { expectation: 'links writable folder' };
+it.func = async function (s) {
+    const { syncedTestFS, localTestFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const folderName = 'folder1';
+    const fName = 'file1';
+    await syncedTestFS.writeTxtFile(`${folderName}/${fName}`, original);
+    let folder = await syncedTestFS.writableSubRoot(folderName);
+    const linkPath = 'link1';
+    await localTestFS.link(linkPath, folder);
+    const link = await localTestFS.readLink(linkPath);
+    expect(link.isFolder).withContext('this link should be for a folder').toBe(true);
+    expect(link.readonly).withContext('this link should be writable').toBe(false);
+    folder = (await link.target());
+    expect(!!folder).withContext('target should be instantiated').toBe(true);
+    expect(await folder.readTxtFile(fName)).toBe(original);
+    const newTxt = 'I better work. A-a-a!!!';
+    await folder.writeTxtFile(fName, newTxt);
+    expect(await folder.readTxtFile(fName)).toBe(newTxt);
+};
+exports.specs.its.push(it);

package/build/tests/caps-api/fs-checks/local-to-synced-linking/reversed-linking.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/local-to-synced-linking/reversed-linking.js

@@ -0,0 +1,50 @@
+"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: '.link should fail to link from synced into local storage,',
+    its: []
+};
+let it = { expectation: 'linking file' };
+it.func = async function (s) {
+    const { syncedTestFS, localTestFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const fName = 'file1';
+    await localTestFS.writeTxtFile(fName, original);
+    const file = await localTestFS.readonlyFile(fName);
+    const linkPath = 'link1';
+    await syncedTestFS.link(linkPath, file).catch((err) => {
+        expect(typeof err).toBe('object');
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'linking folder' };
+it.func = async function (s) {
+    const { syncedTestFS, localTestFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const folderName = 'folder1';
+    const fName = 'file1';
+    await localTestFS.writeTxtFile(`${folderName}/${fName}`, original);
+    const folder = await localTestFS.writableSubRoot(folderName);
+    const linkPath = 'link1';
+    await syncedTestFS.link(linkPath, folder).catch((err) => {
+        expect(typeof err).toBe('object');
+    });
+};
+exports.specs.its.push(it);

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

@@ -0,0 +1,73 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2018, 2020, 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;
+exports.specs = {
+    description: '.deleteFile',
+    its: []
+};
+let it = { expectation: 'cannot delete non-existing file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'non-existing-file';
+    expect(await testFS.checkFilePresence(fName)).toBe(false);
+    await testFS.deleteFile(fName)
+        .then(() => {
+        fail('deleting non-existing file must fail');
+    }, (exc) => {
+        expect(exc.notFound).toBe(true);
+    });
+    await testFS.makeFolder(fName);
+    expect(await testFS.checkFolderPresence(fName)).toBe(true);
+    await testFS.deleteFile(fName)
+        .then(() => {
+        fail('deleting folder as file must fail');
+    }, (exc) => {
+        expect(exc.notFile || exc.opNotPermitted).withContext('folder is not a file').toBe(true);
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'deletes file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    for (const fName of ['file1', 'folder/file1']) {
+        await testFS.writeTxtFile(fName, '');
+        expect(await testFS.checkFilePresence(fName)).toBe(true);
+        await testFS.deleteFile(fName);
+        expect(await testFS.checkFilePresence(fName)).toBe(false);
+    }
+};
+exports.specs.its.push(it);
+it = { expectation: 'deletes files concurrently from fs objects that point to same node' };
+it.func = async function (s) {
+    const { testFS } = s;
+    // folder objects should have the same underlying fs node
+    const folders = await Promise.all([1, 2, 3, 4, 5].map(() => testFS.writableSubRoot('folder')));
+    expect(folders.length).toBe(5);
+    const file1Name = 'file1';
+    await folders[0].writeTxtFile(file1Name, 'blah');
+    for (let i = 1; i < folders.length; i += 1) {
+        expect(await folders[i].checkFilePresence(file1Name)).toBeTrue();
+    }
+    await folders[0].deleteFile(file1Name);
+    for (let i = 1; i < folders.length; i += 1) {
+        expect(await folders[i].checkFilePresence(file1Name)).toBeFalse();
+    }
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,75 @@
+"use strict";
+/*
+ Copyright (C) 2016, 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: '.deleteFile',
+    its: []
+};
+let it = { expectation: 'lists root' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'non-existing-folder';
+    expect(await testFS.checkFolderPresence(fName)).toBe(false);
+    await testFS.deleteFolder(fName)
+        .then(() => {
+        fail('deleting non-existing folder must fail');
+    }, (exc) => {
+        expect(exc.notFound).toBe(true);
+    });
+    await testFS.writeTxtFile(fName, '');
+    expect(await testFS.checkFilePresence(fName)).toBe(true);
+    await testFS.deleteFolder(fName)
+        .then(() => {
+        fail('deleting file as folder must fail');
+    }, (exc) => {
+        expect(exc.notDirectory || exc.notFound).withContext('folder is not a file').toBe(true);
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'deletes folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    for (const fName of ['folder1', 'parent/folder2']) {
+        await testFS.makeFolder(fName);
+        expect(await testFS.checkFolderPresence(fName)).toBe(true);
+        await testFS.deleteFolder(fName);
+        expect(await testFS.checkFolderPresence(fName)).toBe(false);
+    }
+};
+exports.specs.its.push(it);
+it = { expectation: 'will delete folder with content, only when flag is set' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'folder';
+    await testFS.makeFolder(fName);
+    expect(await testFS.checkFolderPresence(fName)).toBe(true);
+    await testFS.writeTxtFile(fName + '/folder2/file1', '');
+    await testFS.writeTxtFile(fName + '/file2', '');
+    await testFS.deleteFolder(fName)
+        .then(() => {
+        fail('cannot remove folder with content, when flag is not set');
+    }, (exc) => {
+        expect(exc.notEmpty).toBe(true);
+    });
+    expect(await testFS.checkFolderPresence(fName)).toBe(true);
+    await testFS.deleteFolder(fName, true);
+    expect(await testFS.checkFolderPresence(fName)).toBe(false);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,96 @@
+"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: '.getByteSink',
+    its: []
+};
+let it = {
+    expectation: 'if not allowed to create, fails for missing file'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    await testFS.getByteSink('non-existing-file', {})
+        .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;
+    const path = 'file1';
+    const content = (0, random_node_1.bytesSync)(2 * 1024);
+    expect(await testFS.checkFilePresence(path)).toBe(false);
+    const sink = await testFS.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 = await testFS.readBytes(path);
+    expect(!!bytes).toBe(true);
+    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;
+    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.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;
+    await testFS.writeBytes(path, bytes);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    const sink = await testFS.getByteSink(path, { truncate: false });
+    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);
+Object.freeze(exports);

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

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