fix(reporter): update calls to match new API in istanbul-lib-report fix #398 (#403)

BREAKING CHANGES: major dependencies are updated

Author: anthony-redFox

lib/in-memory-report.js

@@ -1,5 +1,8 @@
-class InMemoryReport {
+const { ReportBase } = require('istanbul-lib-report')
+
+class InMemoryReport extends ReportBase {
   constructor (opt) {
+    super(opt)
     this.opt = opt
   }
 

lib/reporter.js

@@ -218,11 +218,11 @@ var CoverageReporter = function (rootConfig, helper, logger, emitter) {
     coverageMap.merge(result.coverage)
   }
 
-  this.onRunComplete = function (browsers, results) {
+  this.onRunComplete = async function (browsers, results) {
     const checkedCoverage = {}
 
     for (const reporterConfig of reporters) {
-      browsers.forEach(function (browser) {
+      await Promise.all(browsers.map(async (browser) => {
         const coverageMap = coverageMaps[browser.id]
         if (!coverageMap) {
           return
@@ -231,14 +231,15 @@ var CoverageReporter = function (rootConfig, helper, logger, emitter) {
         const mainDir = reporterConfig.dir || config.dir
         const subDir = reporterConfig.subdir || config.subdir
         const outputPath = generateOutputPath(basePath, browser.name, mainDir, subDir)
+        const remappedCoverageMap = await sourceMapStore.transformCoverage(coverageMap)
 
         const options = helper.merge(config, reporterConfig, {
           dir: outputPath,
           subdir: '',
           browser: browser,
-          emitter: emitter
+          emitter: emitter,
+          coverageMap: remappedCoverageMap
         })
-        const remappedCoverageMap = sourceMapStore.transformCoverage(coverageMap).map
 
         // If config.check is defined, check coverage levels for each browser
         if (hasOwnProperty.call(config, 'check') && !checkedCoverage[browser.id]) {
@@ -250,22 +251,21 @@ var CoverageReporter = function (rootConfig, helper, logger, emitter) {
         }
 
         const context = istanbulLibReport.createContext(options)
-        const tree = istanbulLibReport.summarizers.pkg(remappedCoverageMap)
         const report = reports.create(reporterConfig.type || 'html', options)
 
         // // If reporting to console or in-memory skip directory creation
         const toDisk = !reporterConfig.type || !reporterConfig.type.match(/^(text|text-summary|in-memory)$/)
 
         if (!toDisk && reporterConfig.file === undefined) {
-          tree.visit(report, context)
+          report.execute(context)
           return
         }
 
         helper.mkdirIfNotExists(outputPath, function () {
           log.debug('Writing coverage to %s', outputPath)
-          tree.visit(report, context)
+          report.execute(context)
         })
-      })
+      }))
     }
   }
 

package-lock.json

@@ -19,12 +19,12 @@
   ],
   "author": "SATO taichi <ryushi@gmail.com>",
   "dependencies": {
-    "istanbul-lib-coverage": "^2.0.5",
-    "istanbul-lib-instrument": "^3.3.0",
-    "istanbul-lib-report": "^2.0.8",
-    "istanbul-lib-source-maps": "^3.0.6",
-    "istanbul-reports": "^2.2.4",
-    "minimatch": "^3.0.0"
+    "istanbul-lib-coverage": "^3.0.0",
+    "istanbul-lib-instrument": "^4.0.1",
+    "istanbul-lib-report": "^3.0.0",
+    "istanbul-lib-source-maps": "^4.0.0",
+    "istanbul-reports": "^3.0.0",
+    "minimatch": "^3.0.4"
   },
   "license": "MIT",
   "devDependencies": {

package.json

@@ -44,7 +44,6 @@ describe('reporter', () => {
   let createCoverageSummaryStub = null
   let createCoverageMapStub = null
   let createContextStub = null
-  let packageSummaryStub = null
   let getDefaultWatermarkStub = null
   let sourceMapStoreGetStub = null
   let globalCoverageMapGetStub = null
@@ -82,19 +81,14 @@ describe('reporter', () => {
       functions: [50, 80],
       lines: [50, 80]
     }
-    mockPackageSummary = {
-      visit: sinon.stub()
-    }
     createContextStub = sinon.stub(istanbulLibReport, 'createContext')
-    packageSummaryStub = sinon.stub(istanbulLibReport.summarizers, 'pkg')
-    packageSummaryStub.returns(mockPackageSummary)
     getDefaultWatermarkStub = sinon.stub(istanbulLibReport, 'getDefaultWatermarks')
     getDefaultWatermarkStub.returns(mockDefaultWatermarks)
 
     mockSourceMapStore = {
       transformCoverage: sinon.stub()
     }
-    mockSourceMapStore.transformCoverage.returns({ map: mockCoverageMap })
+    mockSourceMapStore.transformCoverage.resolves(mockCoverageMap)
     sourceMapStoreGetStub = sinon.stub(globalSourceMapStore, 'get')
     sourceMapStoreGetStub.returns(mockSourceMapStore)
 
@@ -103,7 +97,9 @@ describe('reporter', () => {
     globalCoverageMapGetStub.returns(mockGlobalCoverageMap)
     sinon.stub(globalCoverageMap, 'add')
 
+    mockPackageSummary = { execute: sinon.stub() }
     reportCreateStub = sinon.stub(reports, 'create')
+    reportCreateStub.returns(mockPackageSummary)
 
     m = loadFile(path.join(__dirname, '/../lib/reporter.js'), mocks)
   })
@@ -162,22 +158,22 @@ describe('reporter', () => {
       expect(mockCoverageMap.merge).not.to.have.been.called
     })
 
-    it('should make reports', () => {
-      reporter.onRunComplete(browsers)
+    it('should make reports', async () => {
+      await reporter.onRunComplete(browsers)
       expect(mkdirIfNotExistsStub).to.have.been.calledTwice
       const dir = rootConfig.coverageReporter.dir
       expect(mkdirIfNotExistsStub.getCall(0).args[0]).to.deep.equal(resolve('/base', dir, fakeChrome.name))
       expect(mkdirIfNotExistsStub.getCall(1).args[0]).to.deep.equal(resolve('/base', dir, fakeOpera.name))
       mkdirIfNotExistsStub.getCall(0).args[1]()
       expect(reportCreateStub).to.have.been.called
-      expect(mockPackageSummary.visit).to.have.been.called
+      expect(mockPackageSummary.execute).to.have.been.called
       const createArgs = reportCreateStub.getCall(0).args
       expect(createArgs[0]).to.be.equal('html')
       expect(createArgs[1].browser).to.be.equal(fakeChrome)
       expect(createArgs[1].emitter).to.be.equal(emitter)
     })
 
-    it('should support a string for the subdir option', () => {
+    it('should support a string for the subdir option', async () => {
       const customConfig = helper.merge({}, rootConfig, {
         coverageReporter: {
           subdir: 'test'
@@ -188,18 +184,18 @@ describe('reporter', () => {
       reporter.onRunStart()
       browsers.forEach(b => reporter.onBrowserStart(b))
 
-      reporter.onRunComplete(browsers)
+      await reporter.onRunComplete(browsers)
       expect(mkdirIfNotExistsStub).to.have.been.calledTwice
       const dir = customConfig.coverageReporter.dir
       const subdir = customConfig.coverageReporter.subdir
       expect(mkdirIfNotExistsStub.getCall(0).args[0]).to.deep.equal(resolve('/base', dir, subdir))
       expect(mkdirIfNotExistsStub.getCall(1).args[0]).to.deep.equal(resolve('/base', dir, subdir))
       mkdirIfNotExistsStub.getCall(0).args[1]()
       expect(reportCreateStub).to.have.been.called
-      expect(mockPackageSummary.visit).to.have.been.called
+      expect(mockPackageSummary.execute).to.have.been.called
     })
 
-    it('should support a function for the subdir option', () => {
+    it('should support a function for the subdir option', async () => {
       const customConfig = helper.merge({}, rootConfig, {
         coverageReporter: {
           subdir: (browserName) => browserName.toLowerCase().split(/[ /-]/)[0]
@@ -210,17 +206,17 @@ describe('reporter', () => {
       reporter.onRunStart()
       browsers.forEach(b => reporter.onBrowserStart(b))
 
-      reporter.onRunComplete(browsers)
+      await reporter.onRunComplete(browsers)
       expect(mkdirIfNotExistsStub).to.have.been.calledTwice
       const dir = customConfig.coverageReporter.dir
       expect(mkdirIfNotExistsStub.getCall(0).args[0]).to.deep.equal(resolve('/base', dir, 'chrome'))
       expect(mkdirIfNotExistsStub.getCall(1).args[0]).to.deep.equal(resolve('/base', dir, 'opera'))
       mkdirIfNotExistsStub.getCall(0).args[1]()
       expect(reportCreateStub).to.have.been.called
-      expect(mockPackageSummary.visit).to.have.been.called
+      expect(mockPackageSummary.execute).to.have.been.called
     })
 
-    it('should support a specific dir and subdir per reporter', () => {
+    it('should support a specific dir and subdir per reporter', async () => {
       const customConfig = helper.merge({}, rootConfig, {
         coverageReporter: {
           dir: 'useless',
@@ -242,18 +238,18 @@ describe('reporter', () => {
       reporter.onRunStart()
       browsers.forEach(b => reporter.onBrowserStart(b))
 
-      reporter.onRunComplete(browsers)
+      await reporter.onRunComplete(browsers)
       expect(mkdirIfNotExistsStub.callCount).to.equal(4)
       expect(mkdirIfNotExistsStub.getCall(0).args[0]).to.deep.equal(resolve('/base', 'reporter1', 'chrome'))
       expect(mkdirIfNotExistsStub.getCall(1).args[0]).to.deep.equal(resolve('/base', 'reporter1', 'opera'))
       expect(mkdirIfNotExistsStub.getCall(2).args[0]).to.deep.equal(resolve('/base', 'reporter2', 'CHROME'))
       expect(mkdirIfNotExistsStub.getCall(3).args[0]).to.deep.equal(resolve('/base', 'reporter2', 'OPERA'))
       mkdirIfNotExistsStub.getCall(0).args[1]()
       expect(reportCreateStub).to.have.been.called
-      expect(mockPackageSummary.visit).to.have.been.called
+      expect(mockPackageSummary.execute).to.have.been.called
     })
 
-    it('should fallback to the default dir/subdir if not provided', () => {
+    it('should fallback to the default dir/subdir if not provided', async () => {
       const customConfig = helper.merge({}, rootConfig, {
         coverageReporter: {
           dir: 'defaultdir',
@@ -273,48 +269,48 @@ describe('reporter', () => {
       reporter.onRunStart()
       browsers.forEach(b => reporter.onBrowserStart(b))
 
-      reporter.onRunComplete(browsers)
+      await reporter.onRunComplete(browsers)
       expect(mkdirIfNotExistsStub.callCount).to.equal(4)
       expect(mkdirIfNotExistsStub.getCall(0).args[0]).to.deep.equal(resolve('/base', 'reporter1', 'defaultsubdir'))
       expect(mkdirIfNotExistsStub.getCall(1).args[0]).to.deep.equal(resolve('/base', 'reporter1', 'defaultsubdir'))
       expect(mkdirIfNotExistsStub.getCall(2).args[0]).to.deep.equal(resolve('/base', 'defaultdir', 'CHROME'))
       expect(mkdirIfNotExistsStub.getCall(3).args[0]).to.deep.equal(resolve('/base', 'defaultdir', 'OPERA'))
       mkdirIfNotExistsStub.getCall(0).args[1]()
       expect(reportCreateStub).to.have.been.called
-      expect(mockPackageSummary.visit).to.have.been.called
+      expect(mockPackageSummary.execute).to.have.been.called
     })
 
-    it('should not create directory if reporting text* to console', () => {
+    it('should not create directory if reporting text* to console', async () => {
       const run = () => {
         reporter = new m.CoverageReporter(rootConfig, mockHelper, mockLogger)
         reporter.onRunStart()
         browsers.forEach(b => reporter.onBrowserStart(b))
-        reporter.onRunComplete(browsers)
+        return reporter.onRunComplete(browsers)
       }
 
       rootConfig.coverageReporter.reporters = [
         { type: 'text' },
         { type: 'text-summary' }
       ]
-      run()
+      await run()
       expect(mkdirIfNotExistsStub).not.to.have.been.called
     })
 
-    it('should create directory if reporting text* to file', () => {
+    it('should create directory if reporting text* to file', async () => {
       const run = () => {
         reporter = new m.CoverageReporter(rootConfig, mockHelper, mockLogger)
         reporter.onRunStart()
         browsers.forEach(b => reporter.onBrowserStart(b))
-        reporter.onRunComplete(browsers)
+        return reporter.onRunComplete(browsers)
       }
 
       rootConfig.coverageReporter.reporters = [{ type: 'text', file: 'file' }]
-      run()
+      await run()
       expect(mkdirIfNotExistsStub).to.have.been.calledTwice
 
       mkdirIfNotExistsStub.resetHistory()
       rootConfig.coverageReporter.reporters = [{ type: 'text-summary', file: 'file' }]
-      run()
+      await run()
       expect(mkdirIfNotExistsStub).to.have.been.calledTwice
     })
 
@@ -370,7 +366,7 @@ describe('reporter', () => {
       expect(globalCoverageMapGetStub).not.to.have.been.called
     })
 
-    it('should pass watermarks to istanbul', () => {
+    it('should pass watermarks to istanbul', async () => {
       const watermarks = {
         statements: [10, 20],
         branches: [30, 40],
@@ -395,15 +391,15 @@ describe('reporter', () => {
       reporter = new m.CoverageReporter(customConfig, mockHelper, mockLogger)
       reporter.onRunStart()
       browsers.forEach(b => reporter.onBrowserStart(b))
-      reporter.onRunComplete(browsers)
+      await reporter.onRunComplete(browsers)
 
       expect(createContextStub).to.have.been.called
       expect(reportCreateStub).to.have.been.called
       const options = reportCreateStub.getCall(0)
       expect(options.args[1].watermarks).to.deep.equal(watermarks)
     })
 
-    it('should merge with istanbul default watermarks', () => {
+    it('should merge with istanbul default watermarks', async () => {
       const watermarks = {
         statements: [10, 20],
         lines: [70, 80]
@@ -426,7 +422,7 @@ describe('reporter', () => {
       reporter = new m.CoverageReporter(customConfig, mockHelper, mockLogger)
       reporter.onRunStart()
       browsers.forEach(b => reporter.onBrowserStart(b))
-      reporter.onRunComplete(browsers)
+      await reporter.onRunComplete(browsers)
 
       expect(createContextStub).to.have.been.called
       expect(reportCreateStub).to.have.been.called
@@ -437,7 +433,7 @@ describe('reporter', () => {
       expect(options.args[1].watermarks.lines).to.deep.equal(watermarks.lines)
     })
 
-    it('should log errors on low coverage and fail the build', () => {
+    it('should log errors on low coverage and fail the build', async () => {
       const customConfig = helper.merge({}, rootConfig, {
         coverageReporter: {
           check: {
@@ -472,13 +468,13 @@ describe('reporter', () => {
       reporter = new m.CoverageReporter(customConfig, mockHelper, customLogger)
       reporter.onRunStart()
       browsers.forEach(b => reporter.onBrowserStart(b))
-      reporter.onRunComplete(browsers, results)
+      await reporter.onRunComplete(browsers, results)
 
       expect(spy1).to.have.been.called
       expect(results.exitCode).to.not.equal(0)
     })
 
-    it('should not log errors on sufficient coverage and not fail the build', () => {
+    it('should not log errors on sufficient coverage and not fail the build', async () => {
       const customConfig = helper.merge({}, rootConfig, {
         coverageReporter: {
           check: {
@@ -513,7 +509,7 @@ describe('reporter', () => {
       reporter = new m.CoverageReporter(customConfig, mockHelper, customLogger)
       reporter.onRunStart()
       browsers.forEach(b => reporter.onBrowserStart(b))
-      reporter.onRunComplete(browsers, results)
+      await reporter.onRunComplete(browsers, results)
 
       expect(spy1).to.not.have.been.called