pwd-fs 2.4.1 → 3.1.3

package/.travis.yml

@@ -1,10 +1,9 @@
 language: node_js
 node_js:
-  - 8
-  - 10
-  - 12
   - 14
   - 16
+  - 18
+  - 20
 install:
   - yarn
   - yarn global add nyc coveralls

package/__tests__/__fmock.ts

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export interface Iframe {
+  [key: string]: any
+}
+
+export function fmock(frame: Iframe) {  
+  for (const src of Object.keys(frame)) {
+    const { dir } = path.parse(src);
+    const value = frame[src];
+
+    fs.mkdirSync(dir, { recursive: true });
+    
+    if (value.type === 'directory') {
+      fs.mkdirSync(src);
+    }
+    
+    if (value.type === 'file') {
+      fs.writeFileSync(src, value.data);
+    }
+    
+    if (value.type === 'symlink') {
+      fs.symlinkSync(value.target, src);
+    }
+  }
+}
+
+export function restore(tmpDir: string) {
+  const removeRecursive = (src: string) => {
+    if (fs.existsSync(src)) {
+      fs.readdirSync(src).forEach((item) => {
+        const curl = `${src}/${item}`;
+
+        fs.lstatSync(curl).isDirectory()
+          ? removeRecursive(curl)
+          : fs.unlinkSync(curl);
+      });
+
+      fs.rmdirSync(src);
+    }
+  };
+
+  removeRecursive(tmpDir);
+}

package/__tests__/append.spec.ts

@@ -0,0 +1,72 @@
+import assert from 'node:assert';
+import { sep } from 'node:path';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { fmock, restore } from './__fmock';
+import PoweredFileSystem from '../src';
+
+describe('append(src, data [, options])', () => {
+  const pfs = new PoweredFileSystem();
+  const chance = new Chance();
+
+  beforeEach(() => {
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: 'hoodie'
+      }
+    });
+  });
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
+
+
+  it('Positive: Must append content to file', async () => {
+    const payload = chance.paragraph();
+
+    await pfs.append('./tmpdir/tings.txt', payload);
+    const { size } = fs.statSync('./tmpdir/tings.txt');
+
+    assert(payload.length + 6 === size);
+  });
+
+
+  it(`Negative: Unexpected option 'flag' returns Error`, async () => {
+    const payload = chance.paragraph();
+    
+    await expect(async () => {
+      await pfs.append('./tmpdir/tings.txt', payload, {
+        flag: 'r'
+      });
+    })
+    .rejects
+    .toThrow();
+  });
+  
+  
+  it(`[sync] Positive: Must append content to file`, () => {
+    const payload = chance.paragraph();
+
+    pfs.append('./tmpdir/tings.txt', payload, {
+      sync: true
+    });
+
+    const { size } = fs.statSync('./tmpdir/tings.txt');
+
+    assert(payload.length + 6 === size);
+  });
+  
+  
+  it(`[sync] Negative: Unexpected option 'flag' returns Error`, () => {
+    const payload = chance.paragraph();
+    
+    assert.throws(() => {
+      pfs.append('./tmpdir/tings.txt', payload, {
+        sync: true,
+        flag: 'r'
+      });
+    });
+  });
+});

package/__tests__/bitmask.spec.ts

@@ -0,0 +1,23 @@
+import assert from 'node:assert';
+import { bitmask } from '../src';
+
+describe('static bitmask(mode: number)', () => {
+  it('Positive: Calculate bitmask', () => {
+    assert(bitmask(33024) === 0o400); // (r--------)
+    assert(bitmask(33152) === 0o600); // (rw-------)
+    assert(bitmask(33216) === 0o700); // (rwx------)
+    assert(bitmask(32800) === 0o040); // (---r-----)
+    assert(bitmask(32816) === 0o060); // (---rw----)
+    assert(bitmask(32824) === 0o070); // (---rwx---)
+    assert(bitmask(32772) === 0o004); // (------r--)
+    assert(bitmask(32774) === 0o006); // (------rw-)
+    assert(bitmask(32775) === 0o007); // (------rwx)
+  });
+
+  it(`Negative: Throw an exception if the argument is 'null' type`, () => {
+    assert.throws(() => {
+      // @ts-ignore
+      bitmask(null);
+    });
+  });
+});

package/__tests__/chmod.spec.ts

@@ -0,0 +1,78 @@
+import assert from 'node:assert';
+import { sep } from 'node:path';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { fmock, restore } from './__fmock';
+import PoweredFileSystem, { bitmask } from '../src';
+
+describe('chmod(src, mode [, options])', () => {
+  const pfs = new PoweredFileSystem();
+  const chance = new Chance();
+
+  beforeEach(() => {
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: chance.string()
+      }
+    });
+  });
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
+
+
+  it('Positive: Changes directory and file permissions', async () => {
+    await pfs.chmod('./tmpdir', 0o744);
+
+    const { mode } = fs.lstatSync('./tmpdir/tings.txt');
+    const umask = bitmask(mode);
+
+    assert(umask === 0o744);
+  });
+
+
+  it('Negative: Throw if not exists resource', async () => {
+    await expect(async () => {
+      await pfs.chmod('./non-existent-source', 0o744);
+    })
+    .rejects
+    .toThrow();
+  });
+  
+  
+  it(`[sync] Positive: Changes permissions of directory`, () => {
+    pfs.chmod('./tmpdir', 0o744, {
+      sync: true
+    });
+
+    const { mode } = fs.lstatSync('./tmpdir');
+    const umask = bitmask(mode);
+
+    assert(umask === 0o744);
+  });
+
+
+  it(`[sync] Positive: Changes file permissions`, () => {
+    pfs.chmod('./tmpdir', 0o744, {
+      sync: true
+    });
+
+    const { mode } = fs.lstatSync('./tmpdir/tings.txt');
+    const umask = bitmask(mode);
+
+    assert(umask === 0o744);
+  });
+  
+  
+  it('[sync] Negative: Throw if not exists resource', () => {
+    const guid = chance.guid();
+
+    assert.throws(() => {
+      pfs.chmod(`./${guid}`, 0o744, {
+        sync: true
+      });
+    });
+  });
+});

package/__tests__/chown.spec.ts

@@ -0,0 +1,88 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { fmock, restore } from './__fmock';
+import PoweredFileSystem from '../src';
+
+describe('chown(src, uid, gid [, options])', () => {
+  const pfs = new PoweredFileSystem();
+  const chance = new Chance();
+
+  beforeEach(() => {
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: chance.string()
+      },
+      './tmpdir/digest/': { type: 'directory' }
+    });
+  });
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
+  
+  
+  it('Positive: Changes the permissions of a file', async () => {
+    const { uid, gid } = fs.statSync('./tmpdir/tings.txt');
+    
+    await pfs.chown('./tmpdir/tings.txt', uid, gid);
+
+    assert(uid && gid);
+  });
+  
+  
+  it('Positive: Changes the permissions of a directory', async () => {
+    const { uid, gid } = fs.statSync('./tmpdir/digest');
+
+    await pfs.chown('./tmpdir/digest', uid, gid);
+
+    assert(uid && gid);
+  });
+  
+  
+  it('Negative: To a non-existent resource to return an Error', async () => {
+    const guid = chance.guid();
+    const { uid, gid } = fs.statSync('./tmpdir/tings.txt');
+    
+    await expect(async () => {
+      await pfs.chown(`./tmpdir/${guid}`, uid, gid);
+    })
+    .rejects
+    .toThrow();
+  });
+  
+  
+  it('[sync] Positive: Changes the permissions of a file', () => {
+    const { uid, gid } = fs.statSync('./tmpdir/tings.txt');
+
+    pfs.chown('./tmpdir/tings.txt', uid, gid, {
+      sync: true
+    });
+
+    assert(uid && gid);
+  });
+  
+  
+  it('[sync] Positive: Changes the permissions of a directory', () => {
+    const { uid, gid } = fs.statSync('./tmpdir/digest');
+
+    pfs.chown('./tmpdir/digest', uid, gid, {
+      sync: true
+    });
+
+    assert(uid && gid);
+  });
+  
+  
+  it('[sync] Negative: To a non-existent resource to return an Error', () => {
+    const guid = chance.guid();
+    const { uid, gid } = fs.statSync('./tmpdir/tings.txt');
+    
+    assert.throws(() => {
+      pfs.chown(`./tmpdir/${guid}`, uid, gid, {
+        sync: true
+      });
+    });
+  });
+});

package/{test → __tests__}/constructor.spec.ts

@@ -1,16 +1,13 @@
-import assert from 'assert';
+import assert from 'node:assert';
 import PoweredFileSystem from '../src';
 
-describe('#constructor: new PoweredFileSystem(path)', () => {
-  it('Positive: Must be backwards compatible with #require', () => {
-    assert(require('../src') === PoweredFileSystem);
-  });
-
+describe('#constructor: new PoweredFileSystem(pwd?)', () => {
   it('Positive: An empty path must match the context of the cwd', () => {
     const { pwd } = new PoweredFileSystem();
     assert(pwd === process.cwd());
   });
 
+
   it('Positive: Absolute path must match the context of the pwd', () => {
     const { pwd } = new PoweredFileSystem(__dirname);
     assert(pwd === __dirname);

package/__tests__/copy.spec.ts

@@ -0,0 +1,102 @@
+import assert from 'node:assert';
+import { sep } from 'node:path';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { fmock, restore } from './__fmock';
+import PoweredFileSystem, { bitmask } from '../src';
+
+describe('copy(src, dir [, options])', () => {
+  const pfs = new PoweredFileSystem();
+  const chance = new Chance();
+  
+  beforeEach(() => {
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: chance.string()
+      },
+      './tmpdir/digest/': { type: 'directory' }
+    });
+  });
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
+
+  it('Positive: Copying a item file', async () => {
+    await pfs.copy('./tmpdir/tings.txt', './tmpdir/digest');
+    const exist = fs.existsSync(`./tmpdir/digest/tings.txt`);
+    
+    assert(exist);
+  });
+  
+
+  it('Positive: Recursive copying a directory', async () => {
+    await pfs.copy('./src', './tmpdir');
+    const exist = fs.existsSync(`./tmpdir/src`);
+    
+    assert(exist);
+  });
+
+  
+  it('Negative: Throw if not exists resource', async () => {
+    const guid = chance.guid();
+    
+    await expect(async () => {
+      await pfs.copy(`./${guid}`, '.');
+    })
+    .rejects
+    .toThrow();
+  });
+  
+  
+  it('Negative: An attempt to copy to an existing resource should return an Error', async () => {
+    await expect(async () => {
+      await pfs.copy('./tmpdir', '.');
+    })
+    .rejects
+    .toThrow();
+  });
+  
+  
+  it('[sync] Positive: Copying a file', () => {
+    pfs.copy('./tmpdir/tings.txt', './tmpdir/digest', {
+      sync: true
+    });
+
+    const exist = fs.existsSync(`./tmpdir/digest/tings.txt`);
+    
+    assert(exist);
+  });
+  
+  
+  it('[sync] Positive: Recursive copying a directory', () => {
+    pfs.copy('./src', './tmpdir', {
+      sync: true
+    });
+
+    const exist = fs.existsSync(`./tmpdir/src`);
+    
+    assert(exist);
+  });
+  
+  
+  it('[sync] Negative: Throw if not exists resource', () => {
+    const guid = chance.guid();
+
+    assert.throws(() => {
+      pfs.copy(`./${guid}`, '.', {
+        sync: true
+      });
+    });
+  });
+  
+  
+  it('[sync] Negative: An attempt to copy to an existing resource should return an Error', () => {
+    assert.throws(() => {
+      pfs.copy('./tmpdir', '.', {
+        sync: true
+      });
+    });
+  });
+});

package/__tests__/mkdir.spec.ts

@@ -0,0 +1,120 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { fmock, restore } from './__fmock';
+import PoweredFileSystem from '../src';
+
+describe('mkdir(src [, options])', () => {
+  const pfs = new PoweredFileSystem();
+  const chance = new Chance();
+
+  beforeEach(() => {
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: chance.string()
+      }
+    });
+  });
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
+
+  it('Positive: Create directories in the working directory', async () => {
+    const guid = chance.guid();
+    
+    await pfs.mkdir(`./tmpdir/${guid}`);
+    const exist = fs.existsSync(`./tmpdir/${guid}`);
+    
+    assert(exist);
+  });
+  
+  
+  it(`Positive: Make current directory`, async () => {
+    const guid = chance.guid();
+    const pfs = new PoweredFileSystem(`./tmpdir/${guid}`);
+
+    await pfs.mkdir('.');
+    const exist = fs.existsSync(`./tmpdir/${guid}`);
+    
+    assert(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 = fs.existsSync(`./tmpdir/${guid}`);
+      
+    assert(exist);
+  });
+  
+  
+  it('Negative: Throw an exception if trying to create a directory in file', async () => {
+    const guid = chance.guid();    
+    
+    await 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 = fs.existsSync(`./tmpdir/${guid}`);
+    
+    assert(exist);
+  });
+  
+  
+  it('[sync] Positive: Make current directory', () => {
+    const guid = chance.guid();
+    const pfs = new PoweredFileSystem(`./tmpdir/${guid}`);
+
+    pfs.mkdir('.', {
+      sync: true
+    });
+
+    const exist = fs.existsSync(`./tmpdir/${guid}`);
+    
+    assert(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 = fs.existsSync(`./tmpdir/${guid}`);
+    
+    assert(exist);
+  });
+  
+  
+  it('[sync] Negative: Throw an exception if trying to create a directory in file', () => {
+    const guid = chance.guid();
+    
+    assert.throws(() => {
+      pfs.mkdir(`./tmpdir/tings.txt/${guid}`, {
+        sync: true
+      });
+    });
+  });
+});

package/__tests__/read.spec.ts

@@ -0,0 +1,92 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { fmock, restore } from './__fmock';
+import PoweredFileSystem from '../src';
+
+describe('read(src [, options])', () => {
+  const pfs = new PoweredFileSystem();
+  const chance = new Chance();
+  let sentences = 0;
+
+  beforeEach(() => {
+    const tingsContent = chance.paragraph();
+    sentences = tingsContent.length;
+    
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: tingsContent
+      }
+    });
+  });
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
+  
+  it('Positive: Must read content of file; String type by default', async () => {
+    const { length } = await pfs.read('./tmpdir/tings.txt');
+
+    assert(length === sentences);
+  });
+  
+  
+  it('Positive: Must read Buffer content of file when encoding is null', async () => {
+    const buffer = await pfs.read('./tmpdir/tings.txt', {
+      encoding: null
+    });
+
+    assert(buffer instanceof Buffer);
+  });
+  
+  
+  it('Negative: Throw if resource is not file', async () => {
+    await expect(async () => {
+      await pfs.read(`./tmpdir`);
+    })
+    .rejects
+    .toThrow();
+  });
+  
+  
+  it('Negative: Throw if not exists resource', async () => {
+    const guid = chance.guid();
+
+    await expect(async () => {
+      await pfs.read(`./tmpdir/${guid}`);
+    })
+    .rejects
+    .toThrow();
+  });
+  
+  
+  it('[sync] Positive: Must read content of file; String type by default', () => {
+    const { length } = pfs.read('./tmpdir/tings.txt', {
+      sync: true
+    });
+
+    assert(length === sentences);
+  });
+  
+  
+  it('[sync] Positive: Must read Buffer content of file when encoding is null', () => {
+    const buffer = pfs.read('./tmpdir/tings.txt', {
+      encoding: null,
+      sync: true
+    });
+
+    assert(buffer instanceof Buffer);
+  });
+  
+  
+  it(`[sync] Negative: Throw if not exists resource`, () => {
+    const guid = chance.guid();
+    
+    assert.throws(() => {
+      pfs.read(`./tmpdir/${guid}`, {
+        sync: true
+      });
+    });
+  });
+});