pwd-fs 2.4.2 → 3.1.4

package/test/chmod.spec.ts

@@ -1,127 +1,77 @@
-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, bitmask } from '../src';
 
 describe('chmod(src, mode [, options])', () => {
-  beforeEach(() => {
-    const chance = new Chance();
+  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(() => {
+    restore('./tmpdir');
+  });
 
-  afterEach(mockFs.restore);
 
   it('Positive: Changes directory and file permissions', async () => {
-    const pfs = new PoweredFileSystem();
-
     await pfs.chmod('./tmpdir', 0o744);
 
-    const { mode } = await pfs.stat('./tmpdir/binapp');
-    const umask = PoweredFileSystem.bitmask(mode);
+    const { mode } = fs.lstatSync('./tmpdir/tings.txt');
+    const umask = bitmask(mode);
 
     assert(umask === 0o744);
   });
 
-  it('Positive: Must be changes directory when path is absolute', async () => {
-    const pfs = new PoweredFileSystem();
 
-    const cwd = process.cwd();
-    await pfs.chmod(`${cwd}${sep}tmpdir${sep}libxbase` , 0o744, {
-      resolve: false
+  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 } = await pfs.stat('./tmpdir/libxbase');
-    const umask = PoweredFileSystem.bitmask(mode);
+    const { mode } = fs.lstatSync('./tmpdir');
+    const umask = bitmask(mode);
 
     assert(umask === 0o744);
   });
 
-  it('Negative: Search permission is denied on a component of the path prefix', async () => {
-    const pfs = new PoweredFileSystem();
 
-    try {
-      await pfs.chmod('./tmpdir', 0);
-    }
-    catch (err) {
-      assert(err.errno === -9);
-    }
-  });
+  it(`[sync] Positive: Changes file permissions`, () => {
+    pfs.chmod('./tmpdir', 0o744, {
+      sync: true
+    });
 
-  it('Negative: Throw if not exists resource', async () => {
-    const pfs = new PoweredFileSystem();
+    const { mode } = fs.lstatSync('./tmpdir/tings.txt');
+    const umask = bitmask(mode);
 
-    try {
-      await pfs.chmod('./non-existent-source', 0o744);
-    }
-    catch (err) {
-      assert(err.errno === -2);
-    }
+    assert(umask === 0o744);
   });
+  
+  
+  it('[sync] Negative: Throw if not exists resource', () => {
+    const guid = chance.guid();
 
-  describe('sync mode', () => {
-    it(`Positive: Changes directory and file permissions`, async () => {
-      const pfs = new PoweredFileSystem();
-
-      pfs.chmod('./tmpdir', 0o744, {
+    assert.throws(() => {
+      pfs.chmod(`./${guid}`, 0o744, {
         sync: true
       });
-
-      const { mode } = await pfs.stat('./tmpdir/binapp');
-      const umask = PoweredFileSystem.bitmask(mode);
-
-      assert(umask === 0o744);
-    });
-
-    it('Positive: Must be changes directory when path is absolute', async () => {
-      const pfs = new PoweredFileSystem();
-
-      const cwd = process.cwd();
-
-      pfs.chmod(`${cwd}${sep}tmpdir${sep}libxbase` , 0o744, {
-        sync: true,
-        resolve: false
-      });
-
-      const { mode } = await pfs.stat('./tmpdir/libxbase');
-      const umask = PoweredFileSystem.bitmask(mode);
-
-      assert(umask === 0o744);
-    });
-
-    it('Negative: Search permission is denied on a component of the path prefix', async () => {
-      const pfs = new PoweredFileSystem();
-
-      try {
-        pfs.chmod('./tmpdir', 0, {
-          sync: true
-        });
-      }
-      catch (err) {
-        assert(err.errno === -9);
-      }
-    });
-
-    it('Negative: Throw if not exists resource', async () => {
-      const pfs = new PoweredFileSystem();
-
-      try {
-        pfs.chmod('./non-existent-source', 0o744, {
-          sync: true
-        });
-      }
-      catch (err) {
-        assert(err.errno === -2);
-      }
     });
   });
 });

package/test/chown.spec.ts

@@ -1,118 +1,86 @@
-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('chown(src, uid, gid [, 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(mockFs.restore);
-
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
+  
+  
   it('Positive: Changes the permissions of a file', async () => {
-    const pfs = new PoweredFileSystem();
+    const { uid, gid } = fs.statSync('./tmpdir/tings.txt');
+    await pfs.chown('./tmpdir/tings.txt', uid, gid);
 
-    await pfs.chown('./tmpdir', 0, 0);
-    const { uid, gid } = await pfs.stat('./tmpdir');
-
-    assert(uid === 0 && gid === 0);
+    assert(uid && gid);
   });
-
+  
+  
   it('Positive: Changes the permissions of a directory', async () => {
-    const pfs = new PoweredFileSystem();
+    const { uid, gid } = fs.statSync('./tmpdir/digest');
+    await pfs.chown('./tmpdir/digest', uid, gid);
 
-    await pfs.chown('./tmpdir/libxbase', 0, 0);
-    const { uid, gid } = await pfs.stat('./tmpdir/libxbase');
-
-    assert(uid === 0 && gid === 0);
+    assert(uid && gid);
   });
-
-  it('Positive: Changes the permissions of a file, when path is absolute', async () => {
-    const pfs = new PoweredFileSystem();
-
-    const cwd = process.cwd();
-    await pfs.chown(`${cwd}${sep}tmpdir${sep}binapp`, 1, 1, {
-      resolve: false
-    });
-
-    const { uid, gid } = await pfs.stat('./tmpdir/binapp');
-
-    assert(uid === 1 && gid === 1);
-  });
-
+  
+  
   it('Negative: To a non-existent resource to return an Error', async () => {
-    const pfs = new PoweredFileSystem();
-
-    try {
-      await pfs.chown('./non-existent-source', 1, 1);
-    }
-    catch (err) {
-      assert(err.errno === -2);
-    }
+    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');
 
-  describe('sync mode', () => {
-    it('Positive: Changes the permissions of a file', async () => {
-      const pfs = new PoweredFileSystem();
-
-      pfs.chown('./tmpdir/binapp', 1, 1, {
-        sync: true
-      });
-
-      const { uid, gid } = await pfs.stat('./tmpdir/binapp');
-
-      assert(uid === 1 && gid === 1);
+    pfs.chown('./tmpdir/tings.txt', uid, gid, {
+      sync: true
     });
 
-    it('Positive: Changes the permissions of a directory', async () => {
-      const pfs = new PoweredFileSystem();
-
-      pfs.chown('./tmpdir', 1, 1, {
-        sync: true
-      });
-
-      const { uid, gid } = await pfs.stat('./tmpdir');
+    assert(uid && gid);
+  });
+  
+  
+  it('[sync] Positive: Changes the permissions of a directory', () => {
+    const { uid, gid } = fs.statSync('./tmpdir/digest');
 
-      assert(uid === 1 && gid === 1);
+    pfs.chown('./tmpdir/digest', uid, gid, {
+      sync: true
     });
 
-    it('Positive: Changes the permissions of a file, when path is absolute', async () => {
-      const pfs = new PoweredFileSystem();
-
-      const cwd = process.cwd();
-      pfs.chown(`${cwd}${sep}tmpdir${sep}binapp`, 1, 1, {
-        sync: true,
-        resolve: false
+    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
       });
-
-      const { uid, gid } = await pfs.stat('./tmpdir/binapp');
-
-      assert(uid === 1 && gid === 1);
-    });
-
-    it(`Negative: To a non-existent resource to return an Error`, async () => {
-      const pfs = new PoweredFileSystem();
-
-      try {
-        pfs.chown('./non-existent-source', 1, 1, {
-          sync: true
-        });
-      }
-      catch (err) {
-        assert(err.errno === -2);
-      }
     });
   });
 });

package/test/constructor.spec.ts

@@ -1,16 +1,13 @@
-import assert from 'assert';
-import PoweredFileSystem from '../src';
-
-describe('#constructor: new PoweredFileSystem(path)', () => {
-  it('Positive: Must be backwards compatible with #require', () => {
-    assert(require('../src') === PoweredFileSystem);
-  });
+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,171 +1,101 @@
-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 { pfs } from '../src';
 
 describe('copy(src, dir [, options])', () => {
+  const chance = new Chance();
+  
   beforeEach(() => {
-    const chance = new Chance();
-
-    mockFs({
-      'tmpdir': {
-        'binapp': chance.string(),
-        'libxbase': mockFs.directory()
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: chance.string()
       },
-      'flexapp': mockFs.symlink({
-        path: 'tmpdir/binapp'
-      })
+      './tmpdir/digest/': { type: 'directory' }
     });
   });
-
-  afterEach(mockFs.restore);
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
 
   it('Positive: Copying a item file', async () => {
-    const pfs = new PoweredFileSystem();
-
-    const dist = os.tmpdir();
-    await pfs.copy('./tmpdir/binapp', dist);
-
-    const { mode } = await pfs.stat(`${dist}/binapp`);
-    const umask = PoweredFileSystem.bitmask(mode);
-
-    assert(umask === 0o666);
+    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 () => {
-    const pfs = new PoweredFileSystem();
-
-    const dist = os.tmpdir();
-    await pfs.copy('./tmpdir', dist);
-
-    const { mode } = await pfs.stat(`${dist}/tmpdir/libxbase`);
-    const umask = PoweredFileSystem.bitmask(mode);
-
-    assert(umask === 0o777);
-  });
-
-  it('Positive: Recursive copying a directory. Permission check of file', async () => {
-    const pfs = new PoweredFileSystem();
-
-    const dist = os.tmpdir();
-    await pfs.copy('./tmpdir', dist);
-
-    const { mode } = await pfs.stat(`${dist}/tmpdir/binapp`);
-    const umask = PoweredFileSystem.bitmask(mode);
-
-    assert(umask === 0o666);
-  });
-
-  it('Positive: Copying a item file when path is absolute', async () => {
-    const pfs = new PoweredFileSystem();
-
-    const cwd = process.cwd();
-    const dist = os.tmpdir();
-
-    await pfs.copy(`${cwd}${sep}tmpdir`, dist, {
-      resolve: false
-    });
-
-    const { mode } = await pfs.stat(`${dist}/tmpdir/binapp`);
-    const umask = PoweredFileSystem.bitmask(mode);
-
-    assert(umask === 0o666);
+    await pfs.copy('./src', './tmpdir');
+    const exist = fs.existsSync(`./tmpdir/src`);
+    
+    assert(exist);
   });
 
+  
   it('Negative: Throw if not exists resource', async () => {
-    const pfs = new PoweredFileSystem();
-
-    try {
-      await pfs.copy('./non-existent', '.');
-    }
-    catch (err) {
-      assert(err.errno === -2);
-    }
+    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 () => {
-    const pfs = new PoweredFileSystem();
-
-    try {
+    await expect(async () => {
       await pfs.copy('./tmpdir', '.');
-    }
-    catch (err) {
-      assert(err.errno === -17);
-    }
+    })
+    .rejects
+    .toThrow();
   });
+  
+  
+  it('[sync] Positive: Copying a file', () => {
+    pfs.copy('./tmpdir/tings.txt', './tmpdir/digest', {
+      sync: true
+    });
 
-  describe('sync mode', () => {
-    it('Positive: Copying a file', async () => {
-      const pfs = new PoweredFileSystem();
-      const dist = os.tmpdir();
-
-      pfs.copy('./tmpdir/binapp', dist, {
-        sync: true
-      });
-
-      const { mode } = await pfs.stat(`${dist}/binapp`);
-      const umask = PoweredFileSystem.bitmask(mode);
-
-      assert(umask === 0o666);
+    const exist = fs.existsSync(`./tmpdir/digest/tings.txt`);
+    
+    assert(exist);
+  });
+  
+  
+  it('[sync] Positive: Recursive copying a directory', () => {
+    pfs.copy('./src', './tmpdir', {
+      sync: true
     });
 
-    it('Positive: Recursive copying a directory', async () => {
-      const pfs = new PoweredFileSystem();
-      const dist = os.tmpdir();
+    const exist = fs.existsSync(`./tmpdir/src`);
+    
+    assert(exist);
+  });
+  
+  
+  it('[sync] Negative: Throw if not exists resource', () => {
+    const guid = chance.guid();
 
-      pfs.copy('./tmpdir', dist, {
+    assert.throws(() => {
+      pfs.copy(`./${guid}`, '.', {
         sync: true
       });
-
-      const { mode } = await pfs.stat(`${dist}/tmpdir/libxbase`);
-      const umask = PoweredFileSystem.bitmask(mode);
-
-      assert(umask === 0o777);
     });
-
-    it('Positive: Copying a item file when path is absolute', async () => {
-      const pfs = new PoweredFileSystem();
-
-      const cwd = process.cwd();
-      const dist = os.tmpdir();
-
-      pfs.copy(`${cwd}${sep}tmpdir`, dist, {
-        sync: true,
-        resolve: false
+  });
+  
+  
+  it('[sync] Negative: An attempt to copy to an existing resource should return an Error', () => {
+    assert.throws(() => {
+      pfs.copy('./tmpdir', '.', {
+        sync: true
       });
-
-      const { mode } = await pfs.stat(`${dist}/tmpdir/binapp`);
-      const umask = PoweredFileSystem.bitmask(mode);
-
-      assert(umask === 0o666);
-    });
-
-    it('Negative: Throw if not exists resource', async () => {
-      const pfs = new PoweredFileSystem();
-
-      try {
-        pfs.copy('./non-existent', '.', {
-          sync: true
-        });
-      }
-      catch (err) {
-        assert(err.errno === -2);
-      }
-    });
-
-    it('Negative: An attempt to copy to an existing resource should return an Error', async () => {
-      const pfs = new PoweredFileSystem();
-
-      try {
-        pfs.copy('./tmpdir', '.', {
-          sync: true
-        });
-      }
-      catch (err) {
-        assert(err.errno === -17);
-      }
     });
   });
-});
+});