core-3nweb-client-lib 0.44.11 → 0.45.0

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;

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

@@ -0,0 +1,119 @@
+"use strict";
+/*
+ Copyright (C) 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: '.select',
+    its: []
+};
+let it = { expectation: 'fails early for non-existent path' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'unknown-folder';
+    expect(await testFS.checkFolderPresence(path)).toBe(false);
+    await testFS.select(path, { name: '*.png', action: 'include' })
+        .then(() => {
+        fail('select must fail, when folder does not exist');
+    }, (err) => {
+        expect(err.notFound).toBe(true);
+        if (!err.notFound) {
+            throw err;
+        }
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'selects entities in a file tree' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const path = 'testing select';
+    await testFS.makeFolder(path);
+    // setup files
+    const filePaths = [
+        'some.zip', 'some/some/sOME.zip', '1/Some-folder/3.zip',
+        'else.txt', 'else/else/some.txt', 'else.zip/some.txt'
+    ];
+    for (const fPath of filePaths) {
+        await testFS.writeTxtFile(`${path}/${fPath}`, '');
+    }
+    // select *.zip files
+    let criteria = {
+        name: '*.zip',
+        type: 'file',
+        action: 'include',
+    };
+    let { items, completion } = await testFS.select(path, criteria);
+    expect(typeof completion.catch).toBe('function');
+    expect(typeof completion.then).toBe('function');
+    // wait till collection process is done
+    await completion;
+    let found = await items.getAll();
+    expect(found.length).toBe(3);
+    for (const [name, item] of found) {
+        expect(name.endsWith('.zip')).toBe(true);
+        expect(item.isFile).toBe(true);
+        expect(item.location.path).withContext(`name key for item in collection is the same as path, to ensure uniqueness`).toBe(name);
+        expect(filePaths.includes(name.substring(1))).toBeTruthy();
+        expect(item.location.storageType).toBeFalsy();
+        expect(item.location.storageUse).toBeFalsy();
+        expect(item.location.fs.writable).toBe(false);
+    }
+    // select *.zip folder
+    criteria.type = 'folder';
+    ({ items, completion } = await testFS.select(path, criteria));
+    await completion;
+    found = await items.getAll();
+    expect(found.length).toBe(1);
+    expect(found[0][0].endsWith('.zip')).toBe(true);
+    expect(found[0][1].isFolder).toBe(true);
+    // select folders else
+    criteria = {
+        name: {
+            p: 'else',
+            type: 'exact'
+        },
+        type: 'folder',
+        action: 'include',
+    };
+    ({ items, completion } = await testFS.select(path, criteria));
+    await completion;
+    found = await items.getAll();
+    expect(found.length).toBe(2);
+    expect(found[0][0].endsWith('/else')).toBe(true);
+    expect(found[0][1].isFolder).toBe(true);
+    // select all with o and e in the name
+    criteria = {
+        name: '*o*e*',
+        action: 'include',
+    };
+    ({ items, completion } = await testFS.select(path, criteria));
+    await completion;
+    found = await items.getAll();
+    expect(found.length).toBe(7);
+    // select all folders
+    criteria = {
+        name: '*',
+        type: 'folder',
+        action: 'include',
+    };
+    ({ items, completion } = await testFS.select(path, criteria));
+    await completion;
+    found = await items.getAll();
+    expect(found.length).toBe(7);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/not-versioned/stat.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/stat.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 json_equal_1 = require("../../../libs-for-tests/json-equal");
+exports.specs = {
+    description: '.stat',
+    its: []
+};
+let it = { expectation: 'fails to read non-existent path' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'unknown-file';
+    expect(await testFS.checkFilePresence(fName)).toBe(false);
+    await testFS.stat(fName)
+        .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: 'stats file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let original = 'Should I be at BlackHat conference or working?';
+    let originalFileSize = original.length;
+    let fName = 'file1';
+    await testFS.writeTxtFile(fName, original);
+    let stat = await testFS.stat(fName);
+    expect(typeof stat).toBe('object');
+    expect(stat).not.toBeNull();
+    expect(stat.isFile).withContext('flag indicating that path points to file').toBe(true);
+    expect(stat.size).withContext('file size').toBe(originalFileSize);
+    expect(stat.writable).toBe(true);
+    let sndTxt = 'I better work!';
+    let sndVersionFileSize = sndTxt.length;
+    await testFS.writeTxtFile(fName, sndTxt);
+    stat = await testFS.stat(fName);
+    expect(stat.isFile).withContext('flag indicating that path points to file').toBe(true);
+    expect(stat.size).withContext('file size').toBe(sndVersionFileSize);
+    expect(stat.writable).toBe(true);
+    const roFS = await testFS.readonlySubRoot('');
+    stat = await roFS.stat(fName);
+    expect(stat.isFile).withContext('flag indicating that path points to file').toBe(true);
+    expect(stat.size).withContext('file size').toBe(sndVersionFileSize);
+    expect(stat.writable).toBe(false);
+};
+exports.specs.its.push(it);
+it = { expectation: 'stats folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'folder1';
+    await testFS.makeFolder(fName);
+    let stat = await testFS.stat(fName);
+    expect(typeof stat).toBe('object');
+    expect(stat).not.toBeNull();
+    expect(stat.isFolder).withContext('flag indicating that path points to folder').toBe(true);
+    expect(stat.writable).toBe(true);
+    const roFS = await testFS.readonlySubRoot('');
+    stat = await roFS.stat(fName);
+    expect(stat.isFolder).withContext('flag indicating that path points to folder').toBe(true);
+    expect(stat.writable).toBe(false);
+};
+exports.specs.its.push(it);
+it = { expectation: `stats fs' root` };
+it.func = async function (s) {
+    const { testFS } = s;
+    const stat = await testFS.stat('');
+    expect(stat.isFolder).toBe(true);
+    expect(stat.writable).toBe(true);
+    let stat2 = await testFS.stat('.');
+    expect((0, json_equal_1.deepEqual)(stat, stat2)).toBe(true);
+    stat2 = await testFS.stat('/');
+    expect((0, json_equal_1.deepEqual)(stat, stat2)).toBe(true);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,126 @@
+"use strict";
+/*
+ Copyright (C) 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.specs = void 0;
+const json_equal_1 = require("../../../libs-for-tests/json-equal");
+exports.specs = {
+    description: '.updateXAttrs',
+    its: []
+};
+let it = {
+    expectation: 'fails to change xattr for non-existent path',
+    notIncludedIn: 'device-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'unknown-file';
+    await testFS.updateXAttrs(fName, { remove: ['some attribute'] })
+        .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: 'changes extended attributes',
+    notIncludedIn: 'device-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    async function testforPath(path) {
+        const initStats = await testFS.stat(path);
+        let xattrNames = await testFS.listXAttrs(path);
+        expect(xattrNames.length).toBe(0);
+        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
+            }
+        });
+        xattrNames = await testFS.listXAttrs(path);
+        expect(xattrNames).toContain(attr1Name);
+        expect(xattrNames).toContain(attr2Name);
+        expect(await testFS.getXAttr(path, attr1Name)).toBe(attr1Value);
+        expect(await testFS.getXAttr(path, attr2Name)).toBe(attr2Value);
+        let stats = await testFS.stat(path);
+        expect(stats.mtime.valueOf()).withContext(`Update of xattrs shouldn't change mtime, part of common attrs`).toBe(initStats.mtime.valueOf());
+        const newAttr2Value = { a: 123, b: 'sdf', c: [1, 2] };
+        await testFS.updateXAttrs(path, {
+            remove: [attr1Name],
+            set: {
+                [attr2Name]: newAttr2Value
+            }
+        });
+        xattrNames = await testFS.listXAttrs(path);
+        expect(xattrNames).not.toContain(attr1Name);
+        expect(xattrNames).toContain(attr2Name);
+        expect((0, json_equal_1.deepEqual)(await testFS.getXAttr(path, attr2Name), newAttr2Value)).toBe(true);
+    }
+    const file1 = 'file1';
+    await testFS.writeTxtFile(file1, '');
+    await testforPath(file1);
+    expect((await testFS.stat(file1)).size).toBe(0);
+    expect(await testFS.readTxtFile(file1)).toBe('');
+    const file2 = 'file2';
+    const file2txt = 'non-empty content';
+    await testFS.writeTxtFile(file2, file2txt);
+    await testforPath(file2);
+    expect((await testFS.stat(file2)).size).toBe(file2txt.length);
+    expect(await testFS.readTxtFile(file2)).toBe(file2txt);
+    const folder = 'folder1';
+    await testFS.makeFolder(folder);
+    await testforPath(folder);
+    expect((await testFS.listFolder(folder)).length).toBe(0);
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'empty binary and string attribute values',
+    notIncludedIn: 'device-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    const file = 'fileWithEmptyAttrs';
+    const emptyStringAttr = 'empty.string';
+    const emptyBinaryAttr = 'empty.binary';
+    await testFS.writeTxtFile(file, '');
+    const attrsLst = await testFS.listXAttrs(file);
+    expect(attrsLst).not.toContain(emptyStringAttr);
+    expect(attrsLst).not.toContain(emptyBinaryAttr);
+    await testFS.updateXAttrs(file, {
+        set: {
+            [emptyStringAttr]: '',
+            [emptyBinaryAttr]: new Uint8Array(0)
+        }
+    });
+    const emptyStrAttrValue = await testFS.getXAttr(file, emptyStringAttr);
+    expect(typeof emptyStrAttrValue).toBe('string');
+    expect(emptyStrAttrValue).toBe('');
+    const emptyBinAttrValue = await testFS.getXAttr(file, emptyBinaryAttr);
+    expect(typeof emptyBinAttrValue).toBe('object');
+    expect(emptyBinAttrValue.length).toBe(0);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,79 @@
+"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: '.writableFile',
+    its: []
+};
+let it = {
+    expectation: 'fails for non-existing file, in non-create mode'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'unknown-file';
+    expect(await testFS.checkFilePresence(fName)).toBe(false);
+    try {
+        await testFS.writableFile(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: 'fails for existing file, in exclusive create mode' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'file';
+    await testFS.writeTxtFile(fName, '');
+    expect(await testFS.checkFilePresence(fName)).toBe(true);
+    try {
+        await testFS.writableFile(fName, { create: true, exclusive: true });
+        fail('getting file object must fail, when file exists');
+    }
+    catch (err) {
+        expect(err.alreadyExists).toBe(true);
+        if (!err.alreadyExists) {
+            throw err;
+        }
+    }
+};
+exports.specs.its.push(it);
+it = { expectation: 'gives file object for non-existing file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'new-file';
+    expect(await testFS.checkFilePresence(fName)).toBe(false);
+    let file = await testFS.writableFile(fName);
+    expect(typeof file).toBe('object');
+    expect(file.name).withContext('file object should have file name').toBe(fName);
+    expect(file.isNew).withContext('readonly file must exist').toBe(true);
+    expect(file.writable).toBe(true);
+    expect(!!file.v).toBe(!!testFS.v);
+    expect(await testFS.checkFilePresence(fName)).withContext('File does not exist, while nothing has been written to it.').toBe(false);
+    let txt = 'some text';
+    await file.writeTxt(txt);
+    expect(await testFS.checkFilePresence(fName)).withContext('File is created on the first write.').toBe(true);
+    expect(await file.readTxt()).toBe(txt);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

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