pwd-fs 3.3.0 → 3.3.2

package/test/__fmock.ts

@@ -1,45 +0,0 @@
-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/test/append.spec.ts

@@ -1,45 +0,0 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import Chance  from 'chance';
-import { expect } from 'expect';
-import { fmock, restore } from './__fmock';
-import { pfs } from '../src';
-
-describe('append(src, data [, options])', () => {
-  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(`[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);
-  });
-});

package/test/bitmask.spec.ts

@@ -1,23 +0,0 @@
-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/test/chmod.spec.ts

@@ -1,77 +0,0 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import Chance  from 'chance';
-import { expect } from 'expect';
-import { fmock, restore } from './__fmock';
-import { pfs, bitmask } from '../src';
-
-describe('chmod(src, mode [, options])', () => {
-  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/test/chown.spec.ts

@@ -1,92 +0,0 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import Chance  from 'chance';
-import { expect } from 'expect';
-import { fmock, restore } from './__fmock';
-import { pfs } from '../src';
-
-describe('chown(src, [, options])', () => {
-  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', {
-      sync: true,
-      uid,
-      gid
-    });
-
-    assert(uid && gid);
-  });
-  
-  
-  it('[sync] Positive: Changes the permissions of a directory', () => {
-    const { uid, gid } = fs.statSync('./tmpdir/digest');
-
-    pfs.chown('./tmpdir/digest', {
-      sync: true,
-      uid,
-      gid
-    });
-
-    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}`, {
-        sync: true,
-        uid,
-        gid
-      });
-    });
-  });
-});

package/test/constructor.spec.ts

@@ -1,15 +0,0 @@
-import assert from 'node:assert';
-import { PoweredFileSystem } from '../src';
-
-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/test/copy.spec.ts

@@ -1,101 +0,0 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import Chance  from 'chance';
-import { expect } from 'expect';
-import { fmock, restore } from './__fmock';
-import { pfs } from '../src';
-
-describe('copy(src, dir [, options])', () => {
-  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/test/mkdir.spec.ts

@@ -1,121 +0,0 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import Chance  from 'chance';
-import { expect } from 'expect';
-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/test/read.spec.ts

@@ -1,91 +0,0 @@
-import assert from 'node:assert';
-import Chance  from 'chance';
-import { expect } from 'expect';
-import { fmock, restore } from './__fmock';
-import { pfs } from '../src';
-
-describe('read(src [, options])', () => {
-  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 buf = pfs.read('./tmpdir/tings.txt', {
-      sync: true,
-      encoding: null
-    });
-
-    assert(buf instanceof Buffer);
-  });
-  
-  
-  it(`[sync] Negative: Throw if not exists resource`, () => {
-    const guid = chance.guid();
-    
-    assert.throws(() => {
-      pfs.read(`./tmpdir/${guid}`, {
-        sync: true
-      });
-    });
-  });
-});

package/test/readdir.spec.ts

@@ -1,86 +0,0 @@
-import assert from 'node:assert';
-import Chance  from 'chance';
-import { expect } from 'expect';
-import { Iframe, fmock, restore } from './__fmock';
-import { pfs } from '../src';
-
-describe('readdir(src[, options])', () => {
-  const chance = new Chance();
-  let counter = 0;
-
-  beforeEach(() => {
-    const frame: Iframe = {
-      './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' };
-    }
-    
-    fmock(frame);
-  });
-  
-  afterEach(() => {
-    restore('./tmpdir');
-  });
-
-  it('Positive: Must return a directory listing', async () => {
-    const { length } = await pfs.readdir('./tmpdir');
-
-    assert(counter + 1 === length);
-  });
-  
-  
-  it('Negative: Throw if resource is not directory', async () => {
-    await expect(async () => {
-      await pfs.readdir(`./tmpdir/tings.txt`);
-    })
-    .rejects
-    .toThrow();
-  });
-  
-  
-  it('Negative: Throw if not exists resource', async () => {
-    const guid = chance.guid();
-    
-    await expect(async () => {
-      await pfs.readdir(`./tmpdir/${guid}`);
-    })
-    .rejects
-    .toThrow();
-  });
-  
-  
-  it('[sync] Positive: Must return a directory listing', () => {
-    const { length } = pfs.readdir('./tmpdir', {
-      sync: true
-    });
-
-    assert(counter + 1 === length);
-  });
-  
-  
-  it('Negative: Throw if resource is not directory', () => {
-    assert.throws(() => {
-      pfs.readdir(`./tmpdir/tings.txt`, {
-        sync: true
-      });
-    });
-  });
-  
-  
-  it(`Negative: Throw if not exists resource`, () => {
-    const guid = chance.guid();
-    
-    assert.throws(() => {
-      pfs.readdir(`./tmpdir/${guid}`, {
-        sync: true
-      });
-    });
-  });
-});