update to latest api

Author: chrisbreiding

README.md

@@ -17,8 +17,8 @@ In your project's [plugins file](https://on.cypress.io/guides/guides/plugins.htm
 ```javascript
 const webpack = require('@cypress/webpack-preprocessor')
 
-module.exports = (on, config) => {
-  on('file:preprocessor', webpack(config))
+module.exports = (on) => {
+  on('file:preprocessor', webpack())
 }
 ```
 
@@ -28,15 +28,15 @@ Pass in options as the second argument to `webpack`:
 
 ```javascript
 const webpack = require('@cypress/webpack-preprocessor')
-module.exports = (on, config) => {
+module.exports = (on) => {
   const options = {
     // send in the options from your webpack.config.js, so it works the same
     // as your app's code
     webpackOptions: require('../../webpack.config'),
     watchOptions: {},
   }
 
-  on('file:preprocessor', webpack(config, options))
+  on('file:preprocessor', webpack(options))
 }
 ```
 
@@ -83,14 +83,28 @@ If, for example, you want to update the options for the `babel-loader` to add th
 ```javascript
 const webpack = require('@cypress/webpack-preprocessor')
 
-module.exports = (on, config) => {
+module.exports = (on) => {
   const options = webpack.defaultOptions
   options.webpackOptions.module.rules[0].use.options.presets.push('babel-preset-stage-3')
 
-  on('file:preprocessor', webpack(config, options))
+  on('file:preprocessor', webpack(options))
 }
 ```
 
+## Contributing
+
+Run all tests once:
+
+```shell
+npm test
+```
+
+Run tests in watch mode:
+
+```shell
+npm run test-watch
+```
+
 ## License
 
 This project is licensed under the terms of the [MIT license](/LICENSE.md).

index.js

@@ -33,28 +33,24 @@ const defaultOptions = {
 // export a function that returns another function, making it easy for users
 // to configure like so:
 //
-// on('file:preprocessor', webpack(config, userOptions))
+// on('file:preprocessor', webpack(config, options))
 //
-const preprocessor = (config, userOptions = {}) => {
-  if (!config || typeof config.isTextTerminal !== 'boolean') {
-    throw new Error(`Cypress Webpack Preprocessor must be called with the Cypress config as its first argument. You passed: ${JSON.stringify(config, null, 2)}`)
-  }
-
-  log('user options:', userOptions)
-
+const preprocessor = (options = {}) => {
+  log('user options:', options)
 
   // we return function that accepts the arguments provided by
   // the event 'file:preprocessor'
   //
   // this function will get called for the support file when a project is loaded
   // (if the support file is not disabled)
-  // it will also get calledfor a spec file when that spec is requested by
+  // it will also get called for a spec file when that spec is requested by
   // the Cypress runner
   //
   // when running in the GUI, it will likely get called multiple times
   // with the same filePath, as the user could re-run the tests, causing
   // the supported file and spec file to be requested again
-  return (filePath, util) => {
+  return (config) => {
+    const filePath = config.filePath
     log('get', filePath)
 
     // since this function can get called multiple times with the same
@@ -65,17 +61,14 @@ const preprocessor = (config, userOptions = {}) => {
       return bundles[filePath]
     }
 
-    // if we're in a text terminal, this is a one-time run, probably in CI
-    // so we don't need to watch
-    const shouldWatch = !config.isTextTerminal
-    // util.getOutputPath returns a path alongside Cypress's other app data
-    // files so we don't have to worry about where to put the bundled
-    // file on disk
-    const outputPath = util.getOutputPath(filePath)
-
     // user can override the default options
-    let webpackOptions = Object.assign({}, defaultOptions.webpackOptions, userOptions.webpackOptions)
-    let watchOptions = Object.assign({}, defaultOptions.watchOptions, userOptions.watchOptions)
+    let webpackOptions = Object.assign({}, defaultOptions.webpackOptions, options.webpackOptions)
+    let watchOptions = Object.assign({}, defaultOptions.watchOptions, options.watchOptions)
+
+    // we're provided a default output path that lives alongside Cypress's
+    // app data files so we don't have to worry about where to put the bundled
+    // file on disk
+    const outputPath = config.outputPath
 
     // we need to set entry and output
     webpackOptions = Object.assign(webpackOptions, {
@@ -139,25 +132,25 @@ const preprocessor = (config, userOptions = {}) => {
         log('- compile finished for', filePath)
         // when the bundling is finished, we call `util.fileUpdated`
         // to let Cypress know to re-run the spec
-        util.fileUpdated(filePath)
+        config.emit('rerun')
       })
     })
 
-    if (shouldWatch) {
+    if (config.shouldWatch) {
       log('watching')
     }
 
-    const bundler = shouldWatch ?
+    const bundler = config.shouldWatch ?
       compiler.watch(watchOptions, handle) :
       compiler.run(handle)
 
     // when the spec or project is closed, we need to clean up the cached
     // bundle promise and stop the watcher via `bundler.close()`
-    util.onClose(() => {
+    config.on('close', () => {
       log('close', filePath)
       delete bundles[filePath]
 
-      if (shouldWatch) {
+      if (config.shouldWatch) {
         bundler.close()
       }
     })

test/index_spec.js

@@ -36,29 +36,27 @@ describe('webpack preprocessor', function () {
     }
 
     this.config = {
-      isTextTerminal: true,
+      filePath: 'path/to/file.js',
+      outputPath: 'output/output.js',
+      shouldWatch: false,
+      on: sandbox.stub(),
+      emit: sandbox.spy(),
     }
-    this.userOptions = {}
-    this.filePath = 'path/to/file.js'
-    this.outputPath = 'output/output.js'
+    this.options = {}
     this.util = {
       getOutputPath: sandbox.stub().returns(this.outputPath),
       fileUpdated: sandbox.spy(),
       onClose: sandbox.stub(),
     }
 
     this.run = () => {
-      return preprocessor(this.config, this.userOptions)(this.filePath, this.util)
+      return preprocessor(this.options)(this.config)
     }
   })
 
   describe('exported function', function () {
     it('receives user options and returns a preprocessor function', function () {
-      expect(preprocessor(this.config, this.userOptions)).to.be.a('function')
-    })
-
-    it('throws error if config is not the first argument', function () {
-      expect(preprocessor).to.throw('must be called with the Cypress config')
+      expect(preprocessor(this.options)).to.be.a('function')
     })
 
     it('has defaultOptions attached to it', function () {
@@ -69,7 +67,7 @@ describe('webpack preprocessor', function () {
 
   describe('preprocessor function', function () {
     afterEach(function () {
-      this.util.onClose.yield() // resets the cached bundles
+      this.config.on.withArgs('close').yield() // resets the cached bundles
     })
 
     describe('when it finishes cleanly', function () {
@@ -87,15 +85,15 @@ describe('webpack preprocessor', function () {
         webpack.reset()
         webpack.returns(this.compilerApi)
 
-        const run = preprocessor(this.config, this.userOptions)
-        run(this.filePath, this.util)
-        run(this.filePath, this.util)
+        const run = preprocessor(this.options)
+        run(this.config)
+        run(this.config)
         expect(webpack).to.be.calledOnce
       })
 
       it('specifies the entry file', function () {
         return this.run().then(() => {
-          expect(webpack.lastCall.args[0].entry).to.equal(this.filePath)
+          expect(webpack.lastCall.args[0].entry).to.equal(this.config.filePath)
         })
       })
 
@@ -108,24 +106,24 @@ describe('webpack preprocessor', function () {
         })
       })
 
-      it('runs when isTextTerminal is true', function () {
+      it('runs when shouldWatch is false', function () {
         return this.run().then(() => {
           expect(this.compilerApi.run).to.be.called
         })
       })
 
-      it('watches when isTextTerminal is false', function () {
-        this.config.isTextTerminal = false
+      it('watches when shouldWatch is true', function () {
+        this.config.shouldWatch = true
         this.compilerApi.watch.yields(null, this.statsApi)
         return this.run().then(() => {
           expect(this.compilerApi.watch).to.be.called
         })
       })
 
       it('includes watchOptions if provided', function () {
-        this.config.isTextTerminal = false
+        this.config.shouldWatch = true
         this.compilerApi.watch.yields(null, this.statsApi)
-        this.userOptions.watchOptions = { poll: true }
+        this.options.watchOptions = { poll: true }
         return this.run().then(() => {
           expect(this.compilerApi.watch.lastCall.args[0]).to.eql({
             poll: true,
@@ -135,37 +133,29 @@ describe('webpack preprocessor', function () {
 
       it('resolves with the output path', function () {
         return this.run().then((outputPath) => {
-          expect(this.util.getOutputPath).to.be.calledWith(this.filePath)
-          expect(outputPath).to.be.equal(this.outputPath)
+          expect(outputPath).to.be.equal(this.config.outputPath)
         })
       })
 
-      it('calls util.fileUpdated when there is an update', function () {
+      it('emits `rerun` when there is an update', function () {
         this.compilerApi.plugin.withArgs('compile').yields()
         return this.run().then(() => {
-          expect(this.util.fileUpdated).to.be.calledWith(this.filePath)
-        })
-      })
-
-      it('registers onClose callback', function () {
-        return this.run().then(() => {
-          expect(this.util.onClose).to.be.called
-          expect(this.util.onClose.lastCall.args[0]).to.be.a('function')
+          expect(this.config.emit).to.be.calledWith('rerun')
         })
       })
 
-      it('closes bundler when isTextTerminal is false and onClose callback is called', function () {
-        this.config.isTextTerminal = false
+      it('closes bundler when shouldWatch is true and `close` is emitted', function () {
+        this.config.shouldWatch = true
         this.compilerApi.watch.yields(null, this.statsApi)
         return this.run().then(() => {
-          this.util.onClose.lastCall.args[0]()
+          this.config.on.withArgs('close').yield()
           expect(this.watchApi.close).to.be.called
         })
       })
 
-      it('does not close bundler when isTextTerminal is true and onClose callback is called', function () {
+      it('does not close bundler when shouldWatch is false and `close` is emitted', function () {
         return this.run().then(() => {
-          this.util.onClose.lastCall.args[0]()
+          this.config.on.withArgs('close').yield()
           expect(this.watchApi.close).not.to.be.called
         })
       })