pwd-fs 2.4.2 → 3.1.4

package/test/mkdir.spec.ts

@@ -1,187 +1,121 @@
-import assert from 'assert';
-import os from 'os';
-import { sep } from 'path';
-import mockFs from 'mock-fs';
+import assert from 'node:assert';
+import fs from 'node:fs';
 import Chance  from 'chance';
-import PoweredFileSystem from '../src';
+import { expect } from 'expect';
+import { fmock, restore } from './__fmock';
+import { PoweredFileSystem } from '../src';
 
 describe('mkdir(src [, options])', () => {
-  beforeEach(() => {
-    const chance = new Chance();
+  const pfs = new PoweredFileSystem();
+  const chance = new Chance();
 
-    mockFs({
-      'tmpdir': {
-        'binapp': chance.string(),
-        'libxbase': mockFs.directory()
-      },
-      'flexapp': mockFs.symlink({
-        path: 'tmpdir/binapp'
-      })
+  beforeEach(() => {
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: chance.string()
+      }
     });
   });
-
-  afterEach(mockFs.restore);
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
 
   it('Positive: Create directories in the working directory', async () => {
-    const pfs = new PoweredFileSystem();
-    const chance = new Chance();
-
-    const base = chance.guid();
-    await pfs.mkdir(`./tmpdir/${base}`);
-
-    const exist = await pfs.test(`./tmpdir/${base}`);
+    const guid = chance.guid();
+    
+    await pfs.mkdir(`./tmpdir/${guid}`);
+    const exist = fs.existsSync(`./tmpdir/${guid}`);
+    
     assert(exist);
   });
-
+  
+  
   it(`Positive: Make current directory`, async () => {
-    const pfs = new PoweredFileSystem('./tmpdir');
+    const guid = chance.guid();
+    const pfs = new PoweredFileSystem(`./tmpdir/${guid}`);
 
     await pfs.mkdir('.');
-
-    const exist = await pfs.test('.');
-    assert(exist);
-  });
-
-  it(`Positive: Make current directory, when current directory is absolute path`, async () => {
-    const pfs = new PoweredFileSystem('./tmpdir');
-
-    await pfs.mkdir(process.cwd());
-
-    const exist = await pfs.test('.');
+    const exist = fs.existsSync(`./tmpdir/${guid}`);
+    
     assert(exist);
   });
-
+  
+  
   it('Positive: Should work fine with the existing directory', async () => {
-    const pfs = new PoweredFileSystem();
-    const chance = new Chance();
-
-    const base = chance.guid();
+    const guid = chance.guid();
 
-    for (const item of [base, base]) {
-      await pfs.mkdir(`./tmpdir/${item}`);
-
-      const exist = await pfs.test(`./tmpdir/${item}`);
-      assert(exist);
+    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();
 
-  it('Positive: Create directories when path is absolute', async () => {
-    const pfs = new PoweredFileSystem();
-    const chance = new Chance();
-
-    const tmpdir = os.tmpdir();
-    const base = chance.guid();
-
-    await pfs.mkdir(`${tmpdir}${sep}${base}`, {
-      resolve: false
+    pfs.mkdir(`./tmpdir/${guid}`, {
+      sync: true
     });
 
-    const exist = await pfs.test(`${tmpdir}${sep}${base}`);
+    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
+    });
 
-  it('Negative: Throw an exception if trying to create a directory in file', async () => {
-    const pfs = new PoweredFileSystem();
-    const chance = new Chance();
-
-    const base = chance.guid();
-
-    try {
-      await pfs.mkdir(`./tmpdir/binapp/${base}`);
-    }
-    catch (err) {
-      assert(err.errno === -20);
-    }
+    const exist = fs.existsSync(`./tmpdir/${guid}`);
+    
+    assert(exist);
   });
+  
+  
+  it('[sync] Positive: Should work fine with the existing directory', () => {
+    const guid = chance.guid();
 
-  describe('sync mode', () => {
-    it('Positive: Create directories in the working directory', async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
-
-      const base = chance.guid();
-
-      pfs.mkdir(`./tmpdir/${base}`, {
+    for (let i = 2; i; i--) {
+      pfs.mkdir(`./tmpdir/${guid}`, {
         sync: true
       });
-
-      const exist = await pfs.test(`./tmpdir/${base}`);
-      assert(exist);
-    });
-
-    it('Positive: Make current directory', async () => {
-      const pfs = new PoweredFileSystem('./tmpdir');
-
-      pfs.mkdir('.', {
+    }
+    
+    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
       });
-
-      const exist = await pfs.test('.');
-      assert(exist);
-    });
-
-    it('Positive: Should work fine with the existing directory', async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
-
-      const base = chance.guid();
-
-      for (const item of [base, base]) {
-        pfs.mkdir(`./tmpdir/${item}`, {
-          sync: true
-        });
-
-        const exist = await pfs.test(`./tmpdir/${item}`);
-        assert(exist);
-      }
-    });
-
-    it('Positive: Create directories when path is absolute', async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
-
-      const tmpdir = os.tmpdir();
-      const base = chance.guid();
-
-      pfs.mkdir(`${tmpdir}${sep}${base}`, {
-        sync: true,
-        resolve: false
-      });
-
-      const exist = await pfs.test(`${tmpdir}${sep}${base}`);
-      assert(exist);
-    });
-
-    it('Positive: Create in current directories when path is absolute', async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
-
-      const cwd = process.cwd();
-      const base = chance.guid();
-
-      pfs.mkdir(`${cwd}${sep}${base}`, {
-        sync: true,
-        resolve: false
-      });
-
-      const exist = await pfs.test(base);
-      assert(exist);
-    });
-
-    it('Negative: Throw an exception if trying to create a directory in file', async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
-
-      const base = chance.guid();
-
-      try {
-        pfs.mkdir(`./tmpdir/binapp/${base}`, {
-          sync: true
-        });
-      }
-      catch (err) {
-        assert(err.errno === -20);
-      }
     });
   });
 });

package/test/read.spec.ts

@@ -1,130 +1,91 @@
-import assert from 'assert';
-import { sep } from 'path';
-import mockFs from 'mock-fs';
+import assert from 'node:assert';
 import Chance  from 'chance';
-import PoweredFileSystem from '../src';
+import { expect } from 'expect';
+import { fmock, restore } from './__fmock';
+import { pfs } from '../src';
 
 describe('read(src [, options])', () => {
-  beforeEach(() => {
-    const chance = new Chance();
+  const chance = new Chance();
+  let sentences = 0;
 
-    mockFs({
-      'tmpdir': {
-        'binapp': chance.string(),
-        'libxbase': mockFs.directory()
-      },
-      'flexapp': mockFs.symlink({
-        path: 'tmpdir/binapp'
-      })
+  beforeEach(() => {
+    const tingsContent = chance.paragraph();
+    sentences = tingsContent.length;
+    
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: tingsContent
+      }
     });
   });
-
-  afterEach(mockFs.restore);
-
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
+  
   it('Positive: Must read content of file; String type by default', async () => {
-    const pfs = new PoweredFileSystem();
-
-    const raw = await pfs.read('./tmpdir/binapp');
+    const { length } = await pfs.read('./tmpdir/tings.txt');
 
-    assert(raw.length > 0);
+    assert(length === sentences);
   });
-
+  
+  
   it('Positive: Must read Buffer content of file when encoding is null', async () => {
-    const pfs = new PoweredFileSystem();
-
-    const raw = await pfs.read('./tmpdir/binapp', {
+    const buffer = await pfs.read('./tmpdir/tings.txt', {
       encoding: null
     });
 
-    assert(raw instanceof Buffer);
-  });
-
-  it('Positive: Must read content of file, when path is absolute', async () => {
-    const pfs = new PoweredFileSystem();
-
-    const cwd = process.cwd();
-
-    const raw = await pfs.read(`${cwd}${sep}tmpdir${sep}binapp`, {
-      resolve: false
-    });
-
-    assert(raw.length > 0);
+    assert(buffer instanceof Buffer);
   });
-
+  
+  
   it('Negative: Throw if resource is not file', async () => {
-    const pfs = new PoweredFileSystem();
-
-    try {
-      await pfs.read(`./tmpdir/libxbase`);
-    }
-    catch (err) {
-      assert(err.errno === -21);
-    }
+    await expect(async () => {
+      await pfs.read(`./tmpdir`);
+    })
+    .rejects
+    .toThrow();
   });
-
+  
+  
   it('Negative: Throw if not exists resource', async () => {
-    const pfs = new PoweredFileSystem();
-    const chance = new Chance();
+    const guid = chance.guid();
 
-    const base = chance.guid();
-
-    try {
-      await pfs.read(`./${base}`);
-    }
-    catch (err) {
-      assert(err.errno === -2);
-    }
+    await expect(async () => {
+      await pfs.read(`./tmpdir/${guid}`);
+    })
+    .rejects
+    .toThrow();
   });
-
-  describe('sync mode', () => {
-    it('Positive: Must read content of file; String type by default', async () => {
-      const pfs = new PoweredFileSystem();
-
-      const { length } = pfs.read('./tmpdir/binapp', {
-        sync: true
-      });
-
-      assert(length > 0);
+  
+  
+  it('[sync] Positive: Must read content of file; String type by default', () => {
+    const { length } = pfs.read('./tmpdir/tings.txt', {
+      sync: true
     });
 
-    it('Positive: Must read Buffer content of file when encoding is null', async () => {
-      const pfs = new PoweredFileSystem();
-
-      const raw = pfs.read('./tmpdir/binapp', {
-        encoding: null,
-        sync: true
-      });
-
-      assert(raw instanceof Buffer);
+    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
     });
 
-    it('Positive: Must read content of file, when path is absolute', async () => {
-      const pfs = new PoweredFileSystem();
-
-      const cwd = process.cwd();
-
-      const { length } = pfs.read(`${cwd}${sep}tmpdir${sep}binapp`, {
-        sync: true,
-        resolve: false
+    assert(buffer instanceof Buffer);
+  });
+  
+  
+  it(`[sync] Negative: Throw if not exists resource`, () => {
+    const guid = chance.guid();
+    
+    assert.throws(() => {
+      pfs.read(`./tmpdir/${guid}`, {
+        sync: true
       });
-
-      assert(length > 0);
-    });
-
-    it(`Negative: Throw if not exists resource`, async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
-
-      const base = chance.guid();
-
-      try {
-        pfs.read(`./${base}`, {
-          sync: true
-        });
-      }
-      catch (err) {
-        assert(err.errno === -2);
-      }
     });
   });
 });

package/test/readdir.spec.ts

@@ -1,134 +1,86 @@
-import assert from 'assert';
-import { sep } from 'path';
-import mockFs from 'mock-fs';
+import assert from 'node:assert';
 import Chance  from 'chance';
-import PoweredFileSystem from '../src';
+import { expect } from 'expect';
+import { Iframe, fmock, restore } from './__fmock';
+import { pfs } from '../src';
 
 describe('readdir(src[, options])', () => {
-  beforeEach(() => {
-    const chance = new Chance();
+  const chance = new Chance();
+  let counter = 0;
 
-    mockFs({
-      'tmpdir': {
-        'binapp': chance.string(),
-        'libxbase': mockFs.directory()
-      },
-      'flexapp': mockFs.symlink({
-        path: 'tmpdir/binapp'
-      })
-    });
+  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(mockFs.restore);
-
-  it('Positive: Must return a directory listing', async () => {
-    const pfs = new PoweredFileSystem();
-
-    const listOfFiles = await pfs.readdir('./tmpdir');
-
-    assert.deepStrictEqual(listOfFiles, [
-      'binapp',
-      'libxbase'
-    ]);
+  
+  afterEach(() => {
+    restore('./tmpdir');
   });
 
-  it('Positive: Must return a directory listing, when path is absolute', async () => {
-    const pfs = new PoweredFileSystem();
-
-    const cwd = process.cwd();
-
-    const listOfFiles = await pfs.readdir(`${cwd}${sep}tmpdir`, {
-      resolve: false
-    });
+  it('Positive: Must return a directory listing', async () => {
+    const { length } = await pfs.readdir('./tmpdir');
 
-    assert.deepStrictEqual(listOfFiles, [
-      'binapp',
-      'libxbase'
-    ]);
+    assert(counter + 1 === length);
   });
-
+  
+  
   it('Negative: Throw if resource is not directory', async () => {
-    const pfs = new PoweredFileSystem();
-
-    try {
-      await pfs.readdir(`./tmpdir/binapp`);
-    }
-    catch (err) {
-      assert(err.errno === -20);
-    }
+    await expect(async () => {
+      await pfs.readdir(`./tmpdir/tings.txt`);
+    })
+    .rejects
+    .toThrow();
   });
-
+  
+  
   it('Negative: Throw if not exists resource', async () => {
-    const pfs = new PoweredFileSystem();
-    const chance = new Chance();
-
-    const base = chance.guid();
-
-    try {
-      await pfs.readdir(`./${base}`);
-    }
-    catch (err) {
-      assert(err.errno === -2);
-    }
+    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
+    });
 
-  describe('sync mode', () => {
-    it('Positive: Must return a directory listing', async () => {
-      const pfs = new PoweredFileSystem();
-
-      const listOfFiles = pfs.readdir('./tmpdir', {
+    assert(counter + 1 === length);
+  });
+  
+  
+  it('Negative: Throw if resource is not directory', () => {
+    assert.throws(() => {
+      pfs.readdir(`./tmpdir/tings.txt`, {
         sync: true
       });
-
-      assert.deepStrictEqual(listOfFiles, [
-        'binapp',
-        'libxbase'
-      ]);
     });
-
-    it('Positive: Must return a directory listing, when path is absolute', async () => {
-      const pfs = new PoweredFileSystem();
-
-      const cwd = process.cwd();
-
-      const listOfFiles = pfs.readdir(`${cwd}${sep}tmpdir`, {
-        sync: true,
-        resolve: false
+  });
+  
+  
+  it(`Negative: Throw if not exists resource`, () => {
+    const guid = chance.guid();
+    
+    assert.throws(() => {
+      pfs.readdir(`./tmpdir/${guid}`, {
+        sync: true
       });
-
-      assert.deepStrictEqual(listOfFiles, [
-        'binapp',
-        'libxbase'
-      ]);
-    });
-
-    it('Negative: Throw if resource is not directory', async () => {
-      const pfs = new PoweredFileSystem();
-
-      try {
-        pfs.readdir(`./tmpdir/binapp`, {
-          sync: true
-        });
-      }
-      catch (err) {
-        assert(err.errno === -20);
-      }
-    });
-
-    it(`Negative: Throw if not exists resource`, async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
-
-      const base = chance.guid();
-
-      try {
-        pfs.readdir(`./${base}`, {
-          sync: true
-        });
-      }
-      catch (err) {
-        assert(err.errno === -2);
-      }
     });
   });
 });