fix(testlab): switch to fs-extra instead of using fs (#905)

Author: virkt25

packages/testlab/package.json

@@ -21,18 +21,17 @@
   "license": "MIT",
   "dependencies": {
     "@loopback/openapi-spec": "^4.0.0-alpha.20",
-    "@types/rimraf": "^2.0.2",
+    "@types/fs-extra": "^5.0.0",
     "@types/shot": "^3.4.0",
     "@types/sinon": "^2.3.7",
     "@types/supertest": "^2.0.0",
     "@types/swagger-parser": "^4.0.1",
-    "rimraf": "^2.6.2",
+    "fs-extra": "^5.0.0",
     "shot": "^4.0.3",
     "should": "^13.1.3",
     "sinon": "^4.1.2",
     "supertest": "^3.0.0",
-    "swagger-parser": "^4.0.1",
-    "util.promisify": "^1.0.0"
+    "swagger-parser": "^4.0.1"
   },
   "devDependencies": {
     "@loopback/build": "^4.0.0-alpha.9"

packages/testlab/src/test-sandbox.ts

@@ -7,27 +7,7 @@ import {tmpdir} from 'os';
 import {createHash} from 'crypto';
 import {resolve, join, parse} from 'path';
 import * as util from 'util';
-import {mkdirSync, existsSync, mkdir, copyFile, readFile, writeFile} from 'fs';
-const promisify = util.promisify || require('util.promisify/implementation');
-const rimrafAsync = promisify(require('rimraf'));
-const mkdirAsync = promisify(mkdir);
-
-// tslint:disable-next-line:no-any
-let copyFileAsync: any;
-if (copyFile) {
-  copyFileAsync = promisify(copyFile);
-} else {
-  /**
-   * Taranveer: fs.copyFile wasn't made available till Node 8.5.0. As such this
-   * polyfill is needed for versions of Node prior to that.
-   */
-  copyFileAsync = async function(src: string, target: string) {
-    const readFileAsync = promisify(readFile);
-    const writeFileAsync = promisify(writeFile);
-    const data = await readFileAsync(src);
-    await writeFileAsync(target, data);
-  };
-}
+import {copy, ensureDirSync, emptyDir, remove, ensureDir} from 'fs-extra';
 
 /**
  * TestSandbox class provides a convenient way to get a reference to a
@@ -46,18 +26,7 @@ export class TestSandbox {
   constructor(path: string) {
     // resolve ensures path is absolute / makes it absolute (relative to cwd())
     this.path = resolve(path);
-    // Create directory if it doesn't already exist.
-    if (!existsSync(this.path)) {
-      this.create();
-    }
-  }
-
-  /**
-   * Syncronously creates the TestSandbox directory. It is syncronous because
-   * it is called by the constructor.
-   */
-  private create(): void {
-    mkdirSync(this.path);
+    ensureDirSync(this.path);
   }
 
   /**
@@ -84,16 +53,15 @@ export class TestSandbox {
    */
   async reset(): Promise<void> {
     this.validateInst();
-    await rimrafAsync(this.path);
-    this.create();
+    await emptyDir(this.path);
   }
 
   /**
    * Deletes the TestSandbox.
    */
   async delete(): Promise<void> {
     this.validateInst();
-    await rimrafAsync(this.path);
+    await remove(this.path);
     delete this.path;
   }
 
@@ -103,7 +71,7 @@ export class TestSandbox {
    */
   async mkdir(dir: string): Promise<void> {
     this.validateInst();
-    await mkdirAsync(resolve(this.path, dir));
+    await ensureDir(resolve(this.path, dir));
   }
 
   /**
@@ -112,11 +80,11 @@ export class TestSandbox {
    * @param [dest] Optional. Destination filename of the copy operation
    * (relative to TestSandbox). Original filename used if not specified.
    */
-  async copy(src: string, dest?: string): Promise<void> {
+  async copyFile(src: string, dest?: string): Promise<void> {
     this.validateInst();
     dest = dest
       ? resolve(this.path, dest)
       : resolve(this.path, parse(src).base);
-    await copyFileAsync(src, dest);
+    await copy(src, dest);
   }
 }

packages/testlab/test/integration/test-sandbox.integration.ts

@@ -4,13 +4,10 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {TestSandbox, expect} from '../..';
-import {existsSync, readFile as readFile_} from 'fs';
 import {resolve} from 'path';
 import {createHash} from 'crypto';
 import * as util from 'util';
-const promisify = util.promisify || require('util.promisify/implementation');
-const rimraf = require('rimraf');
-const readFile = promisify(readFile_);
+import {remove, pathExists, readFile} from 'fs-extra';
 
 describe('TestSandbox integration tests', () => {
   let sandbox: TestSandbox;
@@ -28,43 +25,43 @@ describe('TestSandbox integration tests', () => {
   beforeEach(givenPath);
   afterEach(deleteSandbox);
 
-  it('returns path of sandbox and it exists', () => {
+  it('returns path of sandbox and it exists', async () => {
     expect(path).to.be.a.String();
-    expect(existsSync(path)).to.be.True();
+    expect(await pathExists(path)).to.be.True();
   });
 
   it('creates a directory in the sandbox', async () => {
     const dir = 'controllers';
     await sandbox.mkdir(dir);
-    expect(existsSync(resolve(path, dir))).to.be.True();
+    expect(await pathExists(resolve(path, dir))).to.be.True();
   });
 
   it('copies a file to the sandbox', async () => {
-    await sandbox.copy(COPY_FILE_PATH);
-    expect(existsSync(resolve(path, COPY_FILE))).to.be.True();
+    await sandbox.copyFile(COPY_FILE_PATH);
+    expect(await pathExists(resolve(path, COPY_FILE))).to.be.True();
     await compareFiles(resolve(path, COPY_FILE));
   });
 
   it('copies and renames the file to the sandbox', async () => {
     const rename = 'copy.me.js';
-    await sandbox.copy(COPY_FILE_PATH, rename);
-    expect(existsSync(resolve(path, COPY_FILE))).to.be.False();
-    expect(existsSync(resolve(path, rename))).to.be.True();
+    await sandbox.copyFile(COPY_FILE_PATH, rename);
+    expect(await pathExists(resolve(path, COPY_FILE))).to.be.False();
+    expect(await pathExists(resolve(path, rename))).to.be.True();
     await compareFiles(resolve(path, rename));
   });
 
   it('copies file to a directory', async () => {
     const dir = 'test';
     await sandbox.mkdir(dir);
     const rename = `${dir}/${COPY_FILE}`;
-    await sandbox.copy(COPY_FILE_PATH, rename);
-    expect(existsSync(resolve(path, rename))).to.be.True();
+    await sandbox.copyFile(COPY_FILE_PATH, rename);
+    expect(await pathExists(resolve(path, rename))).to.be.True();
     await compareFiles(resolve(path, rename));
   });
 
   it('deletes the test sandbox', async () => {
     await sandbox.delete();
-    expect(existsSync(path)).to.be.False();
+    expect(await pathExists(path)).to.be.False();
   });
 
   describe('after deleting sandbox', () => {
@@ -82,7 +79,7 @@ describe('TestSandbox integration tests', () => {
     });
 
     it('throws an error when trying to call copy()', async () => {
-      await expect(sandbox.copy(COPY_FILE_PATH)).to.be.rejectedWith(ERR);
+      await expect(sandbox.copyFile(COPY_FILE_PATH)).to.be.rejectedWith(ERR);
     });
 
     it('throws an error when trying to call reset()', async () => {
@@ -111,13 +108,9 @@ describe('TestSandbox integration tests', () => {
     path = sandbox.getPath();
   }
 
-  function deleteSandbox() {
-    if (!existsSync(path)) return;
-    try {
-      rimraf.sync(sandbox.getPath());
-    } catch (err) {
-      console.log(`Failed to delete sandbox because: ${err}`);
-    }
+  async function deleteSandbox() {
+    if (!await pathExists(path)) return;
+    await remove(sandbox.getPath());
   }
 
   async function getCopyFileContents() {