Don't try to fake generator functions

testdouble.js does not yet support faking generators, full stop. Just
return the actual function and fake any properties tacked onto them
instead.

Author: searls

src/imitate/create-imitation.js

@@ -1,12 +1,17 @@
 import _ from '../wrap/lodash'
 
 import tdFunction from '../function'
+import isGenerator from './is-generator'
 
 export default (original, names) => {
   if (_.isArray(original) || _.isArguments(original)) {
     return []
   } else if (_.isFunction(original)) {
-    return tdFunction(names.join('') || '(anonymous function)')
+    if (isGenerator(original)) {
+      return original
+    } else {
+      return tdFunction(names.join('') || '(anonymous function)')
+    }
   } else {
     return _.clone(original)
   }

src/imitate/is-generator.js

@@ -0,0 +1,17 @@
+const generatorsAreSupported = (function () {
+  try {
+    eval('(function* () {})') // eslint-disable-line
+    return true
+  } catch (e) {
+    return false
+  }
+})()
+
+const GeneratorFunction = (function () {
+  if (!generatorsAreSupported) return
+  const func = eval('(function* () {})') // eslint-disable-line
+  return Object.getPrototypeOf(func).constructor
+})()
+
+export default (func) =>
+  generatorsAreSupported && func.constructor === GeneratorFunction

test/helper.js

@@ -18,3 +18,12 @@ module.exports = {
   },
   afterAll: function () {}
 }
+
+global.ES_GENERATOR_SUPPORT = (function () {
+  try {
+    eval('(function* () {})')
+    return true
+  } catch (e) {
+    return false
+  }
+})()

test/unit/imitate/create-imitation.test.js

@@ -1,7 +1,8 @@
-let tdFunction, subject
+let tdFunction, isGenerator, subject
 module.exports = {
   beforeEach: () => {
     tdFunction = td.replace('../../../src/function').default
+    isGenerator = td.replace('../../../src/imitate/is-generator').default
     subject = require('../../../src/imitate/create-imitation').default
   },
   'an array type': () => {
@@ -12,36 +13,47 @@ module.exports = {
     assert.deepEqual(subject(args, []), [])
   },
   'a function without names': () => {
+    const someFunc = () => {}
     td.when(tdFunction('(anonymous function)')).thenReturn('fake thing')
+    td.when(isGenerator(someFunc)).thenReturn(false)
 
-    const result = subject(() => {}, [])
+    const result = subject(someFunc, [])
 
     assert.deepEqual(result, 'fake thing')
   },
   'a function with names': () => {
+    const someFunc = () => {}
     td.when(tdFunction('AOK')).thenReturn('fake thing')
+    td.when(isGenerator(someFunc)).thenReturn(false)
 
-    const result = subject(() => {}, ['A', 'OK'])
+    const result = subject(someFunc, ['A', 'OK'])
 
     assert.deepEqual(result, 'fake thing')
   },
   'other instances': () => {
     const original = {a: 'b'}
 
-    const result = subject(original)
+    const result = subject(original, [])
 
     assert.deepEqual(result, original)
     assert.notStrictEqual(result, original)
   },
   'primitives': () => {
-    assert.strictEqual(subject(true), true)
-    assert.strictEqual(subject(5), 5)
-    assert.strictEqual(subject('hi'), 'hi')
-    assert.strictEqual(subject(null), null)
-    assert.strictEqual(subject(undefined), undefined)
+    assert.strictEqual(subject(true, []), true)
+    assert.strictEqual(subject(5, []), 5)
+    assert.strictEqual(subject('hi', []), 'hi')
+    assert.strictEqual(subject(null, []), null)
+    assert.strictEqual(subject(undefined, []), undefined)
   },
   'symbols': () => {
     if (!global.Symbol) return
-    assert.strictEqual(subject(Symbol.species), Symbol.species)
+    assert.strictEqual(subject(Symbol.species, []), Symbol.species)
+  },
+  'generators do not blow up and just return themselves i guess': () => {
+    const generator = () => {}
+    td.when(tdFunction(), {ignoreExtraArgs: true}).thenReturn('fake thing')
+    td.when(isGenerator(generator)).thenReturn(true)
+
+    assert.strictEqual(subject(generator, []), generator)
   }
 }

test/unit/imitate/is-generator.test.js

@@ -0,0 +1,24 @@
+import subject from '../../../src/imitate/is-generator'
+
+module.exports = {
+  'returns false if passed a plain function': () => {
+    const func = function () {}
+
+    const result = subject(func)
+
+    assert.strictEqual(result, false)
+  },
+  'returns true if passed a generator (when generators supported)': () => {
+    if (!ES_GENERATOR_SUPPORT) return
+    const func = eval('(function* () {})') //esline-disable-line
+
+    const result = subject(func)
+
+    assert.strictEqual(result, true)
+  },
+  'returns false when generators are not supported': () => {
+    if (ES_GENERATOR_SUPPORT) return
+    // Not much of a test, ¯\_(ツ)_/¯
+    assert.strictEqual(subject(), false)
+  }
+}