core-3nweb-client-lib 0.44.12 → 0.45.0

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

@@ -0,0 +1,95 @@
+"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: '.makeFolder',
+    its: []
+};
+let it = { expectation: 'creates in existing parent' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'folder';
+    expect(await testFS.checkFolderPresence(fName)).toBe(false);
+    await testFS.makeFolder(fName);
+    expect(await testFS.checkFolderPresence(fName)).toBe(true);
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'is a no-op, when folder exists, and a call is not exclusive'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    for (let fName of ['folder2', 'parent2/folder2']) {
+        expect(await testFS.checkFolderPresence(fName)).toBe(false);
+        await testFS.makeFolder(fName);
+        expect(await testFS.checkFolderPresence(fName)).toBe(true);
+        await testFS.makeFolder(fName)
+            .catch(() => {
+            fail('non exclusive creation should not throw');
+        });
+        expect(await testFS.checkFolderPresence(fName)).toBe(true);
+    }
+};
+exports.specs.its.push(it);
+it = { expectation: 'exclusive creation fails if folder exists' };
+it.func = async function (s) {
+    const { testFS } = s;
+    for (let fName of ['folder3', 'parent3/folder3']) {
+        expect(await testFS.checkFolderPresence(fName)).toBe(false);
+        await testFS.makeFolder(fName);
+        expect(await testFS.checkFolderPresence(fName)).toBe(true);
+        await testFS.makeFolder(fName, true)
+            .then(() => {
+            fail('Exclusive creation of folder fails to throw.');
+        }, (e) => {
+            if (!e.alreadyExists) {
+                fail('incorrect exception');
+            }
+        });
+    }
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates parent folder(s) on the way' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'folder';
+    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);
+    await testFS.makeFolder(path);
+    expect(await testFS.checkFolderPresence(path)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'can handle concurrent creation' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'concurrent/a/b/c/d/e/f/g/h';
+    expect(await testFS.checkFolderPresence(path)).toBe(false);
+    let concurrentTasks = [];
+    for (let i = 0; i < 10; i += 1) {
+        concurrentTasks.push(testFS.makeFolder(path));
+    }
+    await Promise.all(concurrentTasks);
+    expect(await testFS.checkFolderPresence(path)).toBe(true);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,127 @@
+"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: '.move',
+    its: []
+};
+let it = { expectation: 'cannot move non-existing element' };
+it.func = async function (s) {
+    const { testFS } = s;
+    for (let src of ['non/existing/thing', 'thing']) {
+        await testFS.move(src, 'thing2')
+            .then(() => {
+            fail('move should fail, when source path does not exist');
+        }, (exc) => {
+            expect(exc.notFound).toBe(true);
+        });
+    }
+};
+exports.specs.its.push(it);
+it = { expectation: 'cannot move when destination path already exists' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let src = 'folder1/file';
+    let srcFileContent = '1st file';
+    await testFS.writeTxtFile(src, srcFileContent);
+    for (let dst of ['folder2/file2', 'folder1/file2']) {
+        await testFS.writeTxtFile(dst, '2nd file');
+        expect(await testFS.readTxtFile(dst)).not.toBe(srcFileContent);
+        await testFS.move(src, dst)
+            .then(() => {
+            fail('move should fail, when destination path already exists');
+        }, (exc) => {
+            expect(exc.alreadyExists).toBe(true);
+        });
+        expect(await testFS.readTxtFile(dst)).not.toBe(srcFileContent, 'existing destination path should stay intact');
+    }
+};
+exports.specs.its.push(it);
+it = { expectation: 'moves element in the same folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    // moving folder
+    let src = 'folder3/folder';
+    let dst = 'folder3/folder-moved';
+    await testFS.makeFolder(src);
+    expect(await testFS.checkFolderPresence(src)).toBe(true);
+    expect(await testFS.checkFolderPresence(dst)).toBe(false);
+    await testFS.move(src, dst);
+    expect(await testFS.checkFolderPresence(src)).toBe(false);
+    expect(await testFS.checkFolderPresence(dst)).toBe(true);
+    // moving file
+    src = 'folder3/file';
+    dst = 'folder3/file-moved';
+    await testFS.writeTxtFile(src, 'file to move');
+    expect(await testFS.checkFilePresence(src)).toBe(true);
+    expect(await testFS.checkFilePresence(dst)).toBe(false);
+    await testFS.move(src, dst);
+    expect(await testFS.checkFilePresence(src)).toBe(false);
+    expect(await testFS.checkFilePresence(dst)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'moves element to a different folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    // moving folder
+    let src = 'folder4/folder';
+    let dst = 'folder5/folder-moved';
+    await testFS.makeFolder(src);
+    expect(await testFS.checkFolderPresence(src)).toBe(true);
+    expect(await testFS.checkFolderPresence(dst)).toBe(false);
+    await testFS.move(src, dst);
+    expect(await testFS.checkFolderPresence(src)).toBe(false);
+    expect(await testFS.checkFolderPresence(dst)).toBe(true);
+    // moving file
+    src = 'folder4/file';
+    dst = 'folder5/file-moved';
+    await testFS.writeTxtFile(src, 'file to move');
+    expect(await testFS.checkFilePresence(src)).toBe(true);
+    expect(await testFS.checkFilePresence(dst)).toBe(false);
+    await testFS.move(src, dst);
+    expect(await testFS.checkFilePresence(src)).toBe(false);
+    expect(await testFS.checkFilePresence(dst)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates parent section(s) in destination path' };
+it.func = async function (s) {
+    const { testFS } = s;
+    // moving folder
+    let src = 'folder6/folder';
+    let dstParent = 'folder6.dst/sub-folder';
+    let dst = `${dstParent}/folder-moved`;
+    await testFS.makeFolder(src);
+    expect(await testFS.checkFolderPresence(src)).toBe(true);
+    expect(await testFS.checkFolderPresence(dstParent)).toBe(false);
+    await testFS.move(src, dst);
+    expect(await testFS.checkFolderPresence(src)).toBe(false);
+    expect(await testFS.checkFolderPresence(dst)).toBe(true);
+    // moving file
+    src = 'folder6/file';
+    dstParent = 'folder6.dst-2/sub-folder-2';
+    dst = `${dstParent}/file-moved`;
+    await testFS.writeTxtFile(src, 'file to move');
+    expect(await testFS.checkFilePresence(src)).toBe(true);
+    expect(await testFS.checkFolderPresence(dstParent)).toBe(false);
+    await testFS.move(src, dst);
+    expect(await testFS.checkFilePresence(src)).toBe(false);
+    expect(await testFS.checkFilePresence(dst)).toBe(true);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,80 @@
+"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: '.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);
+    await testFS.readBytes(fName)
+        .then(() => {
+        fail('reading bytes must fail, when file does not exist');
+    }, (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';
+    await testFS.writeBytes(fName, originalBytes);
+    let bytes = await testFS.readBytes(fName);
+    expect((0, bytes_equal_1.bytesEqual)(bytes, originalBytes)).withContext('file read should produce array with all bytes').toBe(true);
+    fName = 'file2';
+    await testFS.writeBytes(fName, new Uint8Array(0));
+    bytes = await testFS.readBytes(fName);
+    expect(bytes).withContext('reading empty file should produce undefined').toBeUndefined();
+};
+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);
+    await testFS.writeBytes(fName, originalBytes);
+    let bytes = await testFS.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);
+    bytes = await testFS.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);
+    bytes = await testFS.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);
+    bytes = await testFS.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);
+    bytes = await testFS.readBytes(fName, 1024 * 1024, 1024 * 1024 + 4);
+    expect(bytes).withContext('when start is greater than file size, undefined must be returned').toBeUndefined();
+    bytes = await testFS.readBytes(fName, 1024 * 1024);
+    expect(bytes).withContext('when start is greater than file size, undefined must be returned').toBeUndefined();
+    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 = await testFS.readBytes(fName, 1234, 100);
+    expect(bytes).withContext('when end is smaller than start , undefined must be returned').toBeUndefined();
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,59 @@
+"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: '.readJSONFile',
+    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);
+    await testFS.readJSONFile(fName)
+        .then(() => {
+        fail('reading json must fail, when file does not exist');
+    }, (err) => {
+        expect(err.notFound).toBe(true);
+        if (!err.notFound) {
+            throw err;
+        }
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'reads json file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let original = { a: 'foo', b: true, 'df-df': 23 };
+    let fName = 'file1';
+    await testFS.writeJSONFile(fName, original);
+    let json = await testFS.readJSONFile(fName);
+    expect((0, json_equal_1.deepEqual)(json, original)).withContext('file read should produce original json').toBe(true);
+    fName = 'file2';
+    await testFS.writeBytes(fName, new Uint8Array(0));
+    await testFS.readJSONFile(fName)
+        .then(() => {
+        fail('reading empty file should fail, as empty is not valid json');
+    }, (exc) => {
+        expect(exc).toBeTruthy();
+    });
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,39 @@
+"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: '.readLink',
+    its: []
+};
+let it = { expectation: 'cannot read non-existing link' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'non-existing-link';
+    try {
+        await testFS.readLink(fName);
+        fail('reading non-existing link must fail');
+    }
+    catch (exc) {
+        expect(exc.notFound).toBe(true);
+        if (!exc.notFound) {
+            throw exc;
+        }
+    }
+};
+exports.specs.its.push(it);

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

@@ -0,0 +1,54 @@
+"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: '.readTxtFile',
+    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);
+    await testFS.readTxtFile(fName)
+        .then(() => {
+        fail('reading text must fail, when file does not exist');
+    }, (err) => {
+        expect(err.notFound).toBe(true);
+        if (!err.notFound) {
+            throw err;
+        }
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'reads json file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let original = 'Should I be at BlackHat conference or working?';
+    let fName = 'file1';
+    await testFS.writeTxtFile(fName, original);
+    let txt = await testFS.readTxtFile(fName);
+    expect(txt).withContext('file read should produce original text').toBe(original);
+    fName = 'file2';
+    await testFS.writeBytes(fName, new Uint8Array(0));
+    txt = await testFS.readTxtFile(fName);
+    expect(txt).toBe('');
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,55 @@
+"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: '.readonlyFile',
+    its: []
+};
+let it = { expectation: 'fails for 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.readonlyFile(fName);
+        fail('getting file object 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: 'gives file object' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let original = 'Should I be at BlackHat conference or working?';
+    let fName = 'file';
+    await testFS.writeTxtFile(fName, original);
+    let file = await testFS.readonlyFile(fName);
+    expect(typeof file).toBe('object');
+    expect(file.writable).toBe(false);
+    expect(!!file.v).toBe(!!testFS.v);
+    expect(file.name).withContext('file object should have file name').toBe(fName);
+    expect(file.isNew).withContext('readonly file must exist').toBe(false);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,55 @@
+"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: '.readonlySubRoot',
+    its: []
+};
+let it = { expectation: 'creates sub-root based on existing folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'sub-root';
+    await testFS.makeFolder(path);
+    expect(await testFS.checkFolderPresence(path)).toBe(true);
+    let subRoot = await testFS.readonlySubRoot(path);
+    expect(subRoot).toBeTruthy();
+    expect(subRoot.writable).toBe(false);
+    expect(!!subRoot.v).toBe(!!testFS.v);
+    const lst = await subRoot.listFolder('');
+    expect(Array.isArray(lst)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'fails to create a sub-root, whenfolder is missing' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'sub-root2';
+    expect(await testFS.checkFolderPresence(path)).toBe(false);
+    try {
+        await testFS.readonlySubRoot(path);
+        fail('making a readonly sub-root on a missing folder should fail');
+    }
+    catch (exc) {
+        expect(exc.notFound).toBe(true);
+        if (!exc.notFound) {
+            throw exc;
+        }
+    }
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

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