pwd-fs 3.1.3 → 3.2.0

package/lib/{recurse-io.js → src/recurse-io.js}

@@ -1,24 +1,25 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var fs = require('node:fs');
-var path = require('node:path');
-
-const { sep } = path;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mkdir = exports.remove = exports.copy = exports.chown = exports.chmod = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const { sep } = node_path_1.default;
 function chmod(src, mode, callback) {
     let reduce = 0;
-    fs.stat(src, (err, stat) => {
+    node_fs_1.default.stat(src, (err, stats) => {
         if (err) {
             return callback(err);
         }
-        if (stat.isDirectory()) {
-            fs.readdir(src, (err, list) => {
+        if (stats.isDirectory()) {
+            node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
                     return callback(err);
                 }
                 if (list.length === 0) {
-                    return fs.chmod(src, mode, callback);
+                    return node_fs_1.default.chmod(src, mode, callback);
                 }
                 reduce += list.length;
                 for (const loc of list) {
@@ -27,30 +28,37 @@ function chmod(src, mode, callback) {
                             return callback(err);
                         }
                         if (--reduce === 0) {
-                            fs.chmod(src, mode, callback);
+                            node_fs_1.default.chmod(src, mode, callback);
                         }
                     });
                 }
             });
         }
         else {
-            fs.chmod(src, mode, callback);
+            node_fs_1.default.chmod(src, mode, callback);
         }
     });
 }
+exports.chmod = chmod;
 function chown(src, uid, gid, callback) {
     let reduce = 0;
-    fs.stat(src, (err, stats) => {
+    node_fs_1.default.stat(src, (err, stats) => {
         if (err) {
             return callback(err);
         }
+        if (uid === 0) {
+            uid = stats.uid;
+        }
+        if (gid === 0) {
+            gid = stats.gid;
+        }
         if (stats.isDirectory()) {
-            fs.readdir(src, (err, list) => {
+            node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
                     return callback(err);
                 }
                 if (list.length === 0) {
-                    return fs.chown(src, uid, gid, callback);
+                    return node_fs_1.default.chown(src, uid, gid, callback);
                 }
                 reduce += list.length;
                 for (const loc of list) {
@@ -59,25 +67,26 @@ function chown(src, uid, gid, callback) {
                             return callback(err);
                         }
                         if (--reduce === 0) {
-                            fs.chown(src, uid, gid, callback);
+                            node_fs_1.default.chown(src, uid, gid, callback);
                         }
                     });
                 }
             });
         }
         else {
-            fs.chown(src, uid, gid, callback);
+            node_fs_1.default.chown(src, uid, gid, callback);
         }
     });
 }
+exports.chown = chown;
 function copy(src, dir, umask, callback) {
     let reduce = 0;
-    fs.stat(src, (err, stat) => {
+    node_fs_1.default.stat(src, (err, stat) => {
         if (err) {
             return callback(err);
         }
         if (stat.isDirectory()) {
-            fs.readdir(src, (err, list) => {
+            node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
                     return callback(err);
                 }
@@ -86,7 +95,7 @@ function copy(src, dir, umask, callback) {
                 const loc = paths[paths.length - 1];
                 const mode = 0o777 - umask;
                 dir = `${dir}${sep}${loc}`;
-                fs.mkdir(dir, { mode }, (err) => {
+                node_fs_1.default.mkdir(dir, { mode }, (err) => {
                     if (err) {
                         return callback(err);
                     }
@@ -108,9 +117,9 @@ function copy(src, dir, umask, callback) {
         }
         else {
             const mode = 0o666 - umask;
-            const loc = path.basename(src);
-            const readStream = fs.createReadStream(src);
-            const writeStream = fs.createWriteStream(`${dir}${sep}${loc}`, {
+            const loc = node_path_1.default.basename(src);
+            const readStream = node_fs_1.default.createReadStream(src);
+            const writeStream = node_fs_1.default.createWriteStream(`${dir}${sep}${loc}`, {
                 mode
             });
             readStream.on('error', callback);
@@ -122,19 +131,20 @@ function copy(src, dir, umask, callback) {
         }
     });
 }
+exports.copy = copy;
 function remove(src, callback) {
-    fs.stat(src, (err, stat) => {
+    node_fs_1.default.stat(src, (err, stat) => {
         if (err) {
             return callback(err);
         }
         if (stat.isDirectory()) {
-            fs.readdir(src, (err, list) => {
+            node_fs_1.default.readdir(src, (err, list) => {
                 if (err) {
                     return callback(err);
                 }
                 let reduce = list.length;
                 if (reduce === 0) {
-                    return fs.rmdir(src, callback);
+                    return node_fs_1.default.rmdir(src, callback);
                 }
                 for (const loc of list) {
                     remove(`${src}${sep}${loc}`, (err) => {
@@ -142,17 +152,18 @@ function remove(src, callback) {
                             return callback(err);
                         }
                         if (--reduce === 0) {
-                            fs.rmdir(src, callback);
+                            node_fs_1.default.rmdir(src, callback);
                         }
                     });
                 }
             });
         }
         else {
-            fs.unlink(src, callback);
+            node_fs_1.default.unlink(src, callback);
         }
     });
 }
+exports.remove = remove;
 function mkdir(dir, umask, callback) {
     const cwd = process.cwd();
     if (dir === cwd) {
@@ -162,7 +173,7 @@ function mkdir(dir, umask, callback) {
         const iter = yield;
         for (const item of files) {
             dir += `${sep}${item}`;
-            fs.mkdir(dir, { mode }, (err) => {
+            node_fs_1.default.mkdir(dir, { mode }, (err) => {
                 if (err && err.errno !== -17) {
                     return callback(err);
                 }
@@ -175,7 +186,7 @@ function mkdir(dir, umask, callback) {
     let use = '';
     if (dir.indexOf(cwd) === 0) {
         use = cwd;
-        dir = dir.substr(cwd.length);
+        dir = dir.substring(cwd.length);
     }
     const files = dir.split(sep);
     const mode = 0o777 - umask;
@@ -183,12 +194,4 @@ function mkdir(dir, umask, callback) {
     iter.next();
     iter.next(iter);
 }
-var recurse = {
-    chmod,
-    chown,
-    copy,
-    remove,
-    mkdir
-};
-
-exports.default = recurse;
+exports.mkdir = mkdir;

package/lib/test/__fmock.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restore = exports.fmock = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function fmock(frame) {
+    for (const src of Object.keys(frame)) {
+        const { dir } = node_path_1.default.parse(src);
+        const value = frame[src];
+        node_fs_1.default.mkdirSync(dir, { recursive: true });
+        if (value.type === 'directory') {
+            node_fs_1.default.mkdirSync(src);
+        }
+        if (value.type === 'file') {
+            node_fs_1.default.writeFileSync(src, value.data);
+        }
+        if (value.type === 'symlink') {
+            node_fs_1.default.symlinkSync(value.target, src);
+        }
+    }
+}
+exports.fmock = fmock;
+function restore(tmpDir) {
+    const removeRecursive = (src) => {
+        if (node_fs_1.default.existsSync(src)) {
+            node_fs_1.default.readdirSync(src).forEach((item) => {
+                const curl = `${src}/${item}`;
+                node_fs_1.default.lstatSync(curl).isDirectory()
+                    ? removeRecursive(curl)
+                    : node_fs_1.default.unlinkSync(curl);
+            });
+            node_fs_1.default.rmdirSync(src);
+        }
+    };
+    removeRecursive(tmpDir);
+}
+exports.restore = restore;

package/lib/test/append.spec.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const chance_1 = __importDefault(require("chance"));
+const expect_1 = require("expect");
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
+describe('append(src, data [, options])', () => {
+    const chance = new chance_1.default();
+    beforeEach(() => {
+        (0, __fmock_1.fmock)({
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: 'hoodie'
+            }
+        });
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it('Positive: Must append content to file', async () => {
+        const payload = chance.paragraph();
+        await src_1.pfs.append('./tmpdir/tings.txt', payload);
+        const { size } = node_fs_1.default.statSync('./tmpdir/tings.txt');
+        (0, node_assert_1.default)(payload.length + 6 === size);
+    });
+    it(`Negative: Unexpected option 'flag' returns Error`, async () => {
+        const payload = chance.paragraph();
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.append('./tmpdir/tings.txt', payload, {
+                flag: 'r'
+            });
+        })
+            .rejects
+            .toThrow();
+    });
+    it(`[sync] Positive: Must append content to file`, () => {
+        const payload = chance.paragraph();
+        src_1.pfs.append('./tmpdir/tings.txt', payload, {
+            sync: true
+        });
+        const { size } = node_fs_1.default.statSync('./tmpdir/tings.txt');
+        (0, node_assert_1.default)(payload.length + 6 === size);
+    });
+    it(`[sync] Negative: Unexpected option 'flag' returns Error`, () => {
+        const payload = chance.paragraph();
+        node_assert_1.default.throws(() => {
+            src_1.pfs.append('./tmpdir/tings.txt', payload, {
+                sync: true,
+                flag: 'r'
+            });
+        });
+    });
+});

package/lib/test/bitmask.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const src_1 = require("../src");
+describe('static bitmask(mode: number)', () => {
+    it('Positive: Calculate bitmask', () => {
+        (0, node_assert_1.default)((0, src_1.bitmask)(33024) === 0o400); // (r--------)
+        (0, node_assert_1.default)((0, src_1.bitmask)(33152) === 0o600); // (rw-------)
+        (0, node_assert_1.default)((0, src_1.bitmask)(33216) === 0o700); // (rwx------)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32800) === 0o040); // (---r-----)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32816) === 0o060); // (---rw----)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32824) === 0o070); // (---rwx---)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32772) === 0o004); // (------r--)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32774) === 0o006); // (------rw-)
+        (0, node_assert_1.default)((0, src_1.bitmask)(32775) === 0o007); // (------rwx)
+    });
+    it(`Negative: Throw an exception if the argument is 'null' type`, () => {
+        node_assert_1.default.throws(() => {
+            // @ts-ignore
+            (0, src_1.bitmask)(null);
+        });
+    });
+});

package/lib/test/chmod.spec.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const chance_1 = __importDefault(require("chance"));
+const expect_1 = require("expect");
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
+describe('chmod(src, mode [, options])', () => {
+    const chance = new chance_1.default();
+    beforeEach(() => {
+        (0, __fmock_1.fmock)({
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: chance.string()
+            }
+        });
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it('Positive: Changes directory and file permissions', async () => {
+        await src_1.pfs.chmod('./tmpdir', 0o744);
+        const { mode } = node_fs_1.default.lstatSync('./tmpdir/tings.txt');
+        const umask = (0, src_1.bitmask)(mode);
+        (0, node_assert_1.default)(umask === 0o744);
+    });
+    it('Negative: Throw if not exists resource', async () => {
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.chmod('./non-existent-source', 0o744);
+        })
+            .rejects
+            .toThrow();
+    });
+    it(`[sync] Positive: Changes permissions of directory`, () => {
+        src_1.pfs.chmod('./tmpdir', 0o744, {
+            sync: true
+        });
+        const { mode } = node_fs_1.default.lstatSync('./tmpdir');
+        const umask = (0, src_1.bitmask)(mode);
+        (0, node_assert_1.default)(umask === 0o744);
+    });
+    it(`[sync] Positive: Changes file permissions`, () => {
+        src_1.pfs.chmod('./tmpdir', 0o744, {
+            sync: true
+        });
+        const { mode } = node_fs_1.default.lstatSync('./tmpdir/tings.txt');
+        const umask = (0, src_1.bitmask)(mode);
+        (0, node_assert_1.default)(umask === 0o744);
+    });
+    it('[sync] Negative: Throw if not exists resource', () => {
+        const guid = chance.guid();
+        node_assert_1.default.throws(() => {
+            src_1.pfs.chmod(`./${guid}`, 0o744, {
+                sync: true
+            });
+        });
+    });
+});

package/lib/test/chown.spec.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const chance_1 = __importDefault(require("chance"));
+const expect_1 = require("expect");
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
+describe('chown(src, [, options])', () => {
+    const chance = new chance_1.default();
+    beforeEach(() => {
+        (0, __fmock_1.fmock)({
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: chance.string()
+            },
+            './tmpdir/digest/': { type: 'directory' }
+        });
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it('Positive: Changes the permissions of a file', async () => {
+        const { uid, gid } = node_fs_1.default.statSync('./tmpdir/tings.txt');
+        await src_1.pfs.chown('./tmpdir/tings.txt', { uid, gid });
+        (0, node_assert_1.default)(uid && gid);
+    });
+    it('Positive: Changes the permissions of a directory', async () => {
+        const { uid, gid } = node_fs_1.default.statSync('./tmpdir/digest');
+        await src_1.pfs.chown('./tmpdir/digest', { uid, gid });
+        (0, node_assert_1.default)(uid && gid);
+    });
+    it('Negative: To a non-existent resource to return an Error', async () => {
+        const guid = chance.guid();
+        const { uid, gid } = node_fs_1.default.statSync('./tmpdir/tings.txt');
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.chown(`./tmpdir/${guid}`, { uid, gid });
+        })
+            .rejects
+            .toThrow();
+    });
+    it('[sync] Positive: Changes the permissions of a file', () => {
+        const { uid, gid } = node_fs_1.default.statSync('./tmpdir/tings.txt');
+        src_1.pfs.chown('./tmpdir/tings.txt', {
+            sync: true,
+            uid,
+            gid
+        });
+        (0, node_assert_1.default)(uid && gid);
+    });
+    it('[sync] Positive: Changes the permissions of a directory', () => {
+        const { uid, gid } = node_fs_1.default.statSync('./tmpdir/digest');
+        src_1.pfs.chown('./tmpdir/digest', {
+            sync: true,
+            uid,
+            gid
+        });
+        (0, node_assert_1.default)(uid && gid);
+    });
+    it('[sync] Negative: To a non-existent resource to return an Error', () => {
+        const guid = chance.guid();
+        const { uid, gid } = node_fs_1.default.statSync('./tmpdir/tings.txt');
+        node_assert_1.default.throws(() => {
+            src_1.pfs.chown(`./tmpdir/${guid}`, {
+                sync: true,
+                uid,
+                gid
+            });
+        });
+    });
+});

package/lib/test/constructor.spec.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const src_1 = require("../src");
+describe('#constructor: new PoweredFileSystem(pwd?)', () => {
+    it('Positive: An empty path must match the context of the cwd', () => {
+        const { pwd } = new src_1.PoweredFileSystem();
+        (0, node_assert_1.default)(pwd === process.cwd());
+    });
+    it('Positive: Absolute path must match the context of the pwd', () => {
+        const { pwd } = new src_1.PoweredFileSystem(__dirname);
+        (0, node_assert_1.default)(pwd === __dirname);
+    });
+});

package/lib/test/copy.spec.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const chance_1 = __importDefault(require("chance"));
+const expect_1 = require("expect");
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
+describe('copy(src, dir [, options])', () => {
+    const chance = new chance_1.default();
+    beforeEach(() => {
+        (0, __fmock_1.fmock)({
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: chance.string()
+            },
+            './tmpdir/digest/': { type: 'directory' }
+        });
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it('Positive: Copying a item file', async () => {
+        await src_1.pfs.copy('./tmpdir/tings.txt', './tmpdir/digest');
+        const exist = node_fs_1.default.existsSync(`./tmpdir/digest/tings.txt`);
+        (0, node_assert_1.default)(exist);
+    });
+    it('Positive: Recursive copying a directory', async () => {
+        await src_1.pfs.copy('./src', './tmpdir');
+        const exist = node_fs_1.default.existsSync(`./tmpdir/src`);
+        (0, node_assert_1.default)(exist);
+    });
+    it('Negative: Throw if not exists resource', async () => {
+        const guid = chance.guid();
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.copy(`./${guid}`, '.');
+        })
+            .rejects
+            .toThrow();
+    });
+    it('Negative: An attempt to copy to an existing resource should return an Error', async () => {
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.copy('./tmpdir', '.');
+        })
+            .rejects
+            .toThrow();
+    });
+    it('[sync] Positive: Copying a file', () => {
+        src_1.pfs.copy('./tmpdir/tings.txt', './tmpdir/digest', {
+            sync: true
+        });
+        const exist = node_fs_1.default.existsSync(`./tmpdir/digest/tings.txt`);
+        (0, node_assert_1.default)(exist);
+    });
+    it('[sync] Positive: Recursive copying a directory', () => {
+        src_1.pfs.copy('./src', './tmpdir', {
+            sync: true
+        });
+        const exist = node_fs_1.default.existsSync(`./tmpdir/src`);
+        (0, node_assert_1.default)(exist);
+    });
+    it('[sync] Negative: Throw if not exists resource', () => {
+        const guid = chance.guid();
+        node_assert_1.default.throws(() => {
+            src_1.pfs.copy(`./${guid}`, '.', {
+                sync: true
+            });
+        });
+    });
+    it('[sync] Negative: An attempt to copy to an existing resource should return an Error', () => {
+        node_assert_1.default.throws(() => {
+            src_1.pfs.copy('./tmpdir', '.', {
+                sync: true
+            });
+        });
+    });
+});

package/lib/test/mkdir.spec.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const chance_1 = __importDefault(require("chance"));
+const expect_1 = require("expect");
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
+describe('mkdir(src [, options])', () => {
+    const pfs = new src_1.PoweredFileSystem();
+    const chance = new chance_1.default();
+    beforeEach(() => {
+        (0, __fmock_1.fmock)({
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: chance.string()
+            }
+        });
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it('Positive: Create directories in the working directory', async () => {
+        const guid = chance.guid();
+        await pfs.mkdir(`./tmpdir/${guid}`);
+        const exist = node_fs_1.default.existsSync(`./tmpdir/${guid}`);
+        (0, node_assert_1.default)(exist);
+    });
+    it(`Positive: Make current directory`, async () => {
+        const guid = chance.guid();
+        const pfs = new src_1.PoweredFileSystem(`./tmpdir/${guid}`);
+        await pfs.mkdir('.');
+        const exist = node_fs_1.default.existsSync(`./tmpdir/${guid}`);
+        (0, node_assert_1.default)(exist);
+    });
+    it('Positive: Should work fine with the existing directory', async () => {
+        const guid = chance.guid();
+        for (let i = 2; i; i--) {
+            await pfs.mkdir(`./tmpdir/${guid}`);
+        }
+        const exist = node_fs_1.default.existsSync(`./tmpdir/${guid}`);
+        (0, node_assert_1.default)(exist);
+    });
+    it('Negative: Throw an exception if trying to create a directory in file', async () => {
+        const guid = chance.guid();
+        await (0, expect_1.expect)(async () => {
+            await pfs.mkdir(`./tmpdir/tings.txt/${guid}`);
+        })
+            .rejects
+            .toThrow();
+    });
+    it('Positive: Create directories in the working directory', () => {
+        const guid = chance.guid();
+        pfs.mkdir(`./tmpdir/${guid}`, {
+            sync: true
+        });
+        const exist = node_fs_1.default.existsSync(`./tmpdir/${guid}`);
+        (0, node_assert_1.default)(exist);
+    });
+    it('[sync] Positive: Make current directory', () => {
+        const guid = chance.guid();
+        const pfs = new src_1.PoweredFileSystem(`./tmpdir/${guid}`);
+        pfs.mkdir('.', {
+            sync: true
+        });
+        const exist = node_fs_1.default.existsSync(`./tmpdir/${guid}`);
+        (0, node_assert_1.default)(exist);
+    });
+    it('[sync] Positive: Should work fine with the existing directory', () => {
+        const guid = chance.guid();
+        for (let i = 2; i; i--) {
+            pfs.mkdir(`./tmpdir/${guid}`, {
+                sync: true
+            });
+        }
+        const exist = node_fs_1.default.existsSync(`./tmpdir/${guid}`);
+        (0, node_assert_1.default)(exist);
+    });
+    it('[sync] Negative: Throw an exception if trying to create a directory in file', () => {
+        const guid = chance.guid();
+        node_assert_1.default.throws(() => {
+            pfs.mkdir(`./tmpdir/tings.txt/${guid}`, {
+                sync: true
+            });
+        });
+    });
+});