core-3nweb-client-lib 0.44.12 → 0.45.1

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;

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

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

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

@@ -0,0 +1,73 @@
+"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: '.listXAttrs',
+    its: []
+};
+let it = {
+    expectation: 'fails to read xattrs for non-existent path',
+    notIncludedIn: 'device-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'unknown-file';
+    await testFS.listXAttrs(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: 'lists extended attributes',
+    notIncludedIn: 'device-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    async function testforPath(path) {
+        let xattrNames = await testFS.listXAttrs(path);
+        expect(Array.isArray(xattrNames)).toBe(true);
+        expect(xattrNames.length).toBe(0);
+        const attr1Name = 'attribute name 1';
+        const attr2Name = 'attr2';
+        await testFS.updateXAttrs(path, {
+            set: {
+                [attr1Name]: 'some string value',
+                [attr2Name]: 1234
+            }
+        });
+        xattrNames = await testFS.listXAttrs(path);
+        expect(xattrNames.length).toBe(2);
+        expect(xattrNames).toContain(attr1Name);
+        expect(xattrNames).toContain(attr2Name);
+    }
+    const file = 'file1';
+    await testFS.writeTxtFile(file, '');
+    await testforPath(file);
+    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/makeFolder.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/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;