refactor: replace migrate coffee unit tests to modern JS (#407)

Author: anthony-redFox

.eslintrc

@@ -1,3 +1,11 @@
 {
-  "extends": "standard"
+  "extends": "standard",
+  "env": {
+    "node": true,
+    "mocha": true
+  },
+  "globals": {
+    "expect": true,
+    "sinon": true
+  }
 }

gruntfile.js

@@ -8,8 +8,8 @@ module.exports = function (grunt) {
       },
       unit: {
         src: [
-          'test/mocha-globals.coffee',
-          'test/*.spec.coffee'
+          'test/mocha-globals.js',
+          'test/*.spec.js'
         ]
       }
     },

test/coverage-map.spec.coffee

@@ -0,0 +1,31 @@
+const coverageMap = require('../lib/coverage-map')
+const coverageObj = { path: './path.js', otherThings: 'that are in instrumented code' }
+
+describe('coverageMap', () => {
+  it('should add coverageMap and get them', () => {
+    coverageMap.add(coverageObj)
+    expect(coverageMap.get()['./path.js']).to.equal(coverageObj)
+  })
+
+  it('should be able to be reset', () => {
+    coverageMap.reset()
+
+    expect(coverageMap.get()['./path.js']).to.not.exist
+
+    coverageMap.add(coverageObj)
+
+    expect(coverageMap.get()['./path.js']).to.equal(coverageObj)
+
+    coverageMap.reset()
+
+    expect(coverageMap.get()['./path.js']).to.not.exist
+  })
+
+  it('should be able to have multiple coverageMap', () => {
+    coverageMap.reset()
+    coverageMap.add(coverageObj)
+    coverageMap.add({ path: './anotherFile.js', moarKeys: [1, 2, 3] })
+
+    expect(Object.keys(coverageMap.get()).length).to.equal(2)
+  })
+})

test/coverage-map.spec.js

@@ -0,0 +1,30 @@
+const InMemoryReport = require('../lib/in-memory-report')
+
+describe('InMemoryReport', () => {
+  const emitter = {emit: sinon.stub()}
+  const browser = { name: 'firefox' }
+  const result = { test: { data: 'result' } }
+  const fc = {
+    path: 'test',
+    toJSON: sinon.stub().returns({ data: 'result' })
+  }
+  const node = {getFileCoverage: sinon.stub().returns(fc)}
+
+  it('should raise an "coverage_complete" event.', () => {
+    const sut = new InMemoryReport({browser, emitter})
+    sut.onStart()
+    sut.onDetail(node)
+    sut.onEnd()
+    expect(node.getFileCoverage).to.have.been.called
+    expect(fc.toJSON).to.have.been.called
+    expect(emitter.emit).to.have.been.calledWith('coverage_complete', browser, result)
+  })
+
+  it('should be of type "in-memory"', () =>
+    expect(InMemoryReport.TYPE).to.be.equal('in-memory')
+  )
+
+  it('should not fail when created without arguments', () =>
+    expect(new InMemoryReport()).to.be.ok
+  )
+})

test/in-memory-report.spec.coffee

@@ -0,0 +1,9 @@
+require('../lib/index')
+const InMemoryReport = require('../lib/in-memory-report')
+const reportCreator = require('../lib/report-creator')
+
+describe('Index', () => {
+  it('should register "InMemoryReport" to Report Creator', () =>
+    expect(reportCreator.create('in-memory', {})).to.be.an.instanceof(InMemoryReport)
+  )
+})

test/in-memory-report.spec.js

@@ -0,0 +1,12 @@
+const sinon = require('sinon')
+const chai = require('chai')
+
+// publish globals that all specs can use
+global.expect = chai.expect
+global.should = chai.should()
+global.sinon = sinon
+
+// chai plugins
+chai.use(require('sinon-chai'))
+
+afterEach(() => global.sinon.restore())

test/index.spec.coffee

@@ -0,0 +1,224 @@
+const vm = require('vm')
+const util = require('util')
+const path = require('path')
+
+const coverageMap = require('../lib/coverage-map')
+
+describe('preprocessor', () => {
+  const createPreprocessor = require('../lib/preprocessor')
+
+  const ORIGINAL_CODE = `
+  if (a) {
+    something();
+  } else {
+    other();
+  }
+  `
+
+  const ORIGINAL_COFFEE_CODE = `
+  if a
+    something()
+  else
+    other()
+  `
+
+  const mockLogger = {create: () => {
+    return {
+      error: (...arg) => { throw new Error(util.format.apply(util, arg)) },
+      warn: () => {},
+      info: () => {},
+      debug: () => {}
+    }
+  }}
+
+  // TODO(vojta): refactor this somehow ;-) it's copy pasted from lib/file-list.js
+  function File (path, mtime) {
+    this.path = path
+    this.originalPath = path
+    this.contentPath = path
+    this.mtime = mtime
+    this.isUrl = false
+  }
+
+  it('should not do anything if coverage reporter is not used', (done) => {
+    const process = createPreprocessor(mockLogger, null, ['dots', 'progress'], {})
+    const file = new File('/base/path/file.js')
+
+    process(ORIGINAL_CODE, file, (preprocessedCode) => {
+      expect(preprocessedCode).to.equal(ORIGINAL_CODE)
+      expect(file.path).to.equal('/base/path/file.js')
+      done()
+    })
+  })
+
+  it('should preprocess the code', (done) => {
+    const process = createPreprocessor(mockLogger, '/base/path', ['coverage', 'progress'], {})
+    const file = new File('/base/path/file.js')
+
+    process(ORIGINAL_CODE, file, (preprocessedCode) => {
+      const sandbox = {
+        a: true,
+        something: () => {}
+      }
+
+      vm.runInNewContext(preprocessedCode, sandbox)
+      expect(sandbox.__coverage__).to.have.ownProperty(path.resolve('/base/path/file.js'))
+      done()
+    })
+  })
+
+  it('should preprocess the fake code', (done) => {
+    class fakeInstanbulLikeInstrumenter {
+      instrument (_a, _b, callback) {
+        callback()
+      }
+      lastSourceMap () {}
+    }
+    const process = createPreprocessor(mockLogger, '/base/path', ['coverage', 'progress'], {
+      instrumenters: {
+        fakeInstanbulLike: {
+          Instrumenter: fakeInstanbulLikeInstrumenter
+        }
+      },
+      instrumenter: {
+        '**/*.fake': 'fakeInstanbulLike'
+      }
+    })
+    const file = new File('/base/path/file.fake')
+
+    process(ORIGINAL_COFFEE_CODE, file, (preprocessedCode) => {
+      const sandbox = {
+        a: true,
+        something: () => {}
+      }
+
+      vm.runInNewContext(preprocessedCode, sandbox)
+      expect(file.path).to.equal('/base/path/file.fake')
+      done()
+    })
+  })
+
+  it('should preprocess the fake code with the config options', (done) => {
+    class fakeInstanbulLikeInstrumenter {
+      constructor (options) {
+        expect(options.experimental).to.be.ok
+      }
+      instrument (_a, _b, callback) {
+        callback()
+      }
+      lastSourceMap () {}
+    }
+    const process = createPreprocessor(mockLogger, '/base/path', ['coverage', 'progress'], {
+      instrumenters: {
+        fakeInstanbulLike: {
+          Instrumenter: fakeInstanbulLikeInstrumenter
+        }
+      },
+      instrumenterOptions: {
+        fakeInstanbulLike: {
+          experimental: 'yes'
+        }
+      },
+      instrumenter: {
+        '**/*.fake': 'fakeInstanbulLike'
+      }
+    })
+
+    const file = new File('/base/path/file.fake')
+    process(ORIGINAL_COFFEE_CODE, file, done)
+  })
+
+  it('should not preprocess the coffee code', (done) => {
+    const process = createPreprocessor(mockLogger, '/base/path', ['coverage', 'progress'], {instrumenter: {'**/*.coffee': 'istanbul'}})
+    const file = new File('/base/path/file.coffee')
+
+    process(ORIGINAL_CODE, file, (preprocessedCode) => {
+      const sandbox = {
+        a: true,
+        something: () => {}
+      }
+
+      vm.runInNewContext(preprocessedCode, sandbox)
+      expect(file.path).to.equal('/base/path/file.coffee')
+      expect(sandbox.__coverage__).to.have.ownProperty(path.resolve('/base/path/file.coffee'))
+      done()
+    })
+  })
+
+  it('should fail if invalid instrumenter provided', () => {
+    const work = () => {
+      createPreprocessor(mockLogger, '/base/path', ['coverage', 'progress'], {instrumenter: {'**/*.coffee': 'madeup'}})
+    }
+    expect(work).to.throw()
+  })
+
+  it('should add coverageMap when including all sources', (done) => {
+    const process = createPreprocessor(mockLogger, '/base/path', ['coverage'], { includeAllSources: true })
+    const file = new File('/base/path/file.js')
+
+    coverageMap.reset()
+
+    process(ORIGINAL_CODE, file, (preprocessedCode) => {
+      expect(coverageMap.get()[path.resolve('/base/path/file.js')]).to.exist
+      done()
+    })
+  })
+
+  it('should not add coverageMap when not including all sources', (done) => {
+    const process = createPreprocessor(mockLogger, '/base/path', ['coverage'], { includeAllSources: false })
+    const file = new File('/base/path/file.js')
+
+    coverageMap.reset()
+
+    process(ORIGINAL_CODE, file, (preprocessedCode) => {
+      expect(coverageMap.get()['./file.js']).to.not.exist
+      done()
+    })
+  })
+
+  it('should not add coverageMap in the default state', (done) => {
+    const process = createPreprocessor(mockLogger, '/base/path', ['coverage'], {})
+    const file = new File('/base/path/file.js')
+
+    coverageMap.reset()
+
+    process(ORIGINAL_CODE, file, (preprocessedCode) => {
+      expect(coverageMap.get()['./file.js']).to.not.exist
+      done()
+    })
+  })
+
+  it('should change extension of CoffeeScript files when given `useJSExtensionForCoffeeScript`', (done) => {
+    class ibrikInstrumenter {
+      instrument (_a, _b, callback) {
+        callback()
+      }
+      lastSourceMap () {}
+    }
+
+    const process = createPreprocessor(mockLogger, '/base/path', ['coverage', 'progress'], {
+      instrumenters: {
+        ibrik: {
+          Instrumenter: ibrikInstrumenter
+        }
+      },
+      instrumenter: {
+        '**/*.coffee': 'ibrik'
+      },
+      useJSExtensionForCoffeeScript: true
+    })
+
+    const file = new File('/base/path/file.coffee')
+
+    process(ORIGINAL_COFFEE_CODE, file, (preprocessedCode) => {
+      const sandbox = {
+        a: true,
+        something: () => {}
+      }
+
+      vm.runInNewContext(preprocessedCode, sandbox)
+      expect(file.path).to.equal('/base/path/file.js')
+      done()
+    })
+  })
+})

test/index.spec.js

@@ -0,0 +1,43 @@
+const istanbulReports = require('istanbul-reports')
+const reportCreator = require('../lib/report-creator')
+
+describe('Report Creator', () => {
+  afterEach(() => reportCreator.reset())
+
+  describe('register', () => {
+    it('should throw when reporter does not include type', () => {
+      const reporter = {}
+      expect(() => reportCreator.register(reporter)).to.throw
+    })
+
+    it('should complete when report includes a type', () => {
+      const reporter = { TYPE: 'test' }
+      expect(reportCreator.register(reporter)).to.be.equal('test')
+    })
+  })
+
+  describe('create', () => {
+    it('should return custom reporter if registered', () => {
+      const Reporter = sinon.stub()
+      Reporter.TYPE = 'test'
+      reportCreator.register(Reporter)
+      const fallbackCreateStub = sinon.stub(istanbulReports, 'create')
+      const reporterOpts = { test: 'options' }
+
+      reportCreator.create('test', reporterOpts)
+
+      expect(fallbackCreateStub).not.to.be.called
+      expect(Reporter.calledWithNew()).to.be.true
+      expect(Reporter).to.be.calledWith(reporterOpts)
+    })
+
+    it('should proxy call to istanbul if custom reporter is not registered', () => {
+      const fallbackCreateStub = sinon.stub(istanbulReports, 'create')
+      fallbackCreateStub.returnsThis()
+      const reporterOpts = { test: 'options' }
+
+      reportCreator.create('test', reporterOpts)
+      expect(fallbackCreateStub).to.be.calledWith('test', reporterOpts)
+    })
+  })
+})

test/mocha-globals.coffee

@@ -0,0 +1,23 @@
+const istanbulLibSourceMaps = require('istanbul-lib-source-maps')
+const globalSourceMapStore = require('../lib/source-map-store')
+
+describe('Source Map Store', () => {
+  it('should create a source map store for path if it did not exist previously', () => {
+    const createSourceMapStoreStub = sinon.stub(istanbulLibSourceMaps, 'createSourceMapStore')
+    createSourceMapStoreStub.returns({})
+
+    globalSourceMapStore.get('__test', { opts: 'test' })
+    expect(createSourceMapStoreStub).to.be.calledWith({ opts: 'test' })
+  })
+
+  it('should not create a source map store for path if it previously was called', () => {
+    const createSourceMapStoreStub = sinon.stub(istanbulLibSourceMaps, 'createSourceMapStore')
+    createSourceMapStoreStub.returns({})
+
+    globalSourceMapStore.get('__test2', { opts: 'test2' })
+    globalSourceMapStore.get('__test2', { opts: 'test3' })
+
+    expect(createSourceMapStoreStub.callCount).to.be.equal(1)
+    expect(createSourceMapStoreStub).to.be.calledWith({ opts: 'test2' })
+  })
+})