pwd-fs 3.2.4 → 3.3.2

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

package/test/remove.spec.ts

@@ -1,78 +0,0 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import Chance  from 'chance';
-import { expect } from 'expect';
-import { Iframe, fmock, restore } from './__fmock';
-import { pfs } from '../src';
-
-describe('remove(src [, options])', () => {
-  const chance = new Chance();
-  
-  beforeEach(() => {
-    const cwd = process.cwd();
-    
-    const frame: Iframe = {
-      './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' };
-    }
-    
-    fmock(frame);
-  });
-  
-  afterEach(() => {
-    restore('./tmpdir');
-  });
-  
-  
-  it('Positive: Removal a directory with a file', async () => {
-    await pfs.remove('./tmpdir');
-    const exist = fs.existsSync(`./tmpdir`);
-    
-    assert(exist === false);
-  });
-  
-  
-  it('Negative: Throw if not exists resource', async () => {
-    const guid = chance.guid();
-    
-    await expect(async () => {
-      await pfs.remove(`./${guid}`);
-    })
-    .rejects
-    .toThrow();
-  }); 
-  
-  
-  it('[sync] Positive: Removal a directory with a file', () => {
-    pfs.remove('./tmpdir', {
-      sync: true
-    });
-
-    const exist = fs.existsSync(`./tmpdir`);
-    
-    assert(exist === false);
-  });
-  
-  
-  it('[sync] Negative: Throw if not exists resource', () => {
-    const guid = chance.guid();
-
-    assert.throws(() => {
-      pfs.remove(`./tmpdir/${guid}`, {
-        sync: true
-      });
-    });
-  });
-});

package/test/rename.spec.ts

@@ -1,84 +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('rename(src, use [, options])', () => {
-  const chance = new Chance();
-
-  beforeEach(() => {
-    fmock({
-      './tmpdir/tings.txt': {
-        type: 'file',
-        data: chance.string()
-      },
-      './tmpdir/digest/': { type: 'directory' }
-    });
-  });
-  
-  afterEach(() => {
-    restore('./tmpdir');
-  });
-
-
-  it('Positive: Must be recursive rename file', async () => {
-    await pfs.rename('./tmpdir/tings.txt', './tmpdir/newapp.txt');
-    const exist = fs.existsSync(`./tmpdir/newapp.txt`);
-    
-    assert(exist);
-  });
-  
-  
-  it('Positive: Must be recursive rename directory', async () => {
-    await pfs.rename('./tmpdir/digest', './tmpdir/newxbase');
-    const exist = fs.existsSync(`./tmpdir/newxbase`);
-    
-    assert(exist);
-  });
-  
-  
-  it('Negative: Throw if not exists resource', async () => {
-    const guid = chance.guid();
-    
-    await expect(async () => {
-      await pfs.rename(`./tmpdir/${guid}`, './tmpdir/newxbase');
-    })
-    .rejects
-    .toThrow();
-  });
-  
-  
-  it('[sync] Positive: Must be recursive rename file', () => {
-    pfs.rename('./tmpdir/tings.txt', './tmpdir/newapp.txt', {
-      sync: true
-    });
-
-    const exist = fs.existsSync(`./tmpdir/newapp.txt`);
-    
-    assert(exist);
-  });
-  
-  
-  it('[sync] Positive: Must be recursive rename directory', () => {
-    pfs.rename('./tmpdir/digest', './tmpdir/newxbase', {
-      sync: true
-    });
-
-    const exist = fs.existsSync(`./tmpdir/newxbase`);
-    
-    assert(exist);
-  });
-  
-  
-  it('[sync] Negative: Throw if not exists resource', () => {
-    const guid = chance.guid();
-    
-    assert.throws(() => {
-      pfs.rename(`./tmpdir/${guid}`, './tmpdir/newxbase', {
-        sync: true
-      });
-    });
-  });
-});

package/test/stat.spec.ts

@@ -1,99 +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('stat(src [, options])', () => {
-  const chance = new Chance();
-
-  beforeEach(() => {
-    const cwd = process.cwd();
-    
-    fmock({
-      './tmpdir/tings.txt': {
-        type: 'file',
-        data: chance.string()
-      },
-      './tmpdir/digest/': { type: 'directory' },
-      './tmpdir/flexapp': {
-        type: 'symlink',
-        target: `${cwd}/tmpdir/tings.txt`
-      }
-    });
-  });
-  
-  afterEach(() => {
-    restore('./tmpdir');
-  });
-
-
-  it('Positive: Must return information a file', async () => {
-    const stats = await pfs.stat('./tmpdir/tings.txt');
-    
-    assert(stats.isFile());
-  });
-  
-  
-  it('Positive: Must return information a directory', async () => {
-    const stats = await pfs.stat('./tmpdir/digest');
-    
-    assert(stats.isDirectory());
-  });
-  
-  
-  it('Positive: Must return information a symlink', async () => {
-    const stats = await pfs.stat('./tmpdir/flexapp');
-    
-    assert(stats.isSymbolicLink());
-  });
-  
-  
-  it('Negative: Throw if not exists resource', async () => {
-    const guid = chance.guid();
-
-    await expect(async () => {
-      await pfs.stat(`./tmpdir/${guid}`);
-    })
-    .rejects
-    .toThrow();
-  });
-  
-  
-  it('[sync] Positive: Must return information a file', () => {
-    const stats = pfs.stat('./tmpdir/tings.txt', {
-      sync: true
-    });
-
-    assert(stats.isFile());
-  });
-  
-  
-  it('[sync] Positive: Must return information a directory in ', () => {
-    const stats = pfs.stat('./tmpdir/digest', {
-      sync: true
-    });
-
-    assert(stats.isDirectory());
-  });
-  
-  
-  it('[sync] Positive: Must return information a symlink', () => {
-    const stats = pfs.stat('./tmpdir/flexapp', {
-      sync: true
-    });
-
-    assert(stats.isSymbolicLink());
-  });
-  
-  
-  it('[sync] Negative: Throw if not exists resource', () => {
-    const guid = chance.guid();
-    
-    assert.throws(() => {
-      pfs.stat(`./tmpdir/${guid}`, {
-        sync: true
-      });
-    });
-  });
-});

package/test/symlink.spec.ts

@@ -1,95 +0,0 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import Chance  from 'chance';
-import { expect } from 'expect';
-import { Iframe, fmock, restore } from './__fmock';
-import { pfs } from '../src';
-
-describe('symlink(src, use [, options])', () => {
-  const chance = new Chance();
-  
-  beforeEach(() => {
-    const cwd = process.cwd();
-    
-    const frame: Iframe = {
-      './tmpdir/tings.txt': {
-        type: 'file',
-        data: chance.string()
-      },
-      './tmpdir/digest/': { type: 'directory' },
-      './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' };
-    }
-    
-    fmock(frame);
-  });
-  
-  afterEach(() => {
-    restore('./tmpdir');
-  });
-  
-  
-  it('Positive: Must be created a symbolic link', async () => {
-    await pfs.symlink('./tmpdir/tings.txt', './tmpdir/linkapp');
-    
-    const stat = fs.lstatSync('./tmpdir/linkapp');
-    
-    assert(stat.isSymbolicLink());
-  });
-  
-  
-  it('Positive: Must be created a symbolic link for directory', async () => {
-    await pfs.symlink('./tmpdir/digest', './tmpdir/linkapp');
-    
-    const stat = fs.lstatSync('./tmpdir/linkapp');
-    
-    assert(stat.isSymbolicLink());
-  });
-  
-  
-  it('Negative: Throw if destination already exists', async () => {
-    await expect(async () => {
-      await pfs.symlink('./tmpdir/tings.txt', './tmpdir/flexapp');
-    })
-    .rejects
-    .toThrow();
-  });
-  
-  
-  it('[sync] Positive: Must be created a symbolic link', () => {
-    pfs.symlink('./tmpdir/tings.txt', './tmpdir/linkapp', {
-      sync: true
-    });
-
-    const stat = fs.lstatSync('./tmpdir/linkapp');
-    
-    assert(stat.isSymbolicLink());
-  });
-  
-  
-  it('[sync] Positive: Must be created a symbolic link for directory', () => {
-    pfs.symlink('./tmpdir/digest', './tmpdir/linkapp', {
-      sync: true
-    });
-
-    const stat = fs.lstatSync('./tmpdir/linkapp');
-    
-    assert(stat.isSymbolicLink());
-  });
-  
-  it('[sync] Negative: Throw if destination already exists', () => {
-    assert.throws(() => {
-      pfs.symlink('./tmpdir/tings.txt', './tmpdir/flexapp', {
-        sync: true
-      });
-    });
-  });
-});