core-3nweb-client-lib 0.44.11 → 0.45.0

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

@@ -0,0 +1,60 @@
+"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: '.v.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.v.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';
+    let v1 = await testFS.v.writeJSONFile(fName, original);
+    let { json, version } = await testFS.v.readJSONFile(fName);
+    expect((0, json_equal_1.deepEqual)(json, original)).withContext('file read should produce original json').toBe(true);
+    expect(version).withContext('file version at reading should exactly the same as that on respective write').toBe(v1);
+    let v2 = await testFS.v.writeBytes(fName, new Uint8Array(0));
+    expect(v2).toBeGreaterThan(v1);
+    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/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/versioned/readTxtFile.js

@@ -0,0 +1,56 @@
+"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: '.v.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.v.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';
+    let v1 = await testFS.v.writeTxtFile(fName, original);
+    let { txt, version } = await testFS.v.readTxtFile(fName);
+    expect(txt).withContext('file read should produce original text').toBe(original);
+    expect(version).withContext('file version at reading should exactly the same as that on respective write').toBe(v1);
+    let v2 = await testFS.v.writeBytes(fName, new Uint8Array(0));
+    expect(v2).toBeGreaterThan(v1);
+    ({ txt, version } = await testFS.v.readTxtFile(fName));
+    expect(txt).withContext('empty file should be read as an empty string').toBe('');
+    expect(version).withContext('file version at reading should exactly the same as that on respective write').toBe(v2);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/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/versioned/stat.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;
+exports.specs = {
+    description: '.stat',
+    its: []
+};
+let it = { expectation: 'fails to read non-existent path' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const 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;
+    const original = 'Should I be at BlackHat conference or working?';
+    const originalFileSize = original.length;
+    const 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(typeof stat.version).toBe('number');
+    const fstVersion = stat.version;
+    const sndTxt = 'I better work!';
+    const 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.version).withContext('second version of the file').toBe(fstVersion + 1);
+};
+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(typeof stat.version).toBe('number');
+    const fstVersion = stat.version;
+    await testFS.writeTxtFile(`${fName}/some-file`, '');
+    stat = await testFS.stat(fName);
+    expect(stat.isFolder).withContext('flag indicating that path points to folder').toBe(true);
+    expect(stat.version).withContext('second version of the folder').toBe(fstVersion + 1);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,64 @@
+"use strict";
+/*
+ Copyright (C) 2022 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 deferred_1 = require("../../../../lib-common/processes/deferred");
+exports.specs = {
+    description: '.watchFile',
+    its: []
+};
+let it = { expectation: 'fails to watch non-existent path' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'unknown-file';
+    expect(await testFS.checkFilePresence(fName)).toBe(false);
+    const expectedExc = (0, deferred_1.defer)();
+    const sub = testFS.watchFile(fName, {
+        next: () => expectedExc.reject('watching must fail, when path does not exist'),
+        complete: () => expectedExc.reject('watching must fail, when path does not exist'),
+        error: exc => expectedExc.resolve(exc)
+    });
+    const exc = await expectedExc.promise;
+    expect(exc.type).toBe('file');
+    expect(exc.notFound).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'gets file change event' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'file to watch';
+    await testFS.writeTxtFile(fName, '');
+    const expectedEv = (0, deferred_1.defer)();
+    const unsub = testFS.watchFile(fName, {
+        next: ev => {
+            if (ev.type === 'file-change') {
+                expectedEv.resolve(ev);
+            }
+        },
+        complete: () => expectedEv.reject(`Early completion`),
+        error: err => expectedEv.reject(err)
+    });
+    // change file to get file
+    await testFS.writeTxtFile(fName, 'new value');
+    const changeEvent = await expectedEv.promise;
+    expect(changeEvent.src).toBe('local');
+    expect(typeof changeEvent.newVersion).toBe('number');
+    unsub();
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,128 @@
+"use strict";
+/*
+ Copyright (C) 2016 - 2018, 2020, 2022 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: '.v.writeBytes',
+    its: []
+};
+let it = { expectation: 'if not allowed to create, fails for missing file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    await testFS.v.writeBytes('non-existing-file', (0, random_node_1.bytesSync)(123), {})
+        .then(() => {
+        fail('should fail for missing file');
+    }, (e) => {
+        expect(e.notFound).toBe(true);
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates file in existing folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file1';
+    let content = (0, random_node_1.bytesSync)(2 * 1024);
+    expect(await testFS.checkFilePresence(path)).toBe(false);
+    let v = await testFS.v.writeBytes(path, content);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let { bytes, version } = await testFS.v.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(content, bytes)).toBe(true);
+    expect(version).toBe(v);
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates parent folder(s) on the way' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'file2';
+    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);
+    let content = (0, random_node_1.bytesSync)(2 * 1024);
+    let v = await testFS.v.writeBytes(path, content);
+    expect(await testFS.checkFolderPresence(grParent)).toBe(true);
+    expect(await testFS.checkFolderPresence(parent2)).toBe(true);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let { bytes, version } = await testFS.v.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(content, bytes)).toBe(true);
+    expect(version).toBe(v);
+};
+exports.specs.its.push(it);
+it = { expectation: 'over-writes existing file with a non-exclusive call' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file3';
+    // setup initial file
+    let initBytes = (0, random_node_1.bytesSync)(123);
+    let v1 = await testFS.v.writeBytes(path, initBytes);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let { bytes, version } = await testFS.v.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(initBytes, bytes)).toBe(true);
+    expect(version).toBe(v1);
+    // write new file content
+    let newContent = (0, random_node_1.bytesSync)(3223);
+    let v2 = await testFS.v.writeBytes(path, newContent);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect(v2).toBeGreaterThan(v1);
+    ({ bytes, version } = await testFS.v.readBytes(path));
+    expect(version).toBe(v2);
+    expect((0, bytes_equal_1.bytesEqual)(newContent, bytes)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'exclusive-create write throws when file already exists' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file4';
+    // setup initial file
+    let initBytes = (0, random_node_1.bytesSync)(123);
+    let v = await testFS.v.writeBytes(path, initBytes);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    // try an exclusive write
+    let newContent = (0, random_node_1.bytesSync)(3223);
+    await testFS.writeBytes(path, newContent, { create: true, exclusive: true })
+        .then(() => {
+        fail('exclusive-create write operation must fail, when file exists.');
+    }, (exc) => {
+        expect(exc.alreadyExists).toBe(true);
+    });
+    let { bytes, version } = await testFS.v.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(initBytes, bytes)).withContext('initial file content stays intact').toBe(true);
+    expect(version).withContext('initial file version stays intact').toBe(v);
+};
+exports.specs.its.push(it);
+it = { expectation: 'writes 4K-even content' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const kb4 = 4 * 1024;
+    for (const [fName, contentLen] of [
+        ['file-20kb', 5 * kb4],
+        ['file-4kb', kb4],
+        ['file-16kb', 4 * kb4],
+    ]) {
+        const content = (0, random_node_1.bytesSync)(contentLen);
+        await testFS.v.writeBytes(fName, content);
+        expect((0, bytes_equal_1.bytesEqual)((await testFS.v.readBytes(fName)).bytes, content))
+            .toBeTrue();
+    }
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,111 @@
+"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: '.v.writeJSONFile',
+    its: []
+};
+let it = { expectation: 'if not allowed to create, fails for missing file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let json = { a: 1, b: 2 };
+    await testFS.v.writeJSONFile('non-existing-file', json, {})
+        .then(() => {
+        fail('should fail for missing file');
+    }, (e) => {
+        expect(e.notFound).toBe(true);
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates file in existing folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file1';
+    let initJson = { a: 1, b: 2 };
+    expect(await testFS.checkFilePresence(path)).toBe(false);
+    let v = await testFS.v.writeJSONFile(path, initJson);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let { json, version } = await testFS.v.readJSONFile(path);
+    expect((0, json_equal_1.deepEqual)(initJson, json)).toBe(true);
+    expect(version).toBe(v);
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates parent folder(s) on the way' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'file2';
+    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);
+    let initJson = { a: 'foo', b: true, 'df-df': 23 };
+    let v = await testFS.v.writeJSONFile(path, initJson);
+    expect(await testFS.checkFolderPresence(grParent)).toBe(true);
+    expect(await testFS.checkFolderPresence(parent2)).toBe(true);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let { json, version } = await testFS.v.readJSONFile(path);
+    expect((0, json_equal_1.deepEqual)(initJson, json)).toBe(true);
+    expect(version).toBe(v);
+};
+exports.specs.its.push(it);
+it = { expectation: 'over-writes existing file with a non-exclusive call' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file3';
+    // setup initial file
+    let initJson = { a: 'foo', b: true, 'df-df': 23 };
+    let v1 = await testFS.v.writeJSONFile(path, initJson);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let { json, version } = await testFS.v.readJSONFile(path);
+    expect((0, json_equal_1.deepEqual)(initJson, json)).toBe(true);
+    expect(version).toBe(v1);
+    // write new file content
+    let newJson = null;
+    let v2 = await testFS.v.writeJSONFile(path, newJson);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    ({ json, version } = await testFS.v.readJSONFile(path));
+    expect((0, json_equal_1.deepEqual)(newJson, json)).toBe(true);
+    expect(version).toBe(v2);
+};
+exports.specs.its.push(it);
+it = { expectation: 'exclusive-create write throws when file already exists' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file4';
+    // setup initial file
+    let initJson = { a: 'foo', b: true, 'df-df': 23 };
+    let v = await testFS.v.writeJSONFile(path, initJson);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    // try an exclusive write
+    let newJson = null;
+    await testFS.writeJSONFile(path, newJson, { create: true, exclusive: true })
+        .then(() => {
+        fail('exclusive-create write operation must fail, when file exists.');
+    }, (exc) => {
+        expect(exc.alreadyExists).toBe(true);
+    });
+    let { json, version } = await testFS.v.readJSONFile(path);
+    expect((0, json_equal_1.deepEqual)(initJson, json)).withContext('initial file content stays intact').toBe(true);
+    expect(version).withContext('initial file version stays intact').toBe(v);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,107 @@
+"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: '.v.writeTxtFile',
+    its: []
+};
+let it = { expectation: 'if not allowed to create, fails for missing file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let txt = 'Should I be at BlackHat conference or working?';
+    await testFS.v.writeTxtFile('non-existing-file', txt, {})
+        .then(() => {
+        fail('should fail for missing file');
+    }, (e) => {
+        expect(e.notFound).toBe(true);
+    });
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates file in existing folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file1';
+    let txt = 'Should I be at BlackHat conference or working?';
+    expect(await testFS.checkFilePresence(path)).toBe(false);
+    await testFS.writeTxtFile(path, txt);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect((await testFS.v.readTxtFile(path)).txt).toBe(txt);
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates parent folder(s) on the way' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let fName = 'file2';
+    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);
+    let txt = 'Should I be at BlackHat conference or working?';
+    await testFS.writeTxtFile(path, txt);
+    expect(await testFS.checkFolderPresence(grParent)).toBe(true);
+    expect(await testFS.checkFolderPresence(parent2)).toBe(true);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect((await testFS.v.readTxtFile(path)).txt).toBe(txt);
+};
+exports.specs.its.push(it);
+it = { expectation: 'over-writes existing file with a non-exclusive call' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file3';
+    // setup initial file
+    let initTxt = 'Should I be at BlackHat conference or working?';
+    let v1 = await testFS.v.writeTxtFile(path, initTxt);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let { txt, version } = await testFS.v.readTxtFile(path);
+    expect(txt).toBe(initTxt);
+    expect(version).toBe(v1);
+    // write new file content
+    let newTxt = 'Work gives tangible benefits.\nRetire and go anywhere.';
+    let v2 = await testFS.v.writeTxtFile(path, newTxt);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect(v2).toBeGreaterThan(v1);
+    ({ txt, version } = await testFS.v.readTxtFile(path));
+    expect(txt).toBe(newTxt);
+    expect(version).toBe(v2);
+};
+exports.specs.its.push(it);
+it = { expectation: 'exclusive-create write throws when file already exists' };
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file4';
+    // setup initial file
+    let initTxt = 'Should I be at BlackHat conference or working?';
+    let v = await testFS.v.writeTxtFile(path, initTxt);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    // try an exclusive write
+    let newTxt = 'Work gives tangible benefits.\nRetire and go anywhere.';
+    await testFS.writeTxtFile(path, newTxt, { create: true, exclusive: true })
+        .then(() => {
+        fail('exclusive-create write operation must fail, when file exists.');
+    }, (exc) => {
+        expect(exc.alreadyExists).toBe(true);
+    });
+    let { txt, version } = await testFS.v.readTxtFile(path);
+    expect(txt).withContext('initial file content stays intact').toBe(initTxt);
+    expect(version).withContext('initial file version stays intact').toBe(v);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

package/build/tests/caps-api/fs-checks/with-core-restarts/xattrs.d.ts

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