Move coverage to independent module

dgolovin · dgolovin · commit 246bc1a44e6e · 2019-09-05T19:33:45.000-07:00
diff --git a/test/integration/index.coverage.ts b/test/integration/index.coverage.ts
@@ -5,17 +5,15 @@
 
 'use strict';
 
-declare var global: any;
-
 /* tslint:disable no-require-imports */
 
 import * as fs from 'fs';
 import * as glob from 'glob';
 import * as paths from 'path';
+import Mocha = require('mocha');
+import { ITestRunnerOptions, CoverageRunner } from '../coverage';
 
-const istanbul = require('istanbul');
-const Mocha = require('mocha');
-const remapIstanbul = require('remap-istanbul');
+declare var global: any;
 
 // Linux: prevent a weird NPE when mocha on Linux requires the window size from the TTY
 // Since we are not running in a tty environment, we just implement the method statically
@@ -25,10 +23,11 @@ if (!tty.getWindowSize) {
         return [80, 75];
     };
 }
-const config = {
+
+const config: Mocha.MochaOptions = {
     reporter: 'mocha-jenkins-reporter',
     ui: 'tdd',
-    color: true,
+    useColors: true,
     timeout: 15000
 };
 
@@ -43,12 +42,6 @@ function configure(mochaOpts: any): void {
 }
 exports.configure = configure;
 
-function _mkDirIfExists(dir: string): void {
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir);
-    }
-}
-
 function _readCoverOptions(testsRoot: string): ITestRunnerOptions | undefined {
     const coverConfigPath = paths.join(testsRoot, '..', '..', '..', 'coverconfig.json');
     console.log("coverage config location", coverConfigPath);
@@ -59,18 +52,16 @@ function _readCoverOptions(testsRoot: string): ITestRunnerOptions | undefined {
     return undefined;
 }
 
-function run(testsRoot1: string, clb: any): any {
-     return new Promise( (c, e) => { // Glob test files
-           // Read configuration for the coverage file
-    const testsRoot = paths.resolve(__dirname);
-    const coverOptions = _readCoverOptions(testsRoot);
-    let coverageRunner;
-    if (coverOptions && coverOptions.enabled) {
-        console.log('coverage enabled!');
-        // Setup coverage pre-test, including post-test hook to report
-        coverageRunner = new CoverageRunner(coverOptions, testsRoot);
-        coverageRunner.setupCoverage();
-    }
+function run(): any {
+     return new Promise( (c, e) => {
+        const testsRoot = paths.resolve(__dirname);
+        const coverOptions = _readCoverOptions(testsRoot);
+        let coverageRunner;
+        if (coverOptions && coverOptions.enabled) {
+            console.log('coverage enabled!');
+            coverageRunner = new CoverageRunner(coverOptions, testsRoot);
+            coverageRunner.setupCoverage();
+        }
         glob('**/**.test.js', { cwd: testsRoot }, (error, files): any => {
             if (error) {
                 return e(error);
@@ -95,137 +86,4 @@ function run(testsRoot1: string, clb: any): any {
         });
     });
 }
-exports.run = run;
-
-interface ITestRunnerOptions {
-    enabled?: boolean;
-    relativeCoverageDir: string;
-    relativeSourcePath: string;
-    ignorePatterns: string[];
-    includePid?: boolean;
-    reports?: string[];
-    verbose?: boolean;
-}
-
-class CoverageRunner {
-
-    private coverageVar: string = `$$cov_${new Date().getTime()}$$`;
-    private transformer: any = undefined;
-    private matchFn: any = undefined;
-    private instrumenter: any = undefined;
-
-    constructor(private options: ITestRunnerOptions, private testsRoot: string) {
-        if (!options.relativeSourcePath) {
-            return;
-        }
-    }
-
-    public setupCoverage(): void {
-        // Set up Code Coverage, hooking require so that instrumented code is returned
-        const self = this;
-        self.instrumenter = new istanbul.Instrumenter({ coverageVariable: self.coverageVar });
-        const sourceRoot = paths.join(self.testsRoot, self.options.relativeSourcePath);
-
-        // Glob source files
-        const srcFiles = glob.sync('**/**.js', {
-            cwd: sourceRoot,
-            ignore: self.options.ignorePatterns
-        });
-
-        // Create a match function - taken from the run-with-cover.js in istanbul.
-        const decache = require('decache');
-        const fileMap: any = {};
-        srcFiles.forEach((file) => {
-            const fullPath = paths.join(sourceRoot, file);
-            fileMap[fullPath] = true;
-
-            // On Windows, extension is loaded pre-test hooks and this mean we lose
-            // our chance to hook the Require call. In order to instrument the code
-            // we have to decache the JS file so on next load it gets instrumented.
-            // This doesn't impact tests, but is a concern if we had some integration
-            // tests that relied on VSCode accessing our module since there could be
-            // some shared global state that we lose.
-            decache(fullPath);
-        });
-
-        self.matchFn = (file: string): boolean => fileMap[file];
-        self.matchFn.files = Object.keys(fileMap);
-
-        // Hook up to the Require function so that when this is called, if any of our source files
-        // are required, the instrumented version is pulled in instead. These instrumented versions
-        // write to a global coverage variable with hit counts whenever they are accessed
-        self.transformer = self.instrumenter.instrumentSync.bind(self.instrumenter);
-        const hookOpts = { verbose: true, extensions: ['.js'] };
-        istanbul.hook.hookRequire(self.matchFn, self.transformer, hookOpts);
-
-        // initialize the global variable to stop mocha from complaining about leaks
-        global[self.coverageVar] = {};
-    }
-
-    /**
-     * Writes a coverage report.
-     * Note that as this is called in the process exit callback, all calls must be synchronous.
-     *
-     * @returns {void}
-     *
-     * @memberOf CoverageRunner
-     */
-    public reportCoverage(): void {
-        const self = this;
-        istanbul.hook.unhookRequire();
-        let cov: any;
-        if (typeof global[self.coverageVar] === 'undefined' || Object.keys(global[self.coverageVar]).length === 0) {
-            console.error('No coverage information was collected, exit without writing coverage information');
-            return;
-        } else {
-            cov = global[self.coverageVar];
-        }
-
-        // TODO consider putting this under a conditional flag
-        // Files that are not touched by code ran by the test runner is manually instrumented, to
-        // illustrate the missing coverage.
-        self.matchFn.files.forEach((file: any) => {
-            if (cov[file]) {
-                return;
-            }
-            self.transformer(fs.readFileSync(file, 'utf-8'), file);
-
-            // When instrumenting the code, istanbul will give each FunctionDeclaration a value of 1 in coverState.s,
-            // presumably to compensate for function hoisting. We need to reset this, as the function was not hoisted,
-            // as it was never loaded.
-            Object.keys(self.instrumenter.coverState.s).forEach((key) => {
-                self.instrumenter.coverState.s[key] = 0;
-            });
-
-            cov[file] = self.instrumenter.coverState;
-        });
-
-        // TODO Allow config of reporting directory with
-        const reportingDir = paths.join(self.testsRoot, self.options.relativeCoverageDir);
-        const includePid = self.options.includePid;
-        const pidExt = includePid ? ('-' + process.pid) : '';
-        const coverageFile = paths.resolve(reportingDir, `coverage${pidExt}.json`);
-
-        // yes, do this again since some test runners could clean the dir initially created
-        _mkDirIfExists(reportingDir);
-
-        fs.writeFileSync(coverageFile, JSON.stringify(cov), 'utf8');
-
-        const remappedCollector = remapIstanbul.remap(cov, {
-            warn: (warning: any) => {
-                // We expect some warnings as any JS file without a typescript mapping will cause this.
-                // By default, we'll skip printing these to the console as it clutters it up
-                if (self.options.verbose) {
-                    console.warn(warning);
-                }
-            }
-        });
-
-        const reporter = new istanbul.Reporter(undefined, reportingDir);
-        const reportTypes = (self.options.reports instanceof Array) ? self.options.reports : ['lcov'];
-        reporter.addAll(reportTypes);
-        reporter.write(remappedCollector, true, () => {
-            console.log(`reports written to ${reportingDir}`);
-        });
-    }
-}
+exports.run = run;
