Test the thing that creates the root fakes

These are just the node-level replacement, their properties (or for
arrays, elements) will be replaced by overwriteChildren

Simplied somewhat, when I learned through the test that underscore's
clone works well enough for primitives (one would trust, efficiently
enough)

src/imitate/create-imitation.js

@@ -3,15 +3,11 @@ import _ from '../wrap/lodash'
 import tdFunction from '../function'
 
 export default (original, names) => {
-  let target
   if (_.isArray(original) || _.isArguments(original)) {
-    target = []
+    return []
   } else if (_.isFunction(original)) {
-    target = tdFunction(_.compact(names).join('') || '(anonymous function)')
-  } else if (_.isObject(original)) {
-    target = _.clone(original)
+    return tdFunction(names.join('') || '(anonymous function)')
   } else {
-    target = original
+    return _.clone(original)
   }
-  return target
 }

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

@@ -0,0 +1,47 @@
+let tdFunction, subject
+module.exports = {
+  beforeEach: () => {
+    tdFunction = td.replace('../../../src/function').default
+    subject = require('../../../src/imitate/create-imitation').default
+  },
+  'an array type': () => {
+    assert.deepEqual(subject([], []), [])
+  },
+  'an arguments type': () => {
+    let args = (function () { return arguments })()
+    assert.deepEqual(subject(args, []), [])
+  },
+  'a function without names': () => {
+    td.when(tdFunction('(anonymous function)')).thenReturn('fake thing')
+
+    const result = subject(() => {}, [])
+
+    assert.deepEqual(result, 'fake thing')
+  },
+  'a function with names': () => {
+    td.when(tdFunction('AOK')).thenReturn('fake thing')
+
+    const result = subject(() => {}, ['A', 'OK'])
+
+    assert.deepEqual(result, 'fake thing')
+  },
+  'other instances': () => {
+    const original = {a: 'b'}
+
+    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)
+  },
+  'symbols': () => {
+    if (!global.Symbol) return
+    assert.strictEqual(subject(Symbol.species), Symbol.species)
+  }
+}

test/unit/imitate/initialize-names.test.js

@@ -4,13 +4,6 @@ module.exports = {
   'passed a non-null names': () => {
     assert.equal(subject(null, 'foo'), 'foo')
   },
-  'an array type': () => {
-    assert.deepEqual(subject(['lol']), [])
-  },
-  'an arguments type': () => {
-    let args = (function () { return arguments })(1,2,3)
-    assert.deepEqual(subject(args), [])
-  },
   'an anon function': () => {
     assert.deepEqual(subject(function () {}), [])
   },