docs/api/file/src/component/coverage-component.js.html from MitocGroup/run-jst

docs/api/file/src/component/coverage-component.js.html
Summary

Maintainability

Test Coverage

Issues
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <base data-ice="baseUrl" href="../../../">
  <title data-ice="title">src/component/coverage-component.js | REciNK - Rethink Continuous Integration for JavaScript Applications API Document</title>
  <link type="text/css" rel="stylesheet" href="css/style.css">
  <link type="text/css" rel="stylesheet" href="css/prettify-tomorrow.css">
  <script src="script/prettify/prettify.js"></script>
  
  
  <script src="script/manual.js"></script>
</head>
<body class="layout-container" data-ice="rootContainer">

<header>
  <a href="./">Home</a>
  
  <a href="identifiers.html">Reference</a>
  <a href="source.html">Source</a>
  
  <a data-ice="repoURL" href="https://github.com/MitocGroup/recink.git" class="repo-url-github">Repository</a>
  <div class="search-box">
  <span>
    <img src="./image/search.png">
    <span class="search-input-edge"></span><input class="search-input"><span class="search-input-edge"></span>
  </span>
    <ul class="search-result"></ul>
  </div>
</header>

<nav class="navigation" data-ice="nav"><div>
  <ul>
    
  <li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/container.js~Container.html">Container</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/emitter.js~Emitter.html">Emitter</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/logger.js~Logger.html">Logger</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/recink.js~Recink.html">Recink</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-variable">V</span><span data-ice="name"><span><a href="variable/index.html#static-variable-events">events</a></span></span></li>
<li data-ice="doc"><div data-ice="dirPath" class="nav-dir-path">component</div><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/abstract-component.js~AbstractComponent.html">AbstractComponent</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/cache-component.js~CacheComponent.html">CacheComponent</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/config-based-component.js~ConfigBasedComponent.html">ConfigBasedComponent</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/coverage-component.js~CoverageComponent.html">CoverageComponent</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/dependency-based-component.js~DependencyBasedComponent.html">DependencyBasedComponent</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/emit-component.js~EmitComponent.html">EmitComponent</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/factory.js~Factory.html">Factory</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/npm-component.js~NpmComponent.html">NpmComponent</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/preprocess-component.js~PreprocessComponent.html">PreprocessComponent</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/test-component.js~TestComponent.html">TestComponent</a></span></span></li>
<li data-ice="doc"><div data-ice="dirPath" class="nav-dir-path">component/cache</div><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/cache/abstract-driver.js~AbstractDriver.html">AbstractDriver</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/cache/factory.js~Factory.html">Factory</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/cache/s3-driver.js~S3Driver.html">S3Driver</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/cache/s3-unpacked-driver.js~S3UnpackedDriver.html">S3UnpackedDriver</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/cache/void-driver.js~VoidDriver.html">VoidDriver</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-variable">V</span><span data-ice="name"><span><a href="variable/index.html#static-variable-events">events</a></span></span></li>
<li data-ice="doc"><div data-ice="dirPath" class="nav-dir-path">component/coverage</div><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/coverage/abstract-driver.js~AbstractDriver.html">AbstractDriver</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/coverage/factory.js~Factory.html">Factory</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/coverage/s3-driver.js~S3Driver.html">S3Driver</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/coverage/volatile-driver.js~VolatileDriver.html">VolatileDriver</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-variable">V</span><span data-ice="name"><span><a href="variable/index.html#static-variable-events">events</a></span></span></li>
<li data-ice="doc"><div data-ice="dirPath" class="nav-dir-path">component/emit</div><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/emit/emit-module.js~EmitModule.html">EmitModule</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-variable">V</span><span data-ice="name"><span><a href="variable/index.html#static-variable-events">events</a></span></span></li>
<li data-ice="doc"><div data-ice="dirPath" class="nav-dir-path">component/helper</div><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/helper/aws-credentials.js~AwsCredentials.html">AwsCredentials</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/helper/container-transformer.js~ContainerTransformer.html">ContainerTransformer</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/helper/module-compile.js~ModuleCompile.html">ModuleCompile</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/helper/sequential-promise.js~SequentialPromise.html">SequentialPromise</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/helper/spinner.js~Spinner.html">Spinner</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/helper/transformer.js~Transformer.html">Transformer</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-function">F</span><span data-ice="name"><span><a href="function/index.html#static-function-patterntransformer">patterntransformer</a></span></span></li>
<li data-ice="doc"><div data-ice="dirPath" class="nav-dir-path">component/npm</div><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/npm/cache.js~Cache.html">Cache</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/npm/npm-module.js~NpmModule.html">NpmModule</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-variable">V</span><span data-ice="name"><span><a href="variable/index.html#static-variable-events">events</a></span></span></li>
<li data-ice="doc"><div data-ice="dirPath" class="nav-dir-path">component/preprocess</div><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/preprocess/abstract-transformer.js~AbstractTransformer.html">AbstractTransformer</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/preprocess/eval-transformer.js~EvalTransformer.html">EvalTransformer</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/preprocess/factory.js~Factory.html">Factory</a></span></span></li>
<li data-ice="doc"><div data-ice="dirPath" class="nav-dir-path">component/test</div><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/component/test/unit-runner.js~UnitRunner.html">UnitRunner</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-variable">V</span><span data-ice="name"><span><a href="variable/index.html#static-variable-events">events</a></span></span></li>
<li data-ice="doc"><div data-ice="dirPath" class="nav-dir-path">config</div><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/config/abstract-config.js~AbstractConfig.html">AbstractConfig</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/config/factory.js~Factory.html">Factory</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/config/yaml-config.js~YamlConfig.html">YamlConfig</a></span></span></li>
<li data-ice="doc"><div data-ice="dirPath" class="nav-dir-path">helper</div><span data-ice="kind" class="kind-class">C</span><span data-ice="name"><span><a href="class/src/helper/env.js~Env.html">Env</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-function">F</span><span data-ice="name"><span><a href="function/index.html#static-function-fillString">fillString</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-function">F</span><span data-ice="name"><span><a href="function/index.html#static-function-findFilesByPattern">findFilesByPattern</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-function">F</span><span data-ice="name"><span><a href="function/index.html#static-function-trimBoth">trimBoth</a></span></span></li>
<li data-ice="doc"><span data-ice="kind" class="kind-function">F</span><span data-ice="name"><span><a href="function/index.html#static-function-versionCompare">versionCompare</a></span></span></li>
</ul>
</div>
</nav>

<div class="content" data-ice="content"><h1 data-ice="title">src/component/coverage-component.js</h1>
<pre class="source-code line-number raw-source-code"><code class="prettyprint linenums" data-ice="content">&apos;use strict&apos;;

/* eslint no-useless-call: 0 */

const DependencyBasedComponent = require(&apos;./dependency-based-component&apos;);
const istanbul = require(&apos;istanbul&apos;);
const testEvents = require(&apos;./test/events&apos;);
const events = require(&apos;./coverage/events&apos;);
const ContainerTransformer = require(&apos;./helper/container-transformer&apos;);
const path = require(&apos;path&apos;);
const fs = require(&apos;fs&apos;);
const pify = require(&apos;pify&apos;);
const StorageFactory = require(&apos;./coverage/factory&apos;);
const ModuleCompile = require(&apos;./helper/module-compile&apos;);

/**
 * Coverage component
 */
class CoverageComponent extends DependencyBasedComponent {
  /**
   * @param {*} args
   */
  constructor(...args) {
    super(...args);
    
    this._storage = null;
  }
  
  /**
   * @returns {string}
   */
  get name() {
    return &apos;coverage&apos;;
  }
  
  /**
   * @returns {string[]}
   */
  get dependencies() {
    return [ &apos;test&apos; ];
  }
  
  /**
   * @returns {AbstractDriver}
   *
   * @private
   */
  get _comparatorStorage() {
    if (this._storage) {
      return this._storage;
    }
    
    const driver = this.container.get(&apos;compare.storage.driver&apos;, &apos;volatile&apos;);
    const options = this.container.get(&apos;compare.storage.options&apos;, []);
    
    this._storage = StorageFactory.create(driver, ...options);
    
    return this._storage;
  }
  
  /**
   * @param {istanbul.Collector} collector
   *
   * @returns {Promise}
   * 
   * @private
   */
  _doCompare(collector) {
    const allowedDelta = Math.abs(parseFloat(
      this.container.get(&apos;compare.negative-delta&apos;, 100)
    ));
    
    if (!allowedDelta || allowedDelta &gt;= 100) {
      return Promise.resolve();
    }
    
    const storage = this._comparatorStorage;
    
    if (storage.constructor.name === &apos;VolatileDriver&apos;) {
      this.logger.debug(
        `Coverage stored in ${ storage._storageFile(CoverageComponent.COVERAGE_FILE) }`
      );
    }
    
    return storage.read(CoverageComponent.COVERAGE_FILE)
      .then(coverage =&gt; {
        const newCoverage = collector.getFinalCoverage();
        
        if (!coverage) {
          this.logger.info(
            this.logger.emoji.bicycle,
            &apos;No previous coverage info saved...&apos;
          );
          
          return storage.write(
            CoverageComponent.COVERAGE_FILE, 
            newCoverage
          );
        }
        
        const delta = this._calculateDelta(coverage, newCoverage);
        
        if (delta &gt; allowedDelta) {          
          return Promise.reject(new Error(
            `Coverage delta decreased ${ delta.toFixed(2) } &gt; ${ allowedDelta.toFixed(2) }`
          ));
        }
        
        this.logger.info(
          this.logger.emoji.bicycle,
          `Coverage delta checked ${ delta.toFixed(2) } &gt;= ${ allowedDelta.toFixed(2) }`
        );
        
        return storage.write(
          CoverageComponent.COVERAGE_FILE, 
          newCoverage
        );
      });
  }
  
  /**
   * @param {*} coverage
   * @param {*} newCoverage
   *
   * @returns {number}
   *
   * @private
   */
  _calculateDelta(coverage, newCoverage) {
    const summary = this._summarizeCoverage(coverage);
    const newSummary = this._summarizeCoverage(newCoverage);
    
    return CoverageComponent.COVERAGE_KEYS
      .reduce((accumulator, key) =&gt; {
        return accumulator + 
          parseFloat(summary[key]) - 
          parseFloat((newSummary[key] || 0));
      }, 0) / CoverageComponent.COVERAGE_KEYS.length;
  }
  
  /**
   * @param {*} coverage
   *
   * @returns {*}
   *
   * @private
   */
  _summarizeCoverage(coverage) {
    const summary = {};
    
    const summaries = Object.keys(coverage)
      .map(file =&gt; {
        return istanbul.utils
          .summarizeFileCoverage(coverage[file]);
      });
    
    const summaryObj = istanbul.utils
      .mergeSummaryObjects
      .apply(null, summaries);
    
    Object.keys(summaryObj)
      .map(key =&gt; {
        summary[key] = summaryObj[key].pct;
      });
      
    return summary;
  }
  
  /**
   * @param {*} assetsToInstrument
   * @param {*} dispatchedAssets
   * @param {EmitModule} module
   *
   * @returns {Promise}
   * 
   * @private
   */
  _persistModuleBlankCoverage(assetsToInstrument, dispatchedAssets, module) {
    if (!assetsToInstrument[module.name]) {
      return Promise.resolve();
    }
    
    const coverageVariable = this._coverageVariable(module);
    
    return Promise.all(
      assetsToInstrument[module.name]
        .filter(asset =&gt; {
          return (dispatchedAssets[module.name] || []).indexOf(asset) === -1;
        })
        .map(asset =&gt; {
          return pify(fs.readFile)(asset)
            .then(content =&gt; {
              const instrumenter = new istanbul.Instrumenter({ coverageVariable });

              instrumenter.instrumentSync(
                content.toString(), 
                asset
              );
              
              global[coverageVariable] = global[coverageVariable] || {};
              global[coverageVariable][asset] = instrumenter.lastFileCoverage();

              return Promise.resolve();  
            });
        })
    );
  }
  
  /**
   * @param {Emitter} emitter
   * @returns {Promise}
   * @todo split into several abstractions
   */
  run(emitter) {
    return new Promise((resolve, reject) =&gt; {
      const collector = new istanbul.Collector();
      const reporter = new istanbul.Reporter();
      const reporters = this.container.get(&apos;reporters&apos;, {});
      const coverageVariables = [];
      const assetsToInstrument = {};
      const dispatchedAssets = {};
      
      Object.keys(reporters).map(reporterName =&gt; {
        reporter.reports[reporterName] = istanbul.Report.create(reporterName, reporters[reporterName] || {});
      });
      
      emitter.onBlocking(testEvents.asset.test.skip, payload =&gt; {
        if (!this._match(payload.file)) {
          return Promise.resolve();
        }
        
        const { module, fileAbs } = payload;
        
        assetsToInstrument[module.name] = assetsToInstrument[module.name] || [];
        assetsToInstrument[module.name].push(fileAbs);
        
        return Promise.resolve();
      });
      
      emitter.onBlocking(testEvents.asset.tests.end, (mocha, module) =&gt; {
        return this._persistModuleBlankCoverage(assetsToInstrument, dispatchedAssets, module).then(() =&gt; {
          delete assetsToInstrument[module.name];
          delete dispatchedAssets[module.name];
          
          return Promise.resolve();
        });
      });
      
      emitter.onBlocking(testEvents.asset.tests.start, (mocha, module) =&gt; {
        return new Promise(resolve =&gt; {
          const instrumenterCache = {};
          const coverageVariable = this._coverageVariable(module);
          const instrumenter = new istanbul.Instrumenter({ coverageVariable });
          
          coverageVariables.push(coverageVariable);
          
          if (mocha) {
            mocha.loadFiles = (fn =&gt; {
              const self = this;
              const moduleRoot = module.container.get(&apos;root&apos;);
              const coverableAssets = assetsToInstrument[module.name] || [];

              const preprocessor = (source, filename) =&gt; {
                if (coverableAssets.indexOf(filename) !== -1
                  &amp;&amp; self._match(path.relative(moduleRoot, filename))) {

                  if (instrumenterCache.hasOwnProperty(filename)) {
                    return instrumenterCache[filename];
                  }
                  
                  instrumenterCache[filename] = instrumenter.instrumentSync.call(instrumenter, source, filename);
                  dispatchedAssets[module.name] = dispatchedAssets[module.name] || [];
                  dispatchedAssets[module.name].push(filename);
                  
                  return instrumenterCache[filename];
                }
                
                return source;
              };
              
              mocha.files.map(file =&gt; {
                file = path.resolve(file);
                
                mocha.suite.emit(&apos;pre-require&apos;, global, file, mocha);
                mocha.suite.emit(&apos;require&apos;, ModuleCompile.require(file, {}, preprocessor), file, mocha);
                mocha.suite.emit(&apos;post-require&apos;, global, file, mocha);
              });
              
              fn &amp;&amp; fn();
            });
          }
          
          resolve();
        });
      });
      
      emitter.onBlocking(testEvents.assets.test.end, () =&gt; {        
        coverageVariables.map(coverageVariable =&gt; {
          collector.add(global[coverageVariable] || {});
        });
        
        return emitter.emitBlocking(events.coverage.report.create, istanbul, reporter, collector)
          .then(() =&gt; this._dumpCoverageStats(collector, reporter))
          .then(() =&gt; emitter.emitBlocking(events.coverage.report.compare, istanbul, reporter, collector))
          .then(() =&gt; this._doCompare(collector));
      });
      
      emitter.on(testEvents.assets.test.end, () =&gt; resolve());
    });
  }
  
  /**
   * @param {istanbul.Collector} collector
   * @param {istanbul.Reporter} reporter
   *
   * @returns {Promise}
   * 
   * @private
   */
  _dumpCoverageStats(collector, reporter) {
    return new Promise(resolve =&gt; {
      reporter.write(collector, false, () =&gt; {
        
        // @todo find a smarter way to indent the output (buffer it?)
        process.stdout.write(&apos;\n\n&apos;);
        
        resolve();
      });
    });
  }
  
  /**
   * @param {EmitModule} module
   *
   * @returns {string}
   *
   * @private
   */
  _coverageVariable(module) {
    const cleanModuleName = module.name.replace(/[^a-z0-9]/g, &apos;_&apos;);
    
    return `__recink_coverage__${ cleanModuleName }__`;
  }
  
  /**
   * @param {string} file
   *
   * @returns {boolean}
   * 
   * @private
   */
  _match(file) {
    const pattern = this.container.get(&apos;pattern&apos;, []);
    const ignore = this.container.get(&apos;ignore&apos;, []);

    const result = pattern.filter(p =&gt; this._test(p, file)).length &gt; 0
      &amp;&amp; ignore.filter(i =&gt; this._test(i, file)).length &lt;= 0;
      
    return result;
  }
  
  /**
   * @param {string|RegExp} pattern
   * @param {string} value
   *
   * @returns {boolean}
   *
   * @private
   */
  _test(pattern, value) {
    if (!(pattern instanceof RegExp)) {
      return value.indexOf(pattern.toString()) !== -1;
    }
    
    return pattern.test(value);
  }
  
  /**
   * @param {*} config
   * @param {string} configFile
   *
   * @returns {Container}
   */
  prepareConfig(config, configFile) {
    return super.prepareConfig(config, configFile)
      .then(container =&gt; {
        return (new ContainerTransformer(container))
          .addPattern(&apos;pattern&apos;)
          .addPattern(&apos;ignore&apos;)
          .transform();
      });
  }
  
  /**
   * @returns {Array}
   */
  static get COVERAGE_KEYS() {
    return [ &apos;lines&apos;, &apos;statements&apos;, &apos;functions&apos;, &apos;branches&apos; ];
  }
  
  /**
   * @returns {string}
   */
  static get COVERAGE_FILE() {
    return &apos;coverage.json&apos;;
  }
}

module.exports = CoverageComponent;
</code></pre>

</div>

<footer class="footer">
  Generated by <a href="https://esdoc.org">ESDoc<span data-ice="esdocVersion">(0.5.2)</span><img src="./image/esdoc-logo-mini-black.png"></a>
</footer>

<script src="script/search_index.js"></script>
<script src="script/search.js"></script>
<script src="script/pretty-print.js"></script>
<script src="script/inherited-summary.js"></script>
<script src="script/test-summary.js"></script>
<script src="script/inner-link.js"></script>
<script src="script/patch-for-local.js"></script>
</body>
</html>