pwd-fs 3.1.3 → 3.1.4

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,68 @@
+"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, uid, gid [, 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', uid, gid, {
+            sync: true
+        });
+        (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', uid, gid, {
+            sync: true
+        });
+        (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}`, uid, gid, {
+                sync: true
+            });
+        });
+    });
+});

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
+            });
+        });
+    });
+});

package/lib/test/read.spec.js

@@ -0,0 +1,73 @@
+"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 chance_1 = __importDefault(require("chance"));
+const expect_1 = require("expect");
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
+describe('read(src [, options])', () => {
+    const chance = new chance_1.default();
+    let sentences = 0;
+    beforeEach(() => {
+        const tingsContent = chance.paragraph();
+        sentences = tingsContent.length;
+        (0, __fmock_1.fmock)({
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: tingsContent
+            }
+        });
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it('Positive: Must read content of file; String type by default', async () => {
+        const { length } = await src_1.pfs.read('./tmpdir/tings.txt');
+        (0, node_assert_1.default)(length === sentences);
+    });
+    it('Positive: Must read Buffer content of file when encoding is null', async () => {
+        const buffer = await src_1.pfs.read('./tmpdir/tings.txt', {
+            encoding: null
+        });
+        (0, node_assert_1.default)(buffer instanceof Buffer);
+    });
+    it('Negative: Throw if resource is not file', async () => {
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.read(`./tmpdir`);
+        })
+            .rejects
+            .toThrow();
+    });
+    it('Negative: Throw if not exists resource', async () => {
+        const guid = chance.guid();
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.read(`./tmpdir/${guid}`);
+        })
+            .rejects
+            .toThrow();
+    });
+    it('[sync] Positive: Must read content of file; String type by default', () => {
+        const { length } = src_1.pfs.read('./tmpdir/tings.txt', {
+            sync: true
+        });
+        (0, node_assert_1.default)(length === sentences);
+    });
+    it('[sync] Positive: Must read Buffer content of file when encoding is null', () => {
+        const buffer = src_1.pfs.read('./tmpdir/tings.txt', {
+            encoding: null,
+            sync: true
+        });
+        (0, node_assert_1.default)(buffer instanceof Buffer);
+    });
+    it(`[sync] Negative: Throw if not exists resource`, () => {
+        const guid = chance.guid();
+        node_assert_1.default.throws(() => {
+            src_1.pfs.read(`./tmpdir/${guid}`, {
+                sync: true
+            });
+        });
+    });
+});

package/lib/test/readdir.spec.js

@@ -0,0 +1,70 @@
+"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 chance_1 = __importDefault(require("chance"));
+const expect_1 = require("expect");
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
+describe('readdir(src[, options])', () => {
+    const chance = new chance_1.default();
+    let counter = 0;
+    beforeEach(() => {
+        const frame = {
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: chance.string()
+            }
+        };
+        counter = chance.natural({ max: 7 });
+        for (let i = 0; i < counter; i++) {
+            frame[`./tmpdir/${i}`] = { type: 'directory' };
+        }
+        (0, __fmock_1.fmock)(frame);
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it('Positive: Must return a directory listing', async () => {
+        const { length } = await src_1.pfs.readdir('./tmpdir');
+        (0, node_assert_1.default)(counter + 1 === length);
+    });
+    it('Negative: Throw if resource is not directory', async () => {
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.readdir(`./tmpdir/tings.txt`);
+        })
+            .rejects
+            .toThrow();
+    });
+    it('Negative: Throw if not exists resource', async () => {
+        const guid = chance.guid();
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.readdir(`./tmpdir/${guid}`);
+        })
+            .rejects
+            .toThrow();
+    });
+    it('[sync] Positive: Must return a directory listing', () => {
+        const { length } = src_1.pfs.readdir('./tmpdir', {
+            sync: true
+        });
+        (0, node_assert_1.default)(counter + 1 === length);
+    });
+    it('Negative: Throw if resource is not directory', () => {
+        node_assert_1.default.throws(() => {
+            src_1.pfs.readdir(`./tmpdir/tings.txt`, {
+                sync: true
+            });
+        });
+    });
+    it(`Negative: Throw if not exists resource`, () => {
+        const guid = chance.guid();
+        node_assert_1.default.throws(() => {
+            src_1.pfs.readdir(`./tmpdir/${guid}`, {
+                sync: true
+            });
+        });
+    });
+});

package/lib/test/remove.spec.js

@@ -0,0 +1,63 @@
+"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('remove(src [, options])', () => {
+    const chance = new chance_1.default();
+    beforeEach(() => {
+        const cwd = process.cwd();
+        const frame = {
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: chance.string()
+            },
+            './tmpdir/flexapp': {
+                type: 'symlink',
+                target: `${cwd}/tmpdir/tings.txt`
+            }
+        };
+        const counter = chance.natural({ max: 7 });
+        for (let i = 0; i < counter; i++) {
+            frame[`./tmpdir/${i}`] = { type: 'directory' };
+        }
+        (0, __fmock_1.fmock)(frame);
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it('Positive: Removal a directory with a file', async () => {
+        await src_1.pfs.remove('./tmpdir');
+        const exist = node_fs_1.default.existsSync(`./tmpdir`);
+        (0, node_assert_1.default)(exist === false);
+    });
+    it('Negative: Throw if not exists resource', async () => {
+        const guid = chance.guid();
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.remove(`./${guid}`);
+        })
+            .rejects
+            .toThrow();
+    });
+    it('[sync] Positive: Removal a directory with a file', () => {
+        src_1.pfs.remove('./tmpdir', {
+            sync: true
+        });
+        const exist = node_fs_1.default.existsSync(`./tmpdir`);
+        (0, node_assert_1.default)(exist === false);
+    });
+    it('[sync] Negative: Throw if not exists resource', () => {
+        const guid = chance.guid();
+        node_assert_1.default.throws(() => {
+            src_1.pfs.remove(`./tmpdir/${guid}`, {
+                sync: true
+            });
+        });
+    });
+});

package/lib/test/rename.spec.js

@@ -0,0 +1,66 @@
+"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('rename(src, use [, 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: Must be recursive rename file', async () => {
+        await src_1.pfs.rename('./tmpdir/tings.txt', './tmpdir/newapp.txt');
+        const exist = node_fs_1.default.existsSync(`./tmpdir/newapp.txt`);
+        (0, node_assert_1.default)(exist);
+    });
+    it('Positive: Must be recursive rename directory', async () => {
+        await src_1.pfs.rename('./tmpdir/digest', './tmpdir/newxbase');
+        const exist = node_fs_1.default.existsSync(`./tmpdir/newxbase`);
+        (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.rename(`./tmpdir/${guid}`, './tmpdir/newxbase');
+        })
+            .rejects
+            .toThrow();
+    });
+    it('[sync] Positive: Must be recursive rename file', () => {
+        src_1.pfs.rename('./tmpdir/tings.txt', './tmpdir/newapp.txt', {
+            sync: true
+        });
+        const exist = node_fs_1.default.existsSync(`./tmpdir/newapp.txt`);
+        (0, node_assert_1.default)(exist);
+    });
+    it('[sync] Positive: Must be recursive rename directory', () => {
+        src_1.pfs.rename('./tmpdir/digest', './tmpdir/newxbase', {
+            sync: true
+        });
+        const exist = node_fs_1.default.existsSync(`./tmpdir/newxbase`);
+        (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.rename(`./tmpdir/${guid}`, './tmpdir/newxbase', {
+                sync: true
+            });
+        });
+    });
+});