pwd-fs 2.4.1 → 3.1.3

package/__tests__/readdir.spec.ts

@@ -0,0 +1,87 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { type Iframe, fmock, restore } from './__fmock';
+import PoweredFileSystem from '../src';
+
+describe('readdir(src[, options])', () => {
+  const pfs = new PoweredFileSystem();
+  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/__tests__/remove.spec.ts

@@ -0,0 +1,78 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { type Iframe, fmock, restore } from './__fmock';
+import PoweredFileSystem from '../src';
+
+describe('remove(src [, options])', () => {
+  const pfs = new PoweredFileSystem();
+  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/__tests__/rename.spec.ts

@@ -0,0 +1,84 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { fmock, restore } from './__fmock';
+import PoweredFileSystem from '../src';
+
+describe('rename(src, use [, options])', () => {
+  const pfs = new PoweredFileSystem();
+  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/__tests__/stat.spec.ts

@@ -0,0 +1,100 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { fmock, restore } from './__fmock';
+import PoweredFileSystem from '../src';
+
+describe('stat(src [, options])', () => {
+  const pfs = new PoweredFileSystem();
+  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/__tests__/symlink.spec.ts

@@ -0,0 +1,95 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { type Iframe, fmock, restore } from './__fmock';
+import PoweredFileSystem from '../src';
+
+describe('symlink(src, use [, options])', () => {
+  const pfs = new PoweredFileSystem();
+  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
+      });
+    });
+  });
+});

package/__tests__/test.spec.ts

@@ -0,0 +1,82 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { fmock, restore } from './__fmock';
+import PoweredFileSystem from '../src';
+
+describe('test(src[, options])', () => {
+  const pfs = new PoweredFileSystem();
+  const chance = new Chance();
+
+  beforeEach(() => {
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: chance.string()
+      },
+      './tmpdir/digest/': { type: 'directory' }
+    });
+  });
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
+  
+
+  it(`Positive: Should return 'true' for current working directory`, async () => {
+    const exist = await pfs.test('.');
+    
+    assert(exist);
+  });
+  
+  
+  it(`Positive: For existing file should return 'true'`, async () => {
+    const exist = await pfs.test('./tmpdir/tings.txt');
+    
+    assert(exist);
+  });
+  
+  
+  it(`Positive: For existing directory should return 'true'`, async () =>  {
+    const exist = await pfs.test('./tmpdir/digest');
+    
+    assert(exist);
+  });
+  
+  
+  it(`Positive: A non-existent file must return 'false'`, async () => {
+    const guid = chance.guid();
+    const exist = await pfs.test(`./tmpdir/${guid}`);
+
+    assert(exist === false);
+  });
+  
+  
+  it(`Positive: For existing file should return 'true'`, () =>  {
+    const exist = pfs.test('./tmpdir/tings.txt', {
+      sync: true
+    });
+
+    assert(exist);
+  });
+  
+  
+  it(`[sync] Positive: For existing directory should return 'true'`, () =>  {
+    const exist = pfs.test('./tmpdir/digest', {
+      sync: true
+    });
+
+    assert(exist);
+  });
+
+  
+  it(`[sync] Positive: A non-existent file must return 'false'`, () => {
+    const guid = chance.guid();
+    
+    const exist = pfs.test(`./tmpdir/${guid}`, {
+      sync: true
+    });
+
+    assert(exist === false);
+  });
+});

package/__tests__/write.spec.ts

@@ -0,0 +1,104 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import Chance  from 'chance';
+import { fmock, restore } from './__fmock';
+import PoweredFileSystem from '../src';
+
+describe('write(src, data[, options])', () => {
+  const pfs = new PoweredFileSystem();
+  const chance = new Chance();
+
+  beforeEach(() => {    
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: chance.string()
+      }
+    });
+  });
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
+
+  it('Positive: Must write content to file', async () => {
+    const payload = chance.paragraph();
+    const guid = chance.guid();
+
+    await pfs.write(`./tmpdir/${guid}.txt`, payload);
+    const { size } = fs.lstatSync(`./tmpdir/${guid}.txt`);
+    
+    assert(payload.length === size);
+  });
+  
+  
+  it('Positive: Must rewrite content if file already exists', async () => {
+    const payload = chance.paragraph();
+
+    await pfs.write('./tmpdir/tings.txt', payload);
+    const { size } = fs.lstatSync('./tmpdir/tings.txt');
+    
+    assert(payload.length === size);
+  });
+
+
+  it('Negative: Throw if resource is directory', async () => {
+    const payload = chance.paragraph();
+    
+    await expect(async () => {
+      await pfs.write('./tmpdir', payload);
+    })
+    .rejects
+    .toThrow();
+  });
+
+
+  it(`Negative: Unexpected option 'flag' returns Error`, async () => {
+    const payload = chance.paragraph();
+    
+    await expect(async () => {
+      await pfs.write('./tmpdir/tings.txt', payload, {
+        flag: 'r'
+      });
+    })
+    .rejects
+    .toThrow();
+  });
+  
+  
+  it('[sync] Positive: Write contents even to a non-existent file', () => {
+    const payload = chance.paragraph();
+    const guid = chance.guid();
+
+    pfs.write(`./tmpdir/${guid}.txt`, payload, {
+      sync: true
+    });
+    
+    const content = fs.readFileSync(`./tmpdir/${guid}.txt`, 'utf8');
+    
+    assert(payload === content);
+  });
+  
+  
+  it('[sync] Negative: Throw if resource is directory', () => {
+    const payload = chance.paragraph();
+
+    assert.throws(() => {
+      pfs.write('./tmpdir', payload, {
+        sync: true
+      });
+    });
+  });
+  
+  
+  it(`[sync] Negative: Unexpected option 'flag' returns Error`, () => {
+    const payload = chance.paragraph();
+
+    assert.throws(() => {
+      pfs.write('./tmpdir/tings.txt', payload, {
+        sync: true,
+        flag: 'r'
+      });
+    });
+  });
+});

package/appveyor.yml

@@ -1,15 +1,13 @@
 environment:
   matrix:
-    - nodejs_version: 8
-    - nodejs_version: 10
-    - nodejs_version: 12
     - nodejs_version: 14
     - nodejs_version: 16
+    - nodejs_version: 18
+    - nodejs_version: 20
 install:
   - ps: Install-Product node $env:nodejs_version
   - npm config set loglevel warn
   - npm install --silent
-  - npm install -g typescript
 test_script:
   - npm run build
   - npm test

package/jest.config.ts

@@ -0,0 +1,14 @@
+import type { JestConfigWithTsJest } from 'ts-jest';
+
+const config: JestConfigWithTsJest = {
+  verbose: true,
+  collectCoverage: false,
+  errorOnDeprecated: true,
+  maxWorkers: 1,
+  testMatch: [
+    '**/__tests__/**/*.spec.ts'
+  ],
+  preset: 'ts-jest'
+};
+
+export default config;

package/lib/__tests__/__fmock.d.ts

@@ -0,0 +1,5 @@
+export interface Iframe {
+    [key: string]: any;
+}
+export declare function fmock(frame: Iframe): void;
+export declare function restore(tmpDir: string): void;

package/lib/index.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var poweredFileSystem = require('./powered-file-system.js');
+
+// const pfs = new PoweredFileSystem();
+// export const test = pfs.test;
+// export const stat = pfs.stat;
+// export const chmod = pfs.chmod;
+// export const chown = pfs.chown;
+// export const symlink = pfs.symlink;
+// export const copy = pfs.copy;
+// export const rename = pfs.rename;
+// export const remove = pfs.remove;
+// export const read = pfs.read;
+// export const write = pfs.write;
+// export const append = pfs.append;
+// export const readdir = pfs.readdir;
+// export const mkdir = pfs.mkdir;
+const bitmask = poweredFileSystem.PoweredFileSystem.bitmask;
+
+exports.default = poweredFileSystem.PoweredFileSystem;
+exports.bitmask = bitmask;