core-3nweb-client-lib 0.44.12 → 0.45.1

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;

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

@@ -0,0 +1,90 @@
+"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: '.writableSubRoot',
+    its: []
+};
+let it = { expectation: 'creates sub-root based on existing folder' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const path = 'sub-root';
+    await testFS.makeFolder(path);
+    expect(await testFS.checkFolderPresence(path)).toBe(true);
+    const subRoot = await testFS.writableSubRoot(path);
+    expect(subRoot).toBeTruthy();
+    expect(subRoot.writable).toBe(true);
+    expect(!!subRoot.v).toBe(!!testFS.v);
+    const lst = await subRoot.listFolder('');
+    expect(Array.isArray(lst)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates new folder for a sub-root' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const path = 'sub-root2';
+    expect(await testFS.checkFolderPresence(path)).toBe(false);
+    const subRoot = await testFS.writableSubRoot(path);
+    expect(subRoot).toBeTruthy();
+    expect(subRoot.writable).toBe(true);
+    expect(!!subRoot.v).toBe(!!testFS.v);
+    const lst = await subRoot.listFolder('');
+    expect(Array.isArray(lst)).toBe(true);
+};
+exports.specs.its.push(it);
+it = { expectation: 'creates parent folder(s) on the way' };
+it.func = async function (s) {
+    const { testFS } = s;
+    const fName = 'sub-root';
+    const grParent = 'grand-parent';
+    const parent = 'grand-parent/parent';
+    const path = `${parent}/${fName}`;
+    expect(await testFS.checkFolderPresence(grParent)).toBe(false);
+    expect(await testFS.checkFolderPresence(parent)).toBe(false);
+    expect(await testFS.checkFolderPresence(path)).toBe(false);
+    const subRoot = await testFS.writableSubRoot(path);
+    expect(subRoot).toBeTruthy();
+    expect(subRoot.writable).toBe(true);
+    expect(!!subRoot.v).toBe(!!testFS.v);
+    const lst = await subRoot.listFolder('');
+    expect(Array.isArray(lst)).toBe(true);
+    expect(await testFS.checkFolderPresence(path)).toBe(true);
+};
+exports.specs.its.push(it);
+it = {
+    expectation: `concurrently created (on the same folder) sub-roots access the same file tree`
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    const subRootFolder = 'sub-root';
+    const promise1 = testFS.writableSubRoot(subRootFolder);
+    const promise2 = testFS.writableSubRoot(subRootFolder);
+    // create file in one fs
+    const fName = 'file 1';
+    const fileContent = `Sub-roots to the same folder should display same thing`;
+    const subRoot1 = await promise1;
+    await subRoot1.writeTxtFile(fName, fileContent);
+    // see that file is present via another fs
+    const subRoot2 = await promise2;
+    expect(await subRoot2.checkFilePresence(fName)).toBe(true);
+    const readContent = await subRoot2.readTxtFile(fName);
+    expect(readContent).toBe(fileContent);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,137 @@
+"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: '.writeBytes',
+    its: []
+};
+let it = { expectation: 'if not allowed to create, fails for missing file' };
+it.func = async function (s) {
+    const { testFS } = s;
+    await testFS.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);
+    await testFS.writeBytes(path, content);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let bytes = await testFS.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(content, bytes)).toBe(true);
+};
+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);
+    await testFS.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 = await testFS.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(content, bytes)).toBe(true);
+};
+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);
+    await testFS.writeBytes(path, initBytes);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    let bytes = await testFS.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(initBytes, bytes)).toBe(true);
+    // write new file content
+    let newContent = (0, random_node_1.bytesSync)(3223);
+    await testFS.writeBytes(path, newContent);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    bytes = await testFS.readBytes(path);
+    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);
+    await testFS.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 = await testFS.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(initBytes, bytes)).withContext('initial file content stays intact').toBe(true);
+};
+exports.specs.its.push(it);
+it = {
+    expectation: 'write big-ish file',
+    timeout: 10 * 1000
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    let path = 'file5';
+    // write some bytes
+    let bytesToWrite = (0, random_node_1.bytesSync)(3000000);
+    await testFS.writeBytes(path, bytesToWrite);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    // check that same bytes are read
+    let readBytes = await testFS.readBytes(path);
+    expect((0, bytes_equal_1.bytesEqual)(bytesToWrite, readBytes)).toBe(true);
+};
+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-4kb', kb4],
+        ['file-16kb', 4 * kb4],
+        ['file-20kb', 5 * kb4],
+    ]) {
+        const content = (0, random_node_1.bytesSync)(contentLen);
+        await testFS.writeBytes(fName, content);
+        expect((0, bytes_equal_1.bytesEqual)((await testFS.readBytes(fName)), content)).toBeTrue();
+    }
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

@@ -0,0 +1,101 @@
+"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: '.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.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 json = { a: 1, b: 2 };
+    expect(await testFS.checkFilePresence(path)).toBe(false);
+    await testFS.writeJSONFile(path, json);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect((0, json_equal_1.deepEqual)(json, await testFS.readJSONFile(path))).toBe(true);
+};
+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 json = { a: 'foo', b: true, 'df-df': 23 };
+    await testFS.writeJSONFile(path, json);
+    expect(await testFS.checkFolderPresence(grParent)).toBe(true);
+    expect(await testFS.checkFolderPresence(parent2)).toBe(true);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect((0, json_equal_1.deepEqual)(json, await testFS.readJSONFile(path))).toBe(true);
+};
+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 };
+    await testFS.writeJSONFile(path, initJson);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect((0, json_equal_1.deepEqual)(initJson, await testFS.readJSONFile(path))).toBe(true);
+    // write new file content
+    let newJson = null;
+    await testFS.writeJSONFile(path, newJson);
+    expect(await testFS.checkFilePresence(path)).toBe(true);
+    expect((0, json_equal_1.deepEqual)(newJson, await testFS.readJSONFile(path))).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 initJson = { a: 'foo', b: true, 'df-df': 23 };
+    await testFS.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);
+    });
+    expect((0, json_equal_1.deepEqual)(initJson, await testFS.readJSONFile(path))).withContext('initial file content stays intact').toBe(true);
+};
+exports.specs.its.push(it);
+Object.freeze(exports);

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

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