pwd-fs 2.4.2 → 3.1.4

package/test/remove.spec.ts

@@ -1,102 +1,78 @@
-import assert from 'assert';
-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 { Iframe, fmock, restore } from './__fmock';
+import { pfs } from '../src';
 
 describe('remove(src [, options])', () => {
+  const chance = new Chance();
+  
   beforeEach(() => {
-    const chance = new Chance();
-
-    mockFs({
-      'tmpdir': {
-        'binapp': chance.string(),
-        'libxbase': mockFs.directory()
+    const cwd = process.cwd();
+    
+    const frame: Iframe = {
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: chance.string()
       },
-      'flexapp': mockFs.symlink({
-        path: 'tmpdir/binapp'
-      })
-    });
+      './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(mockFs.restore);
-
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
+  
+  
   it('Positive: Removal a directory with a file', async () => {
-    const pfs = new PoweredFileSystem();
-
     await pfs.remove('./tmpdir');
-
-    const exist = await pfs.test('./tmpdir');
+    const exist = fs.existsSync(`./tmpdir`);
+    
     assert(exist === false);
   });
-
-  it('Positive: Removal a directory with a file, when path is absolute', async () => {
-    const pfs = new PoweredFileSystem();
-
-    const cwd = process.cwd();
-
-    await pfs.remove(`${cwd}${sep}tmpdir`, {
-      resolve: 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 = await pfs.test('./tmpdir');
+    const exist = fs.existsSync(`./tmpdir`);
+    
     assert(exist === false);
   });
+  
+  
+  it('[sync] Negative: Throw if not exists resource', () => {
+    const guid = chance.guid();
 
-  it('Negative: Throw if not exists resource', async () => {
-    const pfs = new PoweredFileSystem();
-    const chance = new Chance();
-
-    const base = chance.guid();
-
-    try {
-      await pfs.remove(`./${base}`);
-    }
-    catch (err) {
-      assert(err.errno === -2);
-    }
-  });
-
-  describe('sync mode', () => {
-    it('Positive: Removal a directory with a file', async () => {
-      const pfs = new PoweredFileSystem();
-
-      pfs.remove('./tmpdir', {
+    assert.throws(() => {
+      pfs.remove(`./tmpdir/${guid}`, {
         sync: true
       });
-
-      const exist = await pfs.test('./tmpdir');
-      assert(exist === false);
-    });
-
-    it('Positive: Removal a directory with a file, when path is absolute', async () => {
-      const pfs = new PoweredFileSystem();
-
-      const cwd = process.cwd();
-
-      pfs.remove(`${cwd}${sep}tmpdir`, {
-        sync: true,
-        resolve: false
-      });
-
-      const exist = await pfs.test('./tmpdir');
-      assert(exist === false);
-    });
-
-    it('Negative: Throw if not exists resource', async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
-
-      const base = chance.guid();
-
-      try {
-        pfs.remove(`./${base}`, {
-          sync: true
-        });
-      }
-      catch (err) {
-        assert(err.errno === -2);
-      }
     });
   });
 });

package/test/rename.spec.ts

@@ -1,122 +1,84 @@
-import assert from 'assert';
-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 {pfs } from '../src';
 
 describe('rename(src, use [, options])', () => {
-  beforeEach(() => {
-    const chance = new Chance();
+  const chance = new Chance();
 
-    mockFs({
-      'tmpdir': {
-        'binapp': chance.string(),
-        'libxbase': mockFs.directory()
+  beforeEach(() => {
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: chance.string()
       },
-      'flexapp': mockFs.symlink({
-        path: 'tmpdir/binapp'
-      })
+      './tmpdir/digest/': { type: 'directory' }
     });
   });
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
 
-  afterEach(mockFs.restore);
 
   it('Positive: Must be recursive rename file', async () => {
-    const pfs = new PoweredFileSystem();
-
-    await pfs.rename('./tmpdir/binapp', './tmpdir/newapp');
-    const exist = await pfs.test('./tmpdir/newapp');
-
+    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 () => {
-    const pfs = new PoweredFileSystem();
-
-    await pfs.rename('./tmpdir/libxbase', './tmpdir/newxbase');
-    const exist = await pfs.test('./tmpdir/newxbase');
-
+    await pfs.rename('./tmpdir/digest', './tmpdir/newxbase');
+    const exist = fs.existsSync(`./tmpdir/newxbase`);
+    
     assert(exist);
   });
-
-  it('Positive: Must be recursive rename directory, when path is absolute', async () => {
-    const pfs = new PoweredFileSystem();
-
-    const cwd = process.cwd();
-
-    await pfs.rename(`${cwd}${sep}tmpdir`, `${cwd}${sep}newxbase`, {
-      resolve: false
+  
+  
+  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 = await pfs.test('./newxbase');
+    const exist = fs.existsSync(`./tmpdir/newapp.txt`);
+    
     assert(exist);
   });
-
-  it('Negative: Throw if not exists resource', async () => {
-    const pfs = new PoweredFileSystem();
-    const chance = new Chance();
-
-    const base = chance.guid();
-
-    try {
-      await pfs.rename(`./${base}`, './tmpdir/newapp');
-    }
-    catch (err) {
-      assert(err.errno === -2);
-    }
-  });
-
-  describe('sync mode', () => {
-    it('Positive: Must be recursive rename file', async () => {
-      const pfs = new PoweredFileSystem();
-
-      pfs.rename('./tmpdir/binapp', './tmpdir/newapp', {
-        sync: true
-      });
-
-      const exist = await pfs.test('./tmpdir/newapp');
-      assert(exist);
+  
+  
+  it('[sync] Positive: Must be recursive rename directory', () => {
+    pfs.rename('./tmpdir/digest', './tmpdir/newxbase', {
+      sync: true
     });
 
-    it('Positive: Must be recursive rename directory', async () => {
-      const pfs = new PoweredFileSystem();
-
-      pfs.rename('./tmpdir/libxbase', './tmpdir/newxbase', {
+    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
       });
-
-      const exist = await pfs.test('./tmpdir/newxbase');
-      assert(exist);
-    });
-
-    it('Positive: Must be recursive rename directory, when path is absolute', async () => {
-      const pfs = new PoweredFileSystem();
-
-      const cwd = process.cwd();
-
-      pfs.rename(`${cwd}${sep}tmpdir`, `${cwd}${sep}newxbase`, {
-        sync: true,
-        resolve: false
-      });
-
-      const exist = await pfs.test('./newxbase');
-      assert(exist);
-    });
-
-    it('Negative: Throw if not exists resource', async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
-
-      const base = chance.guid();
-
-      try {
-        pfs.rename(`./${base}`, './tmpdir/newapp', {
-          sync: true
-        });
-      }
-      catch (err) {
-        assert(err.errno === -2);
-      }
     });
   });
 });

package/test/stat.spec.ts

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