core-3nweb-client-lib 0.44.11 → 0.45.0

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;

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

@@ -0,0 +1,67 @@
+"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: '.getByteSource',
+    its: []
+};
+let it = { expectation: 'fails to read non-existent file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    await testFS.getByteSource('non-existing-file')
+        .then(() => {
+        fail('should fail for missing file');
+    }, (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;
+    const original = (0, random_node_1.bytesSync)(12 * 1024 + 3);
+    let fName = 'file1';
+    await testFS.writeBytes(fName, original);
+    let src = await testFS.getByteSource(fName);
+    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);
+    chunk = await src.readAt(1000, 200);
+    expect(await src.getPosition()).toBe(1200);
+    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(typeof (await src.readNext(100))).withContext('undefined is returned, when there are no more bytes to read').toBe('undefined');
+    fName = 'file2';
+    await testFS.writeBytes(fName, new Uint8Array(0));
+    src = await testFS.getByteSource(fName);
+    expect(typeof (await src.readNext(100))).withContext('reading empty file should produce undefined').toBe('undefined');
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,77 @@
+"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;
+exports.specs = {
+    description: '.getXAttr',
+    its: []
+};
+let it = {
+    expectation: 'fails to read xattr for non-existent path',
+    notIncludedIn: 'device-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'unknown-file';
+    await testFS.getXAttr(fName, 'attribute name')
+        .then(() => {
+        fail('stat-ing 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: 'reads extended attribute',
+    notIncludedIn: 'device-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    async function testforPath(path) {
+        let attrValue = await testFS.getXAttr(path, 'unknown attribute');
+        expect((attrValue === null) || (attrValue === undefined)).withContext('value of attribute that is not present').toBe(true);
+        const attr1Name = 'attribute name 1';
+        const attr1Value = 'some string value';
+        const attr2Name = 'attr2';
+        const attr2Value = 1234;
+        await testFS.updateXAttrs(path, {
+            set: {
+                [attr1Name]: attr1Value,
+                [attr2Name]: attr2Value
+            }
+        });
+        attrValue = await testFS.getXAttr(path, attr1Name);
+        expect(attrValue).toBe(attr1Value);
+        attrValue = await testFS.getXAttr(path, attr2Name);
+        expect(attrValue).toBe(attr2Value);
+    }
+    const file = 'file1';
+    await testFS.writeTxtFile(file, '');
+    await testforPath(file);
+    const file2 = 'file2';
+    await testFS.writeTxtFile(file2, 'non-empty');
+    await testforPath(file2);
+    const folder = 'folder1';
+    await testFS.makeFolder(folder);
+    await testforPath(folder);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,115 @@
+"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 in the same storage,',
+    its: []
+};
+let it = {
+    expectation: 'links readonly file',
+    notIncludedIn: 'win-local-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const fName = 'file1';
+    await testFS.writeTxtFile(fName, original);
+    let file = await testFS.readonlyFile(fName);
+    const linkPath = 'link1';
+    await testFS.link(linkPath, file);
+    const link = await testFS.readLink(linkPath);
+    expect(link.isFile).toBe(true, 'this link should be for a file');
+    expect(link.readonly).toBe(true, 'target extractable via this link should be readonly');
+    file = (await link.target());
+    expect(!!file).withContext('target should be instantiated').toBe(true);
+    expect(file.writable).toBe(false);
+    expect(await file.readTxt()).toBe(original);
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'links writable file',
+    notIncludedIn: 'win-local-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const fName = 'file2';
+    await testFS.writeTxtFile(fName, original);
+    let file = await testFS.writableFile(fName);
+    const linkPath = 'link2';
+    await testFS.link(linkPath, file);
+    const link = await testFS.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(file.writable).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',
+    notIncludedIn: 'win-local-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const folderName = 'folder1';
+    const fName = 'file1';
+    await testFS.writeTxtFile(`${folderName}/${fName}`, original);
+    let folder = await testFS.writableSubRoot(folderName);
+    const linkPath = 'link3';
+    await testFS.link(linkPath, folder);
+    const link = await testFS.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(folder.writable).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);
+it = {
+    expectation: 'creates enslosing folder',
+    notIncludedIn: 'win-local-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const fPath = 'folder1/file1';
+    await testFS.writeTxtFile(fPath, original);
+    let file = await testFS.readonlyFile(fPath);
+    const linkFolder = `link's folder`;
+    expect(await testFS.checkFolderPresence(linkFolder)).toBe(false);
+    const linkPath = `${linkFolder}/link`;
+    await testFS.link(linkPath, file);
+    expect(await testFS.checkFolderPresence(linkFolder)).toBe(true);
+    const link = await testFS.readLink(linkPath);
+    expect(link.isFile).withContext('this link should be for a file').toBe(true);
+    file = (await link.target());
+    expect(!!file).withContext('target should be instantiated').toBe(true);
+    expect(await file.readTxt()).toBe(original);
+};
+exports.specs.its.push(it);

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

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