core-3nweb-client-lib 0.44.12 → 0.45.0

package/build/tests/caps-api/asmail/test-utils.js

@@ -0,0 +1,60 @@
+"use strict";
+/*
+ Copyright (C) 2017 - 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.sendTxtMsg = sendTxtMsg;
+exports.throwDeliveryErrorFrom = throwDeliveryErrorFrom;
+const assert_1 = require("../../../lib-common/assert");
+const error_1 = require("../../../lib-common/exceptions/error");
+/**
+ * This function to be run in renderer's context via execExpects
+ * @param recipient
+ * @param txtBody
+ */
+async function sendTxtMsg(w3n, recipient, txtBody) {
+    const msg = {
+        msgType: 'mail',
+        plainTxtBody: txtBody
+    };
+    const idForSending = 'd5b6';
+    await w3n.mail.delivery.addMsg([recipient], msg, idForSending);
+    expect(await w3n.mail.delivery.currentState(idForSending)).toBeTruthy();
+    const lastInfo = await new Promise((resolve, reject) => {
+        let lastInfo;
+        w3n.mail.delivery.observeDelivery(idForSending, {
+            next: info => (lastInfo = info),
+            complete: () => resolve(lastInfo),
+            error: reject
+        });
+    });
+    expect(typeof lastInfo).toBe('object');
+    expect(lastInfo.allDone).toBe('all-ok');
+    throwDeliveryErrorFrom(lastInfo);
+    await w3n.mail.delivery.rmMsg(idForSending);
+    expect(await w3n.mail.delivery.currentState(idForSending)).toBeFalsy();
+    const recInfo = lastInfo.recipients[recipient];
+    expect(typeof recInfo.idOnDelivery).toBe('string');
+    return recInfo.idOnDelivery;
+}
+function throwDeliveryErrorFrom(lastNotif) {
+    (0, assert_1.assert)(!!lastNotif.allDone, `Given delivery notification is not last`);
+    for (const info of Object.values(lastNotif.recipients)) {
+        if (info.err) {
+            throw (0, error_1.errWithCause)(info.err, `Error occured in message delivery:\n${(0, error_1.stringifyErr)(info.err)}`);
+        }
+    }
+}

package/build/tests/caps-api/asmail.js

@@ -0,0 +1,86 @@
+"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 });
+const jasmine_utils_1 = require("../libs-for-tests/jasmine-utils");
+const setups_1 = require("../libs-for-tests/setups");
+const spec_module_1 = require("../libs-for-tests/spec-module");
+const path_1 = require("path");
+const assert_1 = require("../../lib-common/assert");
+describe('ASMail', () => {
+    const s = (0, setups_1.setupWithUsers)(true, ['Bob Perkins @company.inc', 'John Morrison @bank.com']);
+    beforeAll(() => {
+        (0, assert_1.assert)(s.users.length >= 2, `at least two users should be set up`);
+    });
+    (0, jasmine_utils_1.itCond)('mail is present in common CAPs', async () => {
+        (0, assert_1.assert)(s.users.length > 0);
+        for (const u of s.users) {
+            const w3n = s.testAppCapsByUser(u);
+            expect(typeof w3n.mail).toBe('object');
+            expect(typeof w3n.mail.delivery).toBe('object');
+            expect(typeof w3n.mail.inbox).toBe('object');
+            expect(typeof w3n.mail.config).toBe('object');
+            expect(typeof w3n.mail.getUserId).toBe('function');
+        }
+    }, undefined, s);
+    (0, jasmine_utils_1.itCond)('gets current user id', async () => {
+        (0, assert_1.assert)(s.users.length > 0);
+        for (const u of s.users) {
+            const w3n = s.testAppCapsByUser(u);
+            const userId = await w3n.mail.getUserId();
+            expect(userId).toBe(u.userId);
+        }
+    }, undefined, s);
+    describe(`config`, () => {
+        let config;
+        beforeAll(() => {
+            config = s.testAppCapsByUserIndex(0).mail.config;
+        });
+        (0, jasmine_utils_1.itCond)(`shows parameter' values on the server`, async () => {
+            const initPubKey = await config.getOnServer('init-pub-key');
+            expect(typeof initPubKey).toBe('object');
+            const anonSenderPolicy = await config.getOnServer('anon-sender/policy');
+            expect(anonSenderPolicy).toBeTruthy();
+            expect(typeof anonSenderPolicy.accept).toBe('boolean');
+            expect(typeof anonSenderPolicy.defaultMsgSize).toBe('number');
+            const anonSenderInvites = await config.getOnServer('anon-sender/invites');
+            expect(anonSenderInvites).toBeTruthy();
+            expect(typeof anonSenderInvites).toBe('object');
+        }, undefined, s);
+        (0, jasmine_utils_1.itCond)(`sets parameter' values on the server`, async () => {
+            // some paramaters can be set directly
+            let anonSenderPolicy = await config.getOnServer('anon-sender/policy');
+            const newDefaultMsgSize = anonSenderPolicy.defaultMsgSize + 42;
+            anonSenderPolicy.defaultMsgSize = newDefaultMsgSize;
+            await config.setOnServer('anon-sender/policy', anonSenderPolicy);
+            anonSenderPolicy = await config.getOnServer('anon-sender/policy');
+            expect(anonSenderPolicy.defaultMsgSize).toBe(newDefaultMsgSize);
+            // but public key should be set via keyring cap, and not here
+            await config.setOnServer('init-pub-key', null).then(() => fail(`public key shouldn't be set directly`), err => expect(err).toBeTruthy());
+        }, undefined, s);
+    });
+    (0, jasmine_utils_1.itCond)('inbox lists incoming messages (no messages)', async () => {
+        (0, assert_1.assert)(s.users.length > 0);
+        for (const u of s.users) {
+            const w3n = s.testAppCapsByUser(u);
+            const msgs = await w3n.mail.inbox.listMsgs();
+            expect(Array.isArray(msgs)).toBe(true);
+            expect(msgs.length).toBe(0);
+        }
+    }, undefined, s);
+    (0, spec_module_1.loadSpecs)(s, (0, path_1.join)(__dirname, 'asmail', 'specs'));
+});

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

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

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

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ Copyright (C) 2020 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specs = void 0;
+const random_node_1 = require("../../../lib-common/random-node");
+exports.specs = {
+    description: 'gives file sink',
+    its: []
+    // ,focused:true
+};
+let it = { expectation: 'to write big chunks' };
+it.func = async function (s) {
+    const { testFS } = s;
+    // XXX This is WIP. This catches bug, presumably in writing stage.
+    const fileName = 'big file';
+    const sink = await testFS.getByteSink(fileName, { create: true });
+    // write big chunk
+    const bytes = await (0, random_node_1.bytes)(1000000);
+    await sink.splice(0, bytes.length, bytes);
+    // console.log(` -> layout after splice: ${JSON.stringify(await sink.showLayout(), null, 2)}`);
+    await sink.done();
+    console.log(`Reading file ${fileName}`);
+    const fileContent = await testFS.readBytes(fileName)
+        .catch((err) => {
+        console.log(err.cause);
+        throw err;
+    });
+    console.log(` file content length ${fileContent.length}`);
+    // XXX add some expect checks
+};
+// specs.its.push(it);
+Object.freeze(exports);

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

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

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

@@ -0,0 +1,122 @@
+"use strict";
+/*
+ Copyright (C) 2020 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specs = void 0;
+const random_node_1 = require("../../../lib-common/random-node");
+const bytes_equal_1 = require("../../libs-for-tests/bytes-equal");
+exports.specs = {
+    description: 'gives file sinks, able to splice file content',
+    its: []
+};
+let it = { expectation: 'of a newly created file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    function expectSection(l, sectionInd, src, ofs, len) {
+        const section = l.sections[sectionInd];
+        if (section) {
+            expect(section.src).withContext(`wrong source in section ${sectionInd}`).toBe(src);
+            expect(section.ofs).withContext(`wrong offset in section ${sectionInd}`).toBe(ofs);
+            expect(section.len).withContext(`wrong length in section ${sectionInd}`).toBe(len);
+        }
+        else {
+            fail(`section index ${sectionInd} is not in layout with ${l.sections.length} sections`);
+        }
+    }
+    const fName = 'file1';
+    const sink = await testFS.getByteSink(fName, { create: true, exclusive: true });
+    let size = await sink.getSize();
+    expect(size).toBe(0);
+    let layout = await sink.showLayout();
+    expect(Array.isArray(layout.sections)).toBeTruthy();
+    expect(layout.sections.length).toBe(0);
+    const chunk1 = (0, random_node_1.bytesSync)(10000);
+    await sink.splice(0, chunk1.length, chunk1);
+    size = await sink.getSize();
+    expect(size).toBe(10000);
+    layout = await sink.showLayout();
+    expect(layout.sections.length).toBe(1);
+    expectSection(layout, 0, 'new', 0, size);
+    const chunk2 = (0, random_node_1.bytesSync)(100);
+    await sink.splice(11000, 0, chunk2);
+    size = await sink.getSize();
+    layout = await sink.showLayout();
+    if (testFS.type === 'device') {
+        expect(layout.sections.length).toBe(1);
+        expectSection(layout, 0, 'new', 0, size);
+    }
+    else {
+        expect(layout.sections.length).toBe(3);
+        expectSection(layout, 0, 'new', 0, 10000);
+        expectSection(layout, 1, 'empty', 10000, 1000);
+        expectSection(layout, 2, 'new', 11000, 100);
+    }
+    await sink.done();
+    const content = await testFS.readBytes(fName);
+    expect(content.length).toBe(size);
+    expect((0, bytes_equal_1.bytesEqual)(content.subarray(0, 10000), chunk1)).toBe(true);
+    expect((0, bytes_equal_1.bytesEqual)(content.subarray(11000), chunk2)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'of an existing file without inserting new bytes' };
+it.func = async function (s) {
+    const { testFS } = s;
+    function expectSection(l, sectionInd, src, ofs, len) {
+        const section = l.sections[sectionInd];
+        if (section) {
+            expect(section.src).withContext(`source in section ${sectionInd}`).toBe(src);
+            expect(section.ofs).withContext(`offset in section ${sectionInd}`).toBe(ofs);
+            expect(section.len).withContext(`length in section ${sectionInd}`).toBe(len);
+        }
+        else {
+            fail(`section indexes ${sectionInd} is not in layout with ${l.sections.length} sections`);
+        }
+    }
+    // setup original file
+    const fName = 'file1';
+    let sink = await testFS.getByteSink(fName, { create: true, exclusive: true });
+    const chunk1 = (0, random_node_1.bytesSync)(10000);
+    await sink.splice(0, chunk1.length, chunk1);
+    const chunk2 = (0, random_node_1.bytesSync)(100);
+    await sink.splice(11000, 0, chunk2);
+    await sink.done();
+    const initSize = await sink.getSize();
+    // sink for this test
+    sink = await testFS.getByteSink(fName, { create: false });
+    await sink.splice(5000, 4000);
+    let size = await sink.getSize();
+    expect(size).toBe(initSize - 4000);
+    let layout = await sink.showLayout();
+    if (testFS.type === 'device') {
+        expect(layout.sections.length).toBe(1);
+        expectSection(layout, 0, 'new', 0, size);
+    }
+    else {
+        expect(layout.sections.length).toBe(3);
+        expectSection(layout, 0, 'base', 0, 6000);
+        expectSection(layout, 1, 'empty', 6000, 1000);
+        expectSection(layout, 2, 'base', 7000, 100);
+    }
+    await sink.done();
+    const content = await testFS.readBytes(fName);
+    expect(content.length).toBe(size);
+    expect((0, bytes_equal_1.bytesEqual)(content.subarray(0, 5000), chunk1.subarray(0, 5000))).toBe(true);
+    expect((0, bytes_equal_1.bytesEqual)(content.subarray(5000, 6000), chunk1.subarray(9000))).toBe(true);
+    expect((0, bytes_equal_1.bytesEqual)(content.subarray(7000), chunk2)).toBe(true);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

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

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

@@ -0,0 +1,122 @@
+"use strict";
+/*
+ Copyright (C) 2020 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specs = void 0;
+const random_node_1 = require("../../../lib-common/random-node");
+const bytes_equal_1 = require("../../libs-for-tests/bytes-equal");
+exports.specs = {
+    description: 'gives file sinks, able to truncate file content',
+    its: []
+};
+let it = { expectation: 'of a newly created file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    function expectSection(l, sectionInd, src, ofs, len) {
+        const section = l.sections[sectionInd];
+        if (section) {
+            expect(section.src).withContext(`source in section ${sectionInd}`).toBe(src);
+            expect(section.ofs).withContext(`offset in section ${sectionInd}`).toBe(ofs);
+            expect(section.len).withContext(`length in section ${sectionInd}`).toBe(len);
+        }
+        else {
+            fail(`section index ${sectionInd} is not in layout with ${l.sections.length} sections`);
+        }
+    }
+    const fName = 'file1';
+    const sink = await testFS.getByteSink(fName, { create: true, exclusive: true });
+    let size = await sink.getSize();
+    expect(size).toBe(0);
+    let layout = await sink.showLayout();
+    expect(Array.isArray(layout.sections)).toBeTruthy();
+    expect(layout.sections.length).toBe(0);
+    await sink.truncate(10000);
+    size = await sink.getSize();
+    expect(size).toBe(10000);
+    layout = await sink.showLayout();
+    expect(layout.sections.length).toBe(1);
+    if (testFS.type === 'device') {
+        expectSection(layout, 0, 'new', 0, 10000);
+    }
+    else {
+        expectSection(layout, 0, 'empty', 0, 10000);
+    }
+    const chunk = (0, random_node_1.bytesSync)(10000);
+    await sink.splice(0, chunk.length, chunk);
+    size = await sink.getSize();
+    expect(size).toBe(10000);
+    layout = await sink.showLayout();
+    expect(layout.sections.length).toBe(1);
+    expectSection(layout, 0, 'new', 0, size);
+    await sink.truncate(5000);
+    size = await sink.getSize();
+    expect(size).toBe(5000);
+    layout = await sink.showLayout();
+    expect(layout.sections.length).toBe(1);
+    expectSection(layout, 0, 'new', 0, size);
+    await sink.done();
+    const content = await testFS.readBytes(fName);
+    expect(content.length).toBe(size);
+    expect((0, bytes_equal_1.bytesEqual)(content, chunk.subarray(0, size))).toBe(true);
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'and supports truncating without writing to file (scenario 1), checking version',
+    notIncludedIn: 'device-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    async function checkSizeOf(file, expectedSize, expectedVersion) {
+        const { size, version } = await testFS.stat(file);
+        expect(size).withContext(`file size of "${file}"`).toBe(expectedSize);
+        expect(version).withContext(`file version`).toBe(expectedVersion);
+    }
+    const file = 'file to truncate';
+    let fileVersion = await testFS.v.writeTxtFile(file, '', { create: true, exclusive: true });
+    await checkSizeOf(file, 0, fileVersion);
+    let { sink, version } = await testFS.v.getByteSink(file, {});
+    await sink.truncate(500);
+    await sink.done();
+    await checkSizeOf(file, 500, version);
+    ({ sink, version } = await testFS.v.getByteSink(file, {}));
+    await sink.truncate(100);
+    await sink.done();
+    await checkSizeOf(file, 100, version);
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'and supports truncating without writing to file (scenario 1), without checking versions'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    async function checkSizeOf(file, expectedSize) {
+        const { size, version } = await testFS.stat(file);
+        expect(size).withContext(`file size of "${file}"`).toBe(expectedSize);
+    }
+    const file = 'file to truncate';
+    await testFS.writeTxtFile(file, '', { create: true, exclusive: true });
+    await checkSizeOf(file, 0);
+    let sink = await testFS.getByteSink(file, {});
+    await sink.truncate(500);
+    await sink.done();
+    await checkSizeOf(file, 500);
+    sink = await testFS.getByteSink(file, {});
+    await sink.truncate(100);
+    await sink.done();
+    await checkSizeOf(file, 100);
+};
+exports.specs.its.push(it);

package/build/tests/caps-api/fs-checks/local-to-synced-linking/link.d.ts

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

package/build/tests/caps-api/fs-checks/local-to-synced-linking/link.js

@@ -0,0 +1,82 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2018, 2020 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specs = void 0;
+exports.specs = {
+    description: '.link, when linking from local into synced storage,',
+    its: []
+};
+let it = { expectation: 'links readonly file' };
+it.func = async function (s) {
+    const { syncedTestFS, localTestFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const fName = 'file1';
+    await syncedTestFS.writeTxtFile(fName, original);
+    let file = await syncedTestFS.readonlyFile(fName);
+    const linkPath = 'link1';
+    await localTestFS.link(linkPath, file);
+    const link = await localTestFS.readLink(linkPath);
+    expect(link.isFile).withContext('this link should be for a file').toBe(true);
+    expect(link.readonly).withContext('this link should be readonly').toBe(true);
+    file = (await link.target());
+    expect(!!file).withContext('target should be instantiated').toBe(true);
+    expect(await file.readTxt()).toBe(original);
+    expect(file.writable).toBe(false);
+};
+exports.specs.its.push(it);
+it = { expectation: 'links writable file' };
+it.func = async function (s) {
+    const { syncedTestFS, localTestFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const fName = 'file1';
+    await syncedTestFS.writeTxtFile(fName, original);
+    let file = await syncedTestFS.writableFile(fName);
+    const linkPath = 'link1';
+    await localTestFS.link(linkPath, file);
+    const link = await localTestFS.readLink(linkPath);
+    expect(link.isFile).withContext('this link should be for a file').toBe(true);
+    expect(link.readonly).withContext('this link should be writable').toBe(false);
+    file = (await link.target());
+    expect(!!file).withContext('target should be instantiated').toBe(true);
+    expect(await file.readTxt()).toBe(original);
+    const newTxt = 'I better work. A-a-a!!!';
+    await file.writeTxt(newTxt);
+    expect(await file.readTxt()).toBe(newTxt);
+};
+exports.specs.its.push(it);
+it = { expectation: 'links writable folder' };
+it.func = async function (s) {
+    const { syncedTestFS, localTestFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const folderName = 'folder1';
+    const fName = 'file1';
+    await syncedTestFS.writeTxtFile(`${folderName}/${fName}`, original);
+    let folder = await syncedTestFS.writableSubRoot(folderName);
+    const linkPath = 'link1';
+    await localTestFS.link(linkPath, folder);
+    const link = await localTestFS.readLink(linkPath);
+    expect(link.isFolder).withContext('this link should be for a folder').toBe(true);
+    expect(link.readonly).withContext('this link should be writable').toBe(false);
+    folder = (await link.target());
+    expect(!!folder).withContext('target should be instantiated').toBe(true);
+    expect(await folder.readTxtFile(fName)).toBe(original);
+    const newTxt = 'I better work. A-a-a!!!';
+    await folder.writeTxtFile(fName, newTxt);
+    expect(await folder.readTxtFile(fName)).toBe(newTxt);
+};
+exports.specs.its.push(it);

package/build/tests/caps-api/fs-checks/local-to-synced-linking/reversed-linking.d.ts

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

package/build/tests/caps-api/fs-checks/local-to-synced-linking/reversed-linking.js

@@ -0,0 +1,50 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2018, 2020 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specs = void 0;
+exports.specs = {
+    description: '.link should fail to link from synced into local storage,',
+    its: []
+};
+let it = { expectation: 'linking file' };
+it.func = async function (s) {
+    const { syncedTestFS, localTestFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const fName = 'file1';
+    await localTestFS.writeTxtFile(fName, original);
+    const file = await localTestFS.readonlyFile(fName);
+    const linkPath = 'link1';
+    await syncedTestFS.link(linkPath, file).catch((err) => {
+        expect(typeof err).toBe('object');
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'linking folder' };
+it.func = async function (s) {
+    const { syncedTestFS, localTestFS } = s;
+    const original = 'Should I be at BlackHat conference or working?';
+    const folderName = 'folder1';
+    const fName = 'file1';
+    await localTestFS.writeTxtFile(`${folderName}/${fName}`, original);
+    const folder = await localTestFS.writableSubRoot(folderName);
+    const linkPath = 'link1';
+    await syncedTestFS.link(linkPath, folder).catch((err) => {
+        expect(typeof err).toBe('object');
+    });
+};
+exports.specs.its.push(it);

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

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

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

@@ -0,0 +1,73 @@
+"use strict";
+/*
+ Copyright (C) 2016, 2018, 2020, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specs = void 0;
+exports.specs = {
+    description: '.deleteFile',
+    its: []
+};
+let it = { expectation: 'cannot delete non-existing file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'non-existing-file';
+    expect(await testFS.checkFilePresence(fName)).toBe(false);
+    await testFS.deleteFile(fName)
+        .then(() => {
+        fail('deleting non-existing file must fail');
+    }, (exc) => {
+        expect(exc.notFound).toBe(true);
+    });
+    await testFS.makeFolder(fName);
+    expect(await testFS.checkFolderPresence(fName)).toBe(true);
+    await testFS.deleteFile(fName)
+        .then(() => {
+        fail('deleting folder as file must fail');
+    }, (exc) => {
+        expect(exc.notFile || exc.opNotPermitted).withContext('folder is not a file').toBe(true);
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'deletes file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    for (const fName of ['file1', 'folder/file1']) {
+        await testFS.writeTxtFile(fName, '');
+        expect(await testFS.checkFilePresence(fName)).toBe(true);
+        await testFS.deleteFile(fName);
+        expect(await testFS.checkFilePresence(fName)).toBe(false);
+    }
+};
+exports.specs.its.push(it);
+it = { expectation: 'deletes files concurrently from fs objects that point to same node' };
+it.func = async function (s) {
+    const { testFS } = s;
+    // folder objects should have the same underlying fs node
+    const folders = await Promise.all([1, 2, 3, 4, 5].map(() => testFS.writableSubRoot('folder')));
+    expect(folders.length).toBe(5);
+    const file1Name = 'file1';
+    await folders[0].writeTxtFile(file1Name, 'blah');
+    for (let i = 1; i < folders.length; i += 1) {
+        expect(await folders[i].checkFilePresence(file1Name)).toBeTrue();
+    }
+    await folders[0].deleteFile(file1Name);
+    for (let i = 1; i < folders.length; i += 1) {
+        expect(await folders[i].checkFilePresence(file1Name)).toBeFalse();
+    }
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

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