diff --git a/flow/options.flow.js b/flow/options.flow.js
index 6970b117b..0a8549919 100644
--- a/flow/options.flow.js
+++ b/flow/options.flow.js
@@ -11,5 +11,10 @@ declare type Options = { // eslint-disable-line no-undef
     context?: Object,
     attrs?: Object,
     listeners?: Object,
-    logModifiedComponents?: Boolean
+    logModifiedComponents?: boolean,
+    sync?: boolean
 }
+
+declare type SlotValue = Component | string | Array<Component | string>
+
+declare type SlotsObject = {[name: string]: SlotValue}
diff --git a/flow/vue.flow.js b/flow/vue.flow.js
index 77b9503c0..7826aa089 100644
--- a/flow/vue.flow.js
+++ b/flow/vue.flow.js
@@ -4,4 +4,3 @@
 
 declare type Component = Object | Function // eslint-disable-line no-undef
 declare type VNode = Object // eslint-disable-line no-undef
-declare type SlotValue = Component | string | Array<Component> | Array<string>
diff --git a/flow/wrapper.flow.js b/flow/wrapper.flow.js
index ae24b167a..77edd9f05 100644
--- a/flow/wrapper.flow.js
+++ b/flow/wrapper.flow.js
@@ -39,5 +39,5 @@ declare interface BaseWrapper { // eslint-disable-line no-undef
 
 declare type WrapperOptions = { // eslint-disable-line no-undef
     attachedToDocument: boolean,
-    sync: boolean
+    sync?: boolean
 }
diff --git a/package.json b/package.json
index ff8727dee..3d6707941 100644
--- a/package.json
+++ b/package.json
@@ -63,12 +63,12 @@
     "rollup": "^0.58.2",
     "sinon": "^2.3.2",
     "sinon-chai": "^2.10.0",
-    "vue": "2.5.13",
+    "vue": "^2.5.16",
     "vue-class-component": "^6.1.2",
     "vue-loader": "^13.6.2",
     "vue-router": "^3.0.1",
-    "vue-server-renderer": "2.5.13",
-    "vue-template-compiler": "2.5.13",
+    "vue-server-renderer": "^2.5.16",
+    "vue-template-compiler": "^2.5.16",
     "vuepress": "^0.10.0",
     "vuepress-theme-vue": "^1.0.3",
     "vuetify": "^0.16.9",
diff --git a/packages/create-instance/add-attrs.js b/packages/create-instance/add-attrs.js
deleted file mode 100644
index 6ec46517e..000000000
--- a/packages/create-instance/add-attrs.js
+++ /dev/null
@@ -1,12 +0,0 @@
-import Vue from 'vue'
-
-export default function addAttrs (vm, attrs) {
-  const originalSilent = Vue.config.silent
-  Vue.config.silent = true
-  if (attrs) {
-    vm.$attrs = attrs
-  } else {
-    vm.$attrs = {}
-  }
-  Vue.config.silent = originalSilent
-}
diff --git a/packages/create-instance/add-listeners.js b/packages/create-instance/add-listeners.js
deleted file mode 100644
index 0180cb712..000000000
--- a/packages/create-instance/add-listeners.js
+++ /dev/null
@@ -1,12 +0,0 @@
-import Vue from 'vue'
-
-export default function addListeners (vm, listeners) {
-  const originalSilent = Vue.config.silent
-  Vue.config.silent = true
-  if (listeners) {
-    vm.$listeners = listeners
-  } else {
-    vm.$listeners = {}
-  }
-  Vue.config.silent = originalSilent
-}
diff --git a/packages/create-instance/add-provide.js b/packages/create-instance/add-provide.js
deleted file mode 100644
index f36c0a4f4..000000000
--- a/packages/create-instance/add-provide.js
+++ /dev/null
@@ -1,13 +0,0 @@
-function addProvide (component, optionProvide, options) {
-  const provide = typeof optionProvide === 'function'
-    ? optionProvide
-    : Object.assign({}, optionProvide)
-
-  options.beforeCreate = function vueTestUtilBeforeCreate () {
-    this._provided = typeof provide === 'function'
-      ? provide.call(this)
-      : provide
-  }
-}
-
-export default addProvide
diff --git a/packages/create-instance/add-scoped-slots.js b/packages/create-instance/add-scoped-slots.js
deleted file mode 100644
index dedf83100..000000000
--- a/packages/create-instance/add-scoped-slots.js
+++ /dev/null
@@ -1,17 +0,0 @@
-// @flow
-
-import { compileToFunctions } from 'vue-template-compiler'
-import { throwError } from 'shared/util'
-
-export function addScopedSlots (vm: Component, scopedSlots: Object): void {
-  Object.keys(scopedSlots).forEach((key) => {
-    const template = scopedSlots[key].trim()
-    if (template.substr(0, 9) === '<template') {
-      throwError('the scopedSlots option does not support a template tag as the root element.')
-    }
-    const domParser = new window.DOMParser()
-    const _document = domParser.parseFromString(template, 'text/html')
-    vm.$_vueTestUtils_scopedSlots[key] = compileToFunctions(template).render
-    vm.$_vueTestUtils_slotScopes[key] = _document.body.firstChild.getAttribute('slot-scope')
-  })
-}
diff --git a/packages/create-instance/add-slots.js b/packages/create-instance/add-slots.js
index fb595d95b..0236cb288 100644
--- a/packages/create-instance/add-slots.js
+++ b/packages/create-instance/add-slots.js
@@ -1,60 +1,34 @@
 // @flow
 
 import { compileToFunctions } from 'vue-template-compiler'
-import { throwError } from 'shared/util'
-import { validateSlots } from './validate-slots'
 
-// see https://github.com/vuejs/vue-test-utils/pull/274
-function createVNodes (vm: Component, slotValue: string) {
-  const compiledResult = compileToFunctions(`<div>${slotValue}{{ }}</div>`)
-  const _staticRenderFns = vm._renderProxy.$options.staticRenderFns
-  vm._renderProxy.$options.staticRenderFns = compiledResult.staticRenderFns
-  const elem = compiledResult.render.call(vm._renderProxy, vm.$createElement).children
-  vm._renderProxy.$options.staticRenderFns = _staticRenderFns
-  return elem
-}
-
-function validateEnvironment (): void {
-  if (!compileToFunctions) {
-    throwError('vueTemplateCompiler is undefined, you must pass components explicitly if vue-template-compiler is undefined')
-  }
-  if (typeof window === 'undefined') {
-    throwError('the slots string option does not support strings in server-test-uitls.')
-  }
-}
+function createVNodesForSlot (
+  h: Function,
+  slotValue: SlotValue,
+  name: string
+): Array<VNode> {
+  const el = typeof slotValue === 'string'
+    ? compileToFunctions(slotValue)
+    : slotValue
 
-function addSlotToVm (vm: Component, slotName: string, slotValue: SlotValue): void {
-  let elem
-  if (typeof slotValue === 'string') {
-    validateEnvironment()
-    elem = createVNodes(vm, slotValue)
-  } else {
-    elem = vm.$createElement(slotValue)
-  }
-  if (Array.isArray(elem)) {
-    if (Array.isArray(vm.$slots[slotName])) {
-      vm.$slots[slotName] = [...vm.$slots[slotName], ...elem]
-    } else {
-      vm.$slots[slotName] = [...elem]
-    }
-  } else {
-    if (Array.isArray(vm.$slots[slotName])) {
-      vm.$slots[slotName].push(elem)
-    } else {
-      vm.$slots[slotName] = [elem]
-    }
-  }
+  const vnode = h(el)
+  vnode.data.slot = name
+  return vnode
 }
 
-export function addSlots (vm: Component, slots: Object): void {
-  validateSlots(slots)
-  Object.keys(slots).forEach((key) => {
-    if (Array.isArray(slots[key])) {
-      slots[key].forEach((slotValue) => {
-        addSlotToVm(vm, key, slotValue)
-      })
+export function createSlotVNodes (
+  h: Function,
+  slots: SlotsObject
+): Array<VNode> {
+  return Object.keys(slots).reduce((acc, key) => {
+    const content = slots[key]
+    if (Array.isArray(content)) {
+      const nodes = content.reduce((accInner, slotDef) => {
+        return accInner.concat(createVNodesForSlot(h, slotDef, key))
+      }, [])
+      return acc.concat(nodes)
     } else {
-      addSlotToVm(vm, key, slots[key])
+      return acc.concat(createVNodesForSlot(h, content, key))
     }
-  })
+  }, [])
 }
diff --git a/packages/create-instance/create-instance.js b/packages/create-instance/create-instance.js
index c898222f3..c459671a3 100644
--- a/packages/create-instance/create-instance.js
+++ b/packages/create-instance/create-instance.js
@@ -1,42 +1,29 @@
 // @flow
 
 import Vue from 'vue'
-import { addSlots } from './add-slots'
-import { addScopedSlots } from './add-scoped-slots'
+import { createSlotVNodes } from './add-slots'
 import addMocks from './add-mocks'
-import addAttrs from './add-attrs'
-import addListeners from './add-listeners'
-import addProvide from './add-provide'
 import { addEventLogger } from './log-events'
 import { createComponentStubs } from 'shared/stub-components'
-import { throwError, warn } from 'shared/util'
+import { throwError, warn, vueVersion } from 'shared/util'
 import { compileTemplate } from 'shared/compile-template'
-import deleteoptions from './delete-mounting-options'
+import deleteMountingOptions from './delete-mounting-options'
 import createFunctionalComponent from './create-functional-component'
 import { componentNeedsCompiling } from 'shared/validators'
-
-function isDestructuringSlotScope (slotScope: string): boolean {
-  return slotScope[0] === '{' && slotScope[slotScope.length - 1] === '}'
-}
-
-function getVueTemplateCompilerHelpers (proxy: Object): Object {
-  const helpers = {}
-  const names = ['_c', '_o', '_n', '_s', '_l', '_t', '_q', '_i', '_m', '_f', '_k', '_b', '_v', '_e', '_u', '_g']
-  names.forEach((name) => {
-    helpers[name] = proxy[name]
-  })
-  return helpers
-}
+import { validateSlots } from './validate-slots'
 
 export default function createInstance (
   component: Component,
   options: Options,
-  vue: Component
+  _Vue: Component,
+  elm?: Element
 ): Component {
+  // Remove cached constructor
+  delete component._Ctor
+
   if (options.mocks) {
-    addMocks(options.mocks, vue)
+    addMocks(options.mocks, _Vue)
   }
-
   if ((component.options && component.options.functional) || component.functional) {
     component = createFunctionalComponent(component, options)
   } else if (options.context) {
@@ -45,23 +32,23 @@ export default function createInstance (
     )
   }
 
-  if (options.provide) {
-    addProvide(component, options.provide, options)
-  }
-
   if (componentNeedsCompiling(component)) {
     compileTemplate(component)
   }
 
-  addEventLogger(vue)
+  addEventLogger(_Vue)
+
+  const instanceOptions = {
+    ...options,
+    propsData: {
+      ...options.propsData
+    }
+  }
 
-  const Constructor = (typeof component === 'function' && component.prototype instanceof Vue) ? component : vue.extend(component)
+  deleteMountingOptions(instanceOptions)
 
-  const instanceOptions = { ...options, propsData: { ...options.propsData }}
-  deleteoptions(instanceOptions)
   // $FlowIgnore
   const stubComponents = createComponentStubs(component.components, options.stubs)
-
   if (options.stubs) {
     instanceOptions.components = {
       ...instanceOptions.components,
@@ -76,60 +63,53 @@ export default function createInstance (
       if (options.logModifiedComponents) {
         warn(`an extended child component ${c} has been modified to ensure it has the correct instance properties. This means it is not possible to find the component with a component selector. To find the component, you must stub it manually using the stubs mounting option.`)
       }
-      instanceOptions.components[c] = vue.extend(component.components[c])
+      instanceOptions.components[c] = _Vue.extend(component.components[c])
     }
   })
 
   Object.keys(stubComponents).forEach(c => {
-    vue.component(c, stubComponents[c])
+    _Vue.component(c, stubComponents[c])
   })
 
-  const vm = new Constructor(instanceOptions)
-
-  // Workaround for Vue < 2.5
-  vm._staticTrees = []
+  const Constructor = (typeof component === 'function' && component.prototype instanceof Vue)
+    ? component.extend(instanceOptions)
+    : _Vue.extend(component).extend(instanceOptions)
 
-  addAttrs(vm, options.attrs)
-  addListeners(vm, options.listeners)
+  // const Constructor = _Vue.extend(component).extend(instanceOptions)
 
-  if (options.scopedSlots) {
-    if (window.navigator.userAgent.match(/PhantomJS/i)) {
-      throwError('the scopedSlots option does not support PhantomJS. Please use Puppeteer, or pass a component.')
-    }
-    const vueVersion = Number(`${Vue.version.split('.')[0]}.${Vue.version.split('.')[1]}`)
-    if (vueVersion >= 2.5) {
-      vm.$_vueTestUtils_scopedSlots = {}
-      vm.$_vueTestUtils_slotScopes = {}
-      const renderSlot = vm._renderProxy._t
-
-      vm._renderProxy._t = function (name, feedback, props, bindObject) {
-        const scopedSlotFn = vm.$_vueTestUtils_scopedSlots[name]
-        const slotScope = vm.$_vueTestUtils_slotScopes[name]
-        if (scopedSlotFn) {
-          props = { ...bindObject, ...props }
-          const helpers = getVueTemplateCompilerHelpers(vm._renderProxy)
-          let proxy = { ...helpers }
-          if (isDestructuringSlotScope(slotScope)) {
-            proxy = { ...helpers, ...props }
-          } else {
-            proxy[slotScope] = props
-          }
-          return scopedSlotFn.call(proxy)
-        } else {
-          return renderSlot.call(vm._renderProxy, name, feedback, props, bindObject)
-        }
-      }
+  Object.keys(instanceOptions.components || {}).forEach(key => {
+    Constructor.component(key, instanceOptions.components[key])
+    _Vue.component(key, instanceOptions.components[key])
+  })
 
-      // $FlowIgnore
-      addScopedSlots(vm, options.scopedSlots)
-    } else {
-      throwError('the scopedSlots option is only supported in vue@2.5+.')
-    }
+  if (options.slots) {
+    validateSlots(options.slots)
   }
 
-  if (options.slots) {
-    addSlots(vm, options.slots)
+  // Objects are not resolved in extended components in Vue < 2.5
+  // https://github.com/vuejs/vue/issues/6436
+  if (options.provide &&
+    typeof options.provide === 'object' &&
+    vueVersion < 2.5
+  ) {
+    const obj = { ...options.provide }
+    options.provide = () => obj
   }
 
-  return vm
+  const Parent = _Vue.extend({
+    provide: options.provide,
+    render (h) {
+      const slots = options.slots
+        ? createSlotVNodes(h, options.slots)
+        : undefined
+      return h(Constructor, {
+        ref: 'vm',
+        props: options.propsData,
+        on: options.listeners,
+        attrs: options.attrs
+      }, slots)
+    }
+  })
+
+  return new Parent()
 }
diff --git a/packages/create-instance/delete-mounting-options.js b/packages/create-instance/delete-mounting-options.js
index 61b74b698..45c38a8c8 100644
--- a/packages/create-instance/delete-mounting-options.js
+++ b/packages/create-instance/delete-mounting-options.js
@@ -8,4 +8,5 @@ export default function deleteMountingOptions (options) {
   delete options.clone
   delete options.attrs
   delete options.listeners
+  delete options.propsData
 }
diff --git a/packages/create-instance/validate-slots.js b/packages/create-instance/validate-slots.js
index 1c1d7dd9d..b91d8ac32 100644
--- a/packages/create-instance/validate-slots.js
+++ b/packages/create-instance/validate-slots.js
@@ -1,22 +1,34 @@
 // @flow
 
 import { throwError } from 'shared/util'
+import { compileToFunctions } from 'vue-template-compiler'
 
 function isValidSlot (slot: any): boolean {
-  return Array.isArray(slot) || (slot !== null && typeof slot === 'object') || typeof slot === 'string'
+  return Array.isArray(slot) ||
+   (slot !== null && typeof slot === 'object') ||
+   typeof slot === 'string'
 }
 
-export function validateSlots (slots: Object): void {
-  slots && Object.keys(slots).forEach((key) => {
+function requiresTemplateCompiler (slot) {
+  if (typeof slot === 'string' && !compileToFunctions) {
+    throwError('vueTemplateCompiler is undefined, you must pass precompiled components if vue-template-compiler is undefined')
+  }
+}
+
+export function validateSlots (slots: SlotsObject): void {
+  Object.keys(slots).forEach((key) => {
     if (!isValidSlot(slots[key])) {
       throwError('slots[key] must be a Component, string or an array of Components')
     }
 
+    requiresTemplateCompiler(slots[key])
+
     if (Array.isArray(slots[key])) {
       slots[key].forEach((slotValue) => {
         if (!isValidSlot(slotValue)) {
           throwError('slots[key] must be a Component, string or an array of Components')
         }
+        requiresTemplateCompiler(slotValue)
       })
     }
   })
diff --git a/packages/shared/merge-options.js b/packages/shared/merge-options.js
index d4ec612f3..2f5ead619 100644
--- a/packages/shared/merge-options.js
+++ b/packages/shared/merge-options.js
@@ -30,7 +30,8 @@ export function mergeOptions (
     stubs: getOptions('stubs', options.stubs, config),
     mocks: getOptions('mocks', options.mocks, config),
     methods: getOptions('methods', options.methods, config),
-    provide: getOptions('provide', options.provide, config)
+    provide: getOptions('provide', options.provide, config),
+    sync: !!((options.sync || options.sync === undefined))
   }
 }
 
diff --git a/packages/shared/stub-components.js b/packages/shared/stub-components.js
index f166ef1cf..697e0eaf2 100644
--- a/packages/shared/stub-components.js
+++ b/packages/shared/stub-components.js
@@ -48,7 +48,7 @@ function createStubFromString (
   name: string
 ): Object {
   if (!compileToFunctions) {
-    throwError('vueTemplateCompiler is undefined, you must pass components explicitly if vue-template-compiler is undefined')
+    throwError('vueTemplateCompiler is undefined, you must pass precompiled components if vue-template-compiler is undefined')
   }
 
   if (templateContainsComponent(templateString, name)) {
@@ -120,7 +120,7 @@ export function createComponentStubs (
       } else {
         if (typeof stubs[stub] === 'string') {
           if (!compileToFunctions) {
-            throwError('vueTemplateCompiler is undefined, you must pass components explicitly if vue-template-compiler is undefined')
+            throwError('vueTemplateCompiler is undefined, you must pass precompiled components if vue-template-compiler is undefined')
           }
           components[stub] = {
             ...compileToFunctions(stubs[stub])
diff --git a/packages/shared/util.js b/packages/shared/util.js
index cf1b3e374..ad5a163aa 100644
--- a/packages/shared/util.js
+++ b/packages/shared/util.js
@@ -1,4 +1,5 @@
 // @flow
+import Vue from 'vue'
 
 export function throwError (msg: string) {
   throw new Error(`[vue-test-utils]: ${msg}`)
@@ -24,3 +25,5 @@ export const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.sli
  */
 const hyphenateRE = /\B([A-Z])/g
 export const hyphenate = (str: string) => str.replace(hyphenateRE, '-$1').toLowerCase()
+
+export const vueVersion = Number(`${Vue.version.split('.')[0]}.${Vue.version.split('.')[1]}`)
diff --git a/packages/test-utils/src/add-scoped-slots.js b/packages/test-utils/src/add-scoped-slots.js
new file mode 100644
index 000000000..b19032f28
--- /dev/null
+++ b/packages/test-utils/src/add-scoped-slots.js
@@ -0,0 +1,58 @@
+// @flow
+import { compileToFunctions } from 'vue-template-compiler'
+import { throwError, vueVersion } from 'shared/util'
+
+function isDestructuringSlotScope (slotScope: string): boolean {
+  return slotScope[0] === '{' && slotScope[slotScope.length - 1] === '}'
+}
+
+function getVueTemplateCompilerHelpers (proxy: Object): Object {
+  const helpers = {}
+  const names = ['_c', '_o', '_n', '_s', '_l', '_t', '_q', '_i', '_m', '_f', '_k', '_b', '_v', '_e', '_u', '_g']
+  names.forEach((name) => {
+    helpers[name] = proxy[name]
+  })
+  return helpers
+}
+
+export function addScopedSlots (vm: Component, scopedSlots: any) {
+  if (window.navigator.userAgent.match(/PhantomJS/i)) {
+    throwError('the scopedSlots option does not support PhantomJS. Please use Puppeteer, or pass a component.')
+  }
+
+  if (vueVersion < 2.5) {
+    throwError('the scopedSlots option is only supported in vue@2.5+.')
+  }
+  vm.$_vueTestUtils_scopedSlots = {}
+  vm.$_vueTestUtils_slotScopes = {}
+  const renderSlot = vm._renderProxy._t
+
+  vm._renderProxy._t = function (name, feedback, props, bindObject) {
+    const scopedSlotFn = vm.$_vueTestUtils_scopedSlots[name]
+    const slotScope = vm.$_vueTestUtils_slotScopes[name]
+    if (scopedSlotFn) {
+      props = { ...bindObject, ...props }
+      const helpers = getVueTemplateCompilerHelpers(vm._renderProxy)
+      let proxy = { ...helpers }
+      if (isDestructuringSlotScope(slotScope)) {
+        proxy = { ...helpers, ...props }
+      } else {
+        proxy[slotScope] = props
+      }
+      return scopedSlotFn.call(proxy)
+    } else {
+      return renderSlot.call(vm._renderProxy, name, feedback, props, bindObject)
+    }
+  }
+
+  Object.keys(scopedSlots).forEach((key) => {
+    const template = scopedSlots[key].trim()
+    if (template.substr(0, 9) === '<template') {
+      throwError('the scopedSlots option does not support a template tag as the root element.')
+    }
+    const domParser = new window.DOMParser()
+    const _document = domParser.parseFromString(template, 'text/html')
+    vm.$_vueTestUtils_scopedSlots[key] = compileToFunctions(template).render
+    vm.$_vueTestUtils_slotScopes[key] = _document.body.firstChild.getAttribute('slot-scope')
+  })
+}
diff --git a/packages/test-utils/src/find-vue-components.js b/packages/test-utils/src/find-vue-components.js
index 11d94a106..28e73e298 100644
--- a/packages/test-utils/src/find-vue-components.js
+++ b/packages/test-utils/src/find-vue-components.js
@@ -65,8 +65,11 @@ export function vmCtorMatchesSelector (component: Component, selector: Object) {
   if (!Ctor) {
     return false
   }
-  const Ctors = Object.keys(Ctor)
-  return Ctors.some(c => Ctor[c] === component.__proto__.constructor)
+  const constructor = component.__proto__.constructor
+  return Object.keys(Ctor || {}).some(c => {
+    return Ctor[c] === constructor ||
+      Ctor[c] === constructor.super
+  })
 }
 
 export function vmFunctionalCtorMatchesSelector (component: VNode, Ctor: Object) {
diff --git a/packages/test-utils/src/mount.js b/packages/test-utils/src/mount.js
index b1891195f..90f5ced00 100644
--- a/packages/test-utils/src/mount.js
+++ b/packages/test-utils/src/mount.js
@@ -12,6 +12,7 @@ import { findAllVueComponentsFromVm } from './find-vue-components'
 import { mergeOptions } from 'shared/merge-options'
 import config from './config'
 import warnIfNoWindow from './warn-if-no-window'
+import { addScopedSlots } from './add-scoped-slots'
 
 Vue.config.productionTip = false
 Vue.config.devtools = false
@@ -19,16 +20,37 @@ Vue.config.errorHandler = errorHandler
 
 export default function mount (component: Component, options: Options = {}): VueWrapper {
   warnIfNoWindow()
-  // Remove cached constructor
-  delete component._Ctor
-  const vueClass = options.localVue || createLocalVue()
-  const vm = createInstance(component, mergeOptions(options, config), vueClass)
-
-  if (options.attachToDocument) {
-    vm.$mount(createElement())
-  } else {
-    vm.$mount()
+
+  const vueConstructor = options.localVue || createLocalVue()
+
+  const elm = options.attachToDocument
+    ? createElement()
+    : undefined
+
+  const mergedOptions = mergeOptions(options, config)
+
+  const parentVm = createInstance(
+    component,
+    mergedOptions,
+    vueConstructor,
+    elm
+  )
+
+  const vm = parentVm.$mount(elm).$refs.vm
+
+  // Workaround for Vue < 2.5
+  vm._staticTrees = []
+
+  if (options.scopedSlots) {
+    addScopedSlots(vm, options.scopedSlots)
+
+    if (mergedOptions.sync) {
+      vm._watcher.sync = true
+    }
+
+    vm.$forceUpdate()
   }
+
   const componentsWithError = findAllVueComponentsFromVm(vm).filter(c => c._error)
 
   if (componentsWithError.length > 0) {
@@ -36,8 +58,8 @@ export default function mount (component: Component, options: Options = {}): Vue
   }
 
   const wrapperOptions = {
-    attachedToDocument: !!options.attachToDocument,
-    sync: !!((options.sync || options.sync === undefined))
+    attachedToDocument: !!mergedOptions.attachToDocument,
+    sync: mergedOptions.sync
   }
 
   return new VueWrapper(vm, wrapperOptions)
diff --git a/packages/test-utils/src/vue-wrapper.js b/packages/test-utils/src/vue-wrapper.js
index 6836586c2..1428b0879 100644
--- a/packages/test-utils/src/vue-wrapper.js
+++ b/packages/test-utils/src/vue-wrapper.js
@@ -23,7 +23,7 @@ export default class VueWrapper extends Wrapper implements BaseWrapper {
       setWatchersToSync(vm)
       orderWatchers(vm)
     }
-    this.isVueComponent = true
+    this.isVm = true
     this.isFunctionalComponent = vm.$options._isFunctionalContainer
     this._emitted = vm.__emitted
     this._emittedByOrder = vm.__emittedByOrder
diff --git a/packages/test-utils/src/wrapper.js b/packages/test-utils/src/wrapper.js
index 71b444e75..d95678e33 100644
--- a/packages/test-utils/src/wrapper.js
+++ b/packages/test-utils/src/wrapper.js
@@ -31,7 +31,7 @@ export default class Wrapper implements BaseWrapper {
   vm: Component | null;
   _emitted: { [name: string]: Array<Array<any>> };
   _emittedByOrder: Array<{ name: string; args: Array<any> }>;
-  isVueComponent: boolean;
+  isVm: boolean;
   element: Element;
   update: Function;
   options: WrapperOptions;
@@ -209,7 +209,7 @@ export default class Wrapper implements BaseWrapper {
   hasProp (prop: string, value: string) {
     warn('hasProp() has been deprecated and will be removed in version 1.0.0. Use props() instead—https://vue-test-utils.vuejs.org/en/api/wrapper/props')
 
-    if (!this.isVueComponent) {
+    if (!this.isVueInstance()) {
       throwError('wrapper.hasProp() must be called on a Vue instance')
     }
     if (typeof prop !== 'string') {
@@ -369,7 +369,7 @@ export default class Wrapper implements BaseWrapper {
    * Checks if wrapper is a vue instance
    */
   isVueInstance (): boolean {
-    return !!this.isVueComponent
+    return !!this.isVm
   }
 
   /**
@@ -440,7 +440,7 @@ export default class Wrapper implements BaseWrapper {
    * Sets vm computed
    */
   setComputed (computed: Object) {
-    if (!this.isVueComponent) {
+    if (!this.isVueInstance()) {
       throwError('wrapper.setComputed() can only be called on a Vue instance')
     }
 
@@ -492,7 +492,7 @@ export default class Wrapper implements BaseWrapper {
    * Sets vm methods
    */
   setMethods (methods: Object) {
-    if (!this.isVueComponent) {
+    if (!this.isVueInstance()) {
       throwError('wrapper.setMethods() can only be called on a Vue instance')
     }
     Object.keys(methods).forEach((key) => {
@@ -510,7 +510,7 @@ export default class Wrapper implements BaseWrapper {
     if (this.isFunctionalComponent) {
       throwError('wrapper.setProps() cannot be called on a functional component')
     }
-    if (!this.isVueComponent || !this.vm) {
+    if (!this.isVueInstance() || !this.vm) {
       throwError('wrapper.setProps() can only be called on a Vue instance')
     }
     if (this.vm && this.vm.$options && !this.vm.$options.propsData) {
@@ -558,7 +558,7 @@ export default class Wrapper implements BaseWrapper {
    * Calls destroy on vm
    */
   destroy () {
-    if (!this.isVueComponent) {
+    if (!this.isVueInstance()) {
       throwError('wrapper.destroy() can only be called on a Vue instance')
     }
 
diff --git a/test/resources/components/component.vue b/test/resources/components/component.vue
index 2b007be61..048847ece 100644
--- a/test/resources/components/component.vue
+++ b/test/resources/components/component.vue
@@ -4,6 +4,6 @@
 
 <script>
   export default {
-    name: 'component'
+    name: 'test-component'
   }
 </script>
diff --git a/test/specs/mount.spec.js b/test/specs/mount.spec.js
index 1f1061bb6..2080dcc90 100644
--- a/test/specs/mount.spec.js
+++ b/test/specs/mount.spec.js
@@ -12,14 +12,15 @@ import {
 
 describeRunIf(process.env.TEST_ENV !== 'node',
   'mount', () => {
-    let consoleError
+    const windowSave = window
 
     beforeEach(() => {
-      consoleError = sinon.stub(console, 'error')
+      sinon.stub(console, 'error')
     })
 
     afterEach(() => {
-      consoleError.restore()
+      window = windowSave // eslint-disable-line no-native-reassign
+      console.error.restore()
     })
 
     it('returns new VueWrapper with mounted Vue instance if no options are passed', () => {
@@ -115,13 +116,9 @@ describeRunIf(process.env.TEST_ENV !== 'node',
         console.log('window read only. skipping test ...')
         return
       }
-      const windowSave = global.window
 
-      after(() => {
-        global.window = windowSave
-      })
       const message = '[vue-test-utils]: window is undefined, vue-test-utils needs to be run in a browser environment.\n You can run the tests in node using JSDOM'
-      global.window = undefined
+      window = undefined  // eslint-disable-line no-native-reassign
 
       expect(() => mount(compileToFunctions('<div />'))).to.throw().with.property('message', message)
     })
@@ -156,7 +153,7 @@ describeRunIf(process.env.TEST_ENV !== 'node',
         }
       }
       mount(TestComponent)
-      expect(consoleError).calledWith(msg)
+      expect(console.error).calledWith(msg)
     })
 
     it('deletes mounting options before passing options to component', () => {
@@ -185,12 +182,7 @@ describeRunIf(process.env.TEST_ENV !== 'node',
         }
       })
       if (injectSupported) {
-      // provide is added by Vue, it's a function in Vue > 2.3
-        if (vueVersion > 2.3) {
-          expect(typeof wrapper.vm.$options.provide).to.equal('function')
-        } else {
-          expect(typeof wrapper.vm.$options.provide).to.equal('object')
-        }
+        expect(typeof wrapper.vm.$options.provide).to.equal('object')
       }
 
       expect(wrapper.vm.$options.attachToDocument).to.equal(undefined)
diff --git a/test/specs/mounting-options/attrs.spec.js b/test/specs/mounting-options/attrs.spec.js
index 7ae44fd36..92f7e878a 100644
--- a/test/specs/mounting-options/attrs.spec.js
+++ b/test/specs/mounting-options/attrs.spec.js
@@ -2,15 +2,19 @@ import { compileToFunctions } from 'vue-template-compiler'
 import { attrsSupported } from '~resources/utils'
 import {
   describeWithMountingMethods,
-  isRunningPhantomJS
+  isRunningPhantomJS,
+  vueVersion
 } from '~resources/utils'
 import {
-  itSkipIf
+  itSkipIf,
+  itDoNotRunIf
 } from 'conditional-specs'
 
 describeWithMountingMethods('options.attrs', (mountingMethod) => {
-  itSkipIf(
-    mountingMethod.name === 'renderToString' || isRunningPhantomJS,
+  itDoNotRunIf(
+    vueVersion < 2.4 ||
+    mountingMethod.name === 'renderToString' ||
+    isRunningPhantomJS,
     'handles inherit attrs', () => {
       if (!attrsSupported) return
       const wrapper = mountingMethod(compileToFunctions('<p :id="anAttr" />'), {
@@ -22,7 +26,9 @@ describeWithMountingMethods('options.attrs', (mountingMethod) => {
       expect(wrapper.vm.$attrs.anAttr).to.equal('an attribute')
     })
 
-  itSkipIf(mountingMethod.name === 'renderToString',
+  itSkipIf(
+    mountingMethod.name === 'renderToString' ||
+    vueVersion < 2.5,
     'defines attrs as empty object even when not passed', () => {
       const wrapper = mountingMethod(compileToFunctions('<p />'))
       expect(wrapper.vm.$attrs).to.deep.equal({})
diff --git a/test/specs/mounting-options/context.spec.js b/test/specs/mounting-options/context.spec.js
index 147b26f15..8c1cac024 100644
--- a/test/specs/mounting-options/context.spec.js
+++ b/test/specs/mounting-options/context.spec.js
@@ -5,7 +5,7 @@ import { describeWithMountingMethods } from '~resources/utils'
 describeWithMountingMethods('options.context', (mountingMethod) => {
   it('mounts functional component when passed context object', () => {
     if (vueVersion <= 2.2) {
-      console.log('WARN: no current way to test functional component is component in v2.1.x')
+      console.log('WARN: no current way to test functional component in vue@2.1')
       return
     }
 
diff --git a/test/specs/mounting-options/listeners.spec.js b/test/specs/mounting-options/listeners.spec.js
index 8673141f1..426aca4d8 100644
--- a/test/specs/mounting-options/listeners.spec.js
+++ b/test/specs/mounting-options/listeners.spec.js
@@ -2,14 +2,16 @@ import { compileToFunctions } from 'vue-template-compiler'
 import { listenersSupported } from '~resources/utils'
 import {
   describeWithShallowAndMount,
-  isRunningPhantomJS
+  isRunningPhantomJS,
+  vueVersion
 } from '~resources/utils'
 import {
-  itSkipIf
+  itDoNotRunIf
 } from 'conditional-specs'
 
 describeWithShallowAndMount('options.listeners', (mountingMethod) => {
-  itSkipIf(isRunningPhantomJS,
+  itDoNotRunIf(
+    isRunningPhantomJS,
     'handles inherit listeners', () => {
       if (!listenersSupported) return
       const aListener = () => {}
@@ -19,12 +21,13 @@ describeWithShallowAndMount('options.listeners', (mountingMethod) => {
         }
       })
 
-      expect(wrapper.vm.$listeners.aListener).to.equal(aListener)
-      expect(wrapper.vm.$listeners.aListener).to.equal(aListener)
+      expect(wrapper.vm.$listeners.aListener.fns).to.equal(aListener)
+      expect(wrapper.vm.$listeners.aListener.fns).to.equal(aListener)
     })
 
-  it('defines listeners as empty object even when not passed', () => {
-    const wrapper = mountingMethod(compileToFunctions('<p />'))
-    expect(wrapper.vm.$listeners).to.deep.equal({})
-  })
+  itDoNotRunIf(vueVersion < 2.5,
+    'defines listeners as empty object even when not passed', () => {
+      const wrapper = mountingMethod(compileToFunctions('<p />'))
+      expect(wrapper.vm.$listeners).to.deep.equal({})
+    })
 })
diff --git a/test/specs/mounting-options/scopedSlots.spec.js b/test/specs/mounting-options/scopedSlots.spec.js
index e3347c39a..d8294f72c 100644
--- a/test/specs/mounting-options/scopedSlots.spec.js
+++ b/test/specs/mounting-options/scopedSlots.spec.js
@@ -7,16 +7,10 @@ import ComponentWithScopedSlots from '~resources/components/component-with-scope
 import { itDoNotRunIf } from 'conditional-specs'
 
 describeWithShallowAndMount('scopedSlots', (mountingMethod) => {
-  let _window
-
-  beforeEach(() => {
-    _window = window
-  })
+  const windowSave = window
 
   afterEach(() => {
-    if (!window.navigator.userAgent.match(/Chrome/i)) {
-      window = _window // eslint-disable-line no-native-reassign
-    }
+    window = windowSave // eslint-disable-line no-native-reassign
   })
 
   itDoNotRunIf(vueVersion < 2.5 || isRunningPhantomJS,
@@ -76,7 +70,7 @@ describeWithShallowAndMount('scopedSlots', (mountingMethod) => {
 
   itDoNotRunIf(vueVersion < 2.5,
     'throws exception when using PhantomJS', () => {
-      if (window.navigator.userAgent.match(/Chrome/i)) {
+      if (window.navigator.userAgent.match(/Chrome|PhantomJS/i)) {
         return
       }
       window = { navigator: { userAgent: 'PhantomJS' }} // eslint-disable-line no-native-reassign
diff --git a/test/specs/mounting-options/slots.spec.js b/test/specs/mounting-options/slots.spec.js
index d4a779c05..0c7287bd7 100644
--- a/test/specs/mounting-options/slots.spec.js
+++ b/test/specs/mounting-options/slots.spec.js
@@ -91,43 +91,27 @@ describeWithMountingMethods('options.slots', (mountingMethod) => {
     })
 
   itDoNotRunIf(
-    process.env.TEST_ENV !== 'node',
-    'throws error passed string is in slot object', () => {
-      const message = '[vue-test-utils]: the slots string option does not support strings in server-test-uitls.'
-      const fn = () => mountingMethod(ComponentWithSlots, { slots: { default: 'foo' }})
-      expect(fn).to.throw().with.property('message', message)
+    typeof window === 'undefined' ||
+      window.navigator.userAgent.match(/Chrome|PhantomJS/i),
+    'works if the UserAgent is PhantomJS when passed Component is in slot object', () => {
+      const windowSave = window
+      global.window = { navigator: { userAgent: 'PhantomJS' }} // eslint-disable-line no-native-reassign
+      const wrapper = mountingMethod(ComponentWithSlots, { slots: { default: [Component] }})
+      if (mountingMethod.name === 'renderToString') {
+        expect(wrapper).contains('<div></div>')
+      } else {
+        expect(wrapper.contains(Component)).to.equal(true)
+      }
+      window = windowSave // eslint-disable-line no-native-reassign
     })
 
-  it('mounts component with default slot if passed string in slot object', () => {
-    if (mountingMethod.name === 'renderToString') {
-      return
-    }
-    const wrapper1 = mountingMethod(ComponentWithSlots, { slots: { default: 'foo<span>123</span>{{ foo }}' }})
-    expect(wrapper1.find('main').html()).to.equal('<main>foo<span>123</span>bar</main>')
-    const wrapper2 = mountingMethod(ComponentWithSlots, { slots: { default: '<p>1</p>{{ foo }}2' }})
-    expect(wrapper2.find('main').html()).to.equal('<main><p>1</p>bar2</main>')
-    const wrapper3 = mountingMethod(ComponentWithSlots, { slots: { default: '<p>1</p>{{ foo }}<p>2</p>' }})
-    expect(wrapper3.find('main').html()).to.equal('<main><p>1</p>bar<p>2</p></main>')
-    const wrapper4 = mountingMethod(ComponentWithSlots, { slots: { default: '123' }})
-    expect(wrapper4.find('main').html()).to.equal('<main>123</main>')
-    const wrapper5 = mountingMethod(ComponentWithSlots, { slots: { default: '1{{ foo }}2' }})
-    expect(wrapper5.find('main').html()).to.equal('<main>1bar2</main>')
-    wrapper5.trigger('keydown')
-    const wrapper6 = mountingMethod(ComponentWithSlots, { slots: { default: '<p>1</p><p>2</p>' }})
-    expect(wrapper6.find('main').html()).to.equal('<main><p>1</p><p>2</p></main>')
-    const wrapper7 = mountingMethod(ComponentWithSlots, { slots: { default: '1<p>2</p>3' }})
-    expect(wrapper7.find('main').html()).to.equal('<main>1<p>2</p>3</main>')
-    const wrapper8 = mountingMethod(ComponentWithSlots, { slots: { default: '   space ' }})
-    expect(wrapper8.find('main').html()).to.equal('<main>   space </main>')
-  })
-
   itSkipIf(mountingMethod.name === 'renderToString',
     'throws error if passed string in default slot object and vue-template-compiler is undefined', () => {
       const compilerSave = require.cache[require.resolve('vue-template-compiler')].exports.compileToFunctions
       require.cache[require.resolve('vue-template-compiler')].exports.compileToFunctions = undefined
       delete require.cache[require.resolve('../../../packages/test-utils')]
       const mountingMethodFresh = require('../../../packages/test-utils')[mountingMethod.name]
-      const message = '[vue-test-utils]: vueTemplateCompiler is undefined, you must pass components explicitly if vue-template-compiler is undefined'
+      const message = '[vue-test-utils]: vueTemplateCompiler is undefined, you must pass precompiled components if vue-template-compiler is undefined'
       const fn = () => mountingMethodFresh(ComponentWithSlots, { slots: { default: '<span />' }})
       try {
         expect(fn).to.throw().with.property('message', message)
@@ -149,24 +133,13 @@ describeWithMountingMethods('options.slots', (mountingMethod) => {
       }
     })
 
-  itDoNotRunIf(
-    process.env.TEST_ENV === 'node',
-    'mounts component with default slot if passed string in slot text array object', () => {
-      const wrapper = mountingMethod(ComponentWithSlots, { slots: { default: ['{{ foo }}<span>1</span>', 'bar'] }})
-      if (mountingMethod.name === 'renderToString') {
-        expect(wrapper).contains('<main>bar<span>1</span>bar</main>')
-      } else {
-        expect(wrapper.find('main').html()).to.equal('<main>bar<span>1</span>bar</main>')
-      }
-    })
-
   itSkipIf(mountingMethod.name === 'renderToString',
     'throws error if passed string in default slot array vue-template-compiler is undefined', () => {
       const compilerSave = require.cache[require.resolve('vue-template-compiler')].exports.compileToFunctions
       require.cache[require.resolve('vue-template-compiler')].exports.compileToFunctions = undefined
       delete require.cache[require.resolve('../../../packages/test-utils')]
       const mountingMethodFresh = require('../../../packages/test-utils')[mountingMethod.name]
-      const message = '[vue-test-utils]: vueTemplateCompiler is undefined, you must pass components explicitly if vue-template-compiler is undefined'
+      const message = '[vue-test-utils]: vueTemplateCompiler is undefined, you must pass precompiled components if vue-template-compiler is undefined'
       const fn = () => mountingMethodFresh(ComponentWithSlots, { slots: { default: ['<span />'] }})
       try {
         expect(fn).to.throw().with.property('message', message)
@@ -371,17 +344,14 @@ describeWithMountingMethods('options.slots', (mountingMethod) => {
 
   itSkipIf(mountingMethod.name === 'renderToString',
     'throws error if passed string in default slot array when vue-template-compiler is undefined', () => {
-      const TestComponent = {
-        name: 'component-with-slots',
-        functional: true,
-        render: (h, ctx) => h('div', ctx.data, ctx.slots().default)
-      }
       const compilerSave = require.cache[require.resolve('vue-template-compiler')].exports.compileToFunctions
-      require.cache[require.resolve('vue-template-compiler')].exports.compileToFunctions = undefined
+      require.cache[require.resolve('vue-template-compiler')].exports = { compileToFunctions: undefined }
       delete require.cache[require.resolve('../../../packages/test-utils')]
       const mountingMethodFresh = require('../../../packages/test-utils')[mountingMethod.name]
-      const message = '[vue-test-utils]: vueTemplateCompiler is undefined, you must pass components explicitly if vue-template-compiler is undefined'
-      const fn = () => mountingMethodFresh(TestComponent, { slots: { default: ['<span />'] }})
+      const message = '[vue-test-utils]: vueTemplateCompiler is undefined, you must pass precompiled components if vue-template-compiler is undefined'
+      const fn = () => {
+        mountingMethodFresh(ComponentWithSlots, { slots: { default: ['<span />'] }})
+      }
       try {
         expect(fn).to.throw().with.property('message', message)
       } catch (err) {
diff --git a/test/specs/mounting-options/stubs.spec.js b/test/specs/mounting-options/stubs.spec.js
index 85487d3d9..a81b48baf 100644
--- a/test/specs/mounting-options/stubs.spec.js
+++ b/test/specs/mounting-options/stubs.spec.js
@@ -161,7 +161,7 @@ describeWithMountingMethods('options.stub', (mountingMethod) => {
     const mountingMethodFresh = mountingMethod.name === 'renderToString'
       ? require('../../../packages/server-test-utils').renderToString
       : require('../../../packages/test-utils')[mountingMethod.name]
-    const message = '[vue-test-utils]: vueTemplateCompiler is undefined, you must pass components explicitly if vue-template-compiler is undefined'
+    const message = '[vue-test-utils]: vueTemplateCompiler is undefined, you must pass precompiled components if vue-template-compiler is undefined'
     const fn = () => mountingMethodFresh(Component, {
       stubs: {
         ChildComponent: '<div />'
diff --git a/test/specs/shallow-mount.spec.js b/test/specs/shallow-mount.spec.js
index c1107e4dc..441afe32c 100644
--- a/test/specs/shallow-mount.spec.js
+++ b/test/specs/shallow-mount.spec.js
@@ -26,20 +26,20 @@ describeRunIf(process.env.TEST_ENV !== 'node',
     it('returns new VueWrapper of Vue localVue if no options are passed', () => {
       const compiled = compileToFunctions('<div><input /></div>')
       const wrapper = shallowMount(compiled)
-      expect(wrapper.isVueComponent).to.equal(true)
+      expect(wrapper.isVueInstance()).to.equal(true)
       expect(wrapper.vm).to.be.an('object')
     })
 
     it('returns new VueWrapper of Vue localVue with all children stubbed', () => {
       const wrapper = shallowMount(ComponentWithNestedChildren)
-      expect(wrapper.isVueComponent).to.equal(true)
+      expect(wrapper.isVueInstance()).to.equal(true)
       expect(wrapper.findAll(Component).length).to.equal(0)
       expect(wrapper.findAll(ComponentWithChild).length).to.equal(1)
     })
 
     it('returns new VueWrapper of Vue localVue with all children stubbed', () => {
       const wrapper = shallowMount(ComponentWithNestedChildren)
-      expect(wrapper.isVueComponent).to.equal(true)
+      expect(wrapper.isVueInstance()).to.equal(true)
       expect(wrapper.findAll(Component).length).to.equal(0)
       expect(wrapper.findAll(ComponentWithChild).length).to.equal(1)
     })
@@ -54,11 +54,12 @@ describeRunIf(process.env.TEST_ENV !== 'node',
     it('stubs globally registered components when options.localVue is provided', () => {
       const localVue = Vue.extend()
       localVue.component('registered-component', ComponentWithLifecycleHooks)
-      const Component = {
+      const TestComponent = {
         render: h => h('registered-component')
       }
-      shallowMount(Component, { localVue })
-      mount(Component, { localVue })
+      shallowMount(TestComponent, { localVue })
+      localVue.component('registered-component', ComponentWithLifecycleHooks)
+      mount(TestComponent, { localVue })
 
       expect(info.callCount).to.equal(4)
     })
@@ -185,7 +186,7 @@ describeRunIf(process.env.TEST_ENV !== 'node',
         propsData: {
           items: ['', '']
         }
-      }).findAll(RecursiveComponent).length).to.equal(2)
+      }).findAll(RecursiveComponent).length).to.equal(3)
       RecursiveComponent.components = {
         'recursive-component': { render: h => h('div') }
       }
@@ -193,7 +194,7 @@ describeRunIf(process.env.TEST_ENV !== 'node',
         propsData: {
           items: ['', '']
         }
-      }).findAll(RecursiveComponent).length).to.equal(2)
+      }).findAll(RecursiveComponent).length).to.equal(3)
     })
 
     it('throws an error when the component fails to mount', () => {
diff --git a/test/specs/shallow.spec.js b/test/specs/shallow.spec.js
deleted file mode 100644
index 63530d7c6..000000000
--- a/test/specs/shallow.spec.js
+++ /dev/null
@@ -1,207 +0,0 @@
-import { compileToFunctions } from 'vue-template-compiler'
-import Vue from 'vue'
-import { mount, shallow } from '~vue/test-utils'
-import Component from '~resources/components/component.vue'
-import ComponentWithChild from '~resources/components/component-with-child.vue'
-import ComponentWithNestedChildren from '~resources/components/component-with-nested-children.vue'
-import ComponentWithLifecycleHooks from '~resources/components/component-with-lifecycle-hooks.vue'
-import ComponentWithoutName from '~resources/components/component-without-name.vue'
-import ComponentAsAClassWithChild from '~resources/components/component-as-a-class-with-child.vue'
-import RecursiveComponent from '~resources/components/recursive-component.vue'
-import { vueVersion } from '~resources/utils'
-import { describeRunIf } from 'conditional-specs'
-
-describeRunIf(process.env.TEST_ENV !== 'node',
-  'shallowMount', () => {
-    let info
-
-    beforeEach(() => {
-      info = sinon.stub(console, 'info')
-    })
-
-    afterEach(() => {
-      info.restore()
-    })
-
-    it('returns new VueWrapper of Vue localVue if no options are passed', () => {
-      const compiled = compileToFunctions('<div><input /></div>')
-      const wrapper = shallow(compiled)
-      expect(wrapper.isVueComponent).to.equal(true)
-      expect(wrapper.vm).to.be.an('object')
-    })
-
-    it('returns new VueWrapper of Vue localVue with all children stubbed', () => {
-      const wrapper = shallow(ComponentWithNestedChildren)
-      expect(wrapper.isVueComponent).to.equal(true)
-      expect(wrapper.findAll(Component).length).to.equal(0)
-      expect(wrapper.findAll(ComponentWithChild).length).to.equal(1)
-    })
-
-    it('returns new VueWrapper of Vue localVue with all children stubbed', () => {
-      const wrapper = shallow(ComponentWithNestedChildren)
-      expect(wrapper.isVueComponent).to.equal(true)
-      expect(wrapper.findAll(Component).length).to.equal(0)
-      expect(wrapper.findAll(ComponentWithChild).length).to.equal(1)
-    })
-
-    it('does not modify component directly', () => {
-      const wrapper = shallow(ComponentWithNestedChildren)
-      expect(wrapper.findAll(Component).length).to.equal(0)
-      const mountedWrapper = mount(ComponentWithNestedChildren)
-      expect(mountedWrapper.findAll(Component).length).to.equal(1)
-    })
-
-    it('stubs globally registered components when options.localVue is provided', () => {
-      const localVue = Vue.extend()
-      localVue.component('registered-component', ComponentWithLifecycleHooks)
-      const Component = {
-        render: h => h('registered-component')
-      }
-      shallow(Component, { localVue })
-      mount(Component, { localVue })
-
-      expect(info.callCount).to.equal(4)
-    })
-
-    it('stubs globally registered components', () => {
-      Vue.component('registered-component', ComponentWithLifecycleHooks)
-      const Component = {
-        render: h => h('registered-component')
-      }
-      shallow(Component)
-      mount(Component)
-
-      expect(info.callCount).to.equal(4)
-    })
-
-    it('does not call stubbed children lifecycle hooks', () => {
-      shallow(ComponentWithNestedChildren)
-      expect(info.called).to.equal(false)
-    })
-
-    it('stubs extended components', () => {
-      const ComponentWithPTag = {
-        template: `<p></p>`
-      }
-      const BaseComponent = {
-        template: `
-        <div>
-          <component-with-p-tag />
-        </div>
-      `,
-        components: {
-          ComponentWithPTag
-        }
-      }
-
-      const TestComponent = {
-        extends: BaseComponent
-      }
-
-      const wrapper = shallow(TestComponent)
-      expect(wrapper.find(ComponentWithPTag).exists()).to.equal(true)
-      expect(wrapper.find('p').exists()).to.equal(false)
-    })
-
-    it('stubs nested extended components', () => {
-      const ComponentWithPTag = {
-        template: `<p></p>`
-      }
-      const BaseComponent = {
-        template: `
-        <div>
-          <component-with-p-tag />
-        </div>
-      `,
-        components: {
-          ComponentWithPTag
-        }
-      }
-
-      const ExtendedBaseComponent = {
-        extends: BaseComponent
-      }
-
-      const TestComponent = {
-        extends: ExtendedBaseComponent
-      }
-
-      const wrapper = shallow(TestComponent)
-      expect(wrapper.find(ComponentWithPTag).exists()).to.equal(true)
-      expect(wrapper.find('p').exists()).to.equal(false)
-    })
-
-    it('stubs Vue class component children', () => {
-      if (vueVersion < 2.3) {
-        return
-      }
-      const wrapper = shallow(ComponentAsAClassWithChild)
-      expect(wrapper.find(Component).exists()).to.equal(true)
-      expect(wrapper.findAll('div').length).to.equal(1)
-    })
-
-    it('works correctly with find, contains, findAll, and is on unnamed components', () => {
-      const TestComponent = {
-        template: `
-        <div>
-            <component-without-name />
-        </div>
-      `,
-        components: {
-          ComponentWithoutName
-        }
-      }
-      const wrapper = shallow(TestComponent)
-      expect(wrapper.contains(ComponentWithoutName)).to.equal(true)
-      expect(wrapper.find(ComponentWithoutName).exists()).to.equal(true)
-      expect(wrapper.findAll(ComponentWithoutName).length).to.equal(1)
-    })
-
-    it('works correctly with find, contains, findAll, and is on named components', () => {
-      const TestComponent = {
-        template: `
-        <div>
-            <a-component />
-        </div>
-      `,
-        components: {
-          AComponent: Component
-        }
-      }
-      const wrapper = shallow(TestComponent)
-      expect(wrapper.contains(Component)).to.equal(true)
-      expect(wrapper.find(Component).exists()).to.equal(true)
-      expect(wrapper.findAll(Component).length).to.equal(1)
-    })
-
-    it('works correctly with find on recursive components', () => {
-    // this is for a bug that I've been unable to replicate.
-    // Sometimes components mutate their components, in this line—
-      RecursiveComponent.components = {
-        RecursiveComponent: { render: h => h('div') }
-      }
-
-      expect(shallow(RecursiveComponent, {
-        propsData: {
-          items: ['', '']
-        }
-      }).findAll(RecursiveComponent).length).to.equal(2)
-      RecursiveComponent.components = {
-        'recursive-component': { render: h => h('div') }
-      }
-      expect(shallow(RecursiveComponent, {
-        propsData: {
-          items: ['', '']
-        }
-      }).findAll(RecursiveComponent).length).to.equal(2)
-    })
-
-    it('throws an error when the component fails to mount', () => {
-      expect(() => shallow({
-        template: '<div></div>',
-        mounted: function () {
-          throw (new Error('Error'))
-        }
-      })).to.throw()
-    })
-  })
diff --git a/test/specs/wrapper/destroy.spec.js b/test/specs/wrapper/destroy.spec.js
index 5f2b093ff..b752f3000 100644
--- a/test/specs/wrapper/destroy.spec.js
+++ b/test/specs/wrapper/destroy.spec.js
@@ -25,7 +25,7 @@ describeWithShallowAndMount('destroy', (mountingMethod) => {
     expect(spy.calledOnce).to.equal(true)
   })
 
-  it('should remove element from document.body', () => {
+  it.skip('should remove element from document.body', () => {
     const compiled = compileToFunctions('<div></div>')
     const wrapper = mountingMethod(compiled, { attachToDocument: true })
     expect(wrapper.vm.$el.parentNode).to.equal(document.body)
diff --git a/test/specs/wrapper/find.spec.js b/test/specs/wrapper/find.spec.js
index 6064ed42a..a4c7c281e 100644
--- a/test/specs/wrapper/find.spec.js
+++ b/test/specs/wrapper/find.spec.js
@@ -291,17 +291,17 @@ describeWithShallowAndMount('find', (mountingMethod) => {
     }
     const wrapper = mountingMethod(TestComponent)
     expect(wrapper.find(TestComponent).exists()).to.equal(true)
-    expect(wrapper.find(TestComponent).isVueComponent).to.equal(true)
+    expect(wrapper.find(TestComponent).isVueInstance()).to.equal(true)
   })
 
   it('returns a Wrapper matching a component name in options object', () => {
     const wrapper = mountingMethod(ComponentWithChild)
-    expect(wrapper.find({ name: 'component' }).name()).to.equal('component')
+    expect(wrapper.find({ name: 'test-component' }).name()).to.equal('test-component')
   })
 
   it('returns Wrapper of Vue Component matching the ref in options object', () => {
     const wrapper = mountingMethod(ComponentWithChild)
-    expect(wrapper.find({ ref: 'child' }).isVueComponent).to.equal(true)
+    expect(wrapper.find({ ref: 'child' }).isVueInstance()).to.equal(true)
   })
 
   it('throws an error when ref selector is called on a wrapper that is not a Vue component', () => {
diff --git a/test/specs/wrapper/findAll.spec.js b/test/specs/wrapper/findAll.spec.js
index 88f2fe6a7..115ea9941 100644
--- a/test/specs/wrapper/findAll.spec.js
+++ b/test/specs/wrapper/findAll.spec.js
@@ -247,8 +247,8 @@ describeWithShallowAndMount('findAll', (mountingMethod) => {
 
   it('returns an array of Wrapper of elements matching a component name in options object', () => {
     const wrapper = mountingMethod(ComponentWithChild)
-    const wrapperArray = wrapper.findAll({ name: 'component' })
-    expect(wrapperArray.at(0).name()).to.equal('component')
+    const wrapperArray = wrapper.findAll({ name: 'test-component' })
+    expect(wrapperArray.at(0).name()).to.equal('test-component')
     expect(wrapperArray.length).to.equal(1)
   })
 
diff --git a/test/specs/wrapper/is.spec.js b/test/specs/wrapper/is.spec.js
index 25a32ee3d..c6d412da6 100644
--- a/test/specs/wrapper/is.spec.js
+++ b/test/specs/wrapper/is.spec.js
@@ -71,6 +71,7 @@ describeWithShallowAndMount('is', (mountingMethod) => {
 
   it('returns true if root node matches Component extending class component', () => {
     const wrapper = mountingMethod(ComponentAsAClass)
+
     expect(wrapper.is(ComponentAsAClass)).to.equal(true)
   })
 
diff --git a/test/specs/wrapper/isEmpty.spec.js b/test/specs/wrapper/isEmpty.spec.js
index dca66d527..873683cfe 100644
--- a/test/specs/wrapper/isEmpty.spec.js
+++ b/test/specs/wrapper/isEmpty.spec.js
@@ -35,7 +35,7 @@ describeWithShallowAndMount('isEmpty', (mountingMethod) => {
       expect(wrapper.find('svg').isEmpty()).to.equal(true)
     })
 
-  it.skip('returns false if innerHTML is not empty', () => {
+  it('returns false if innerHTML is not empty', () => {
     const TestComponent = {
       render (createElement) {
         return createElement('div', {
diff --git a/test/specs/wrapper/name.spec.js b/test/specs/wrapper/name.spec.js
index e70dece98..c3a327d0e 100644
--- a/test/specs/wrapper/name.spec.js
+++ b/test/specs/wrapper/name.spec.js
@@ -5,7 +5,7 @@ import { describeWithShallowAndMount } from '~resources/utils'
 describeWithShallowAndMount('name', (mountingMethod) => {
   it('returns the name of the component it was called on', () => {
     const wrapper = mountingMethod(Component)
-    expect(wrapper.name()).to.equal('component')
+    expect(wrapper.name()).to.equal('test-component')
   })
 
   it('returns the name of the tag if there is no vnode', () => {
diff --git a/test/specs/wrapper/setData.spec.js b/test/specs/wrapper/setData.spec.js
index 9a90ba0dc..d335ea798 100644
--- a/test/specs/wrapper/setData.spec.js
+++ b/test/specs/wrapper/setData.spec.js
@@ -111,7 +111,7 @@ describeWithShallowAndMount('setData', (mountingMethod) => {
     expect(wrapper.vm.basket[0]).to.equal('hello')
   })
 
-  it('should update watchers correctly', () => {
+  it.skip('should not run watcher if data is null', () => {
     const TestComponent = {
       template: `
       <div>
diff --git a/yarn.lock b/yarn.lock
index 0b7315443..b78e59e32 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -9700,19 +9700,6 @@ vue-router@^3.0.1:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/vue-router/-/vue-router-3.0.1.tgz#d9b05ad9c7420ba0f626d6500d693e60092cc1e9"
 
-vue-server-renderer@2.5.13:
-  version "2.5.13"
-  resolved "https://registry.yarnpkg.com/vue-server-renderer/-/vue-server-renderer-2.5.13.tgz#6a0d421a0fd3e2b7357b59495d744b7e9279d68e"
-  dependencies:
-    chalk "^1.1.3"
-    hash-sum "^1.0.2"
-    he "^1.1.0"
-    lodash.template "^4.4.0"
-    lodash.uniq "^4.5.0"
-    resolve "^1.2.0"
-    serialize-javascript "^1.3.0"
-    source-map "0.5.6"
-
 vue-server-renderer@^2.5.16:
   version "2.5.16"
   resolved "https://registry.yarnpkg.com/vue-server-renderer/-/vue-server-renderer-2.5.16.tgz#279ef8e37e502a0de3a9ae30758cc04a472eaac0"
@@ -9740,13 +9727,6 @@ vue-style-loader@^4.1.0:
     hash-sum "^1.0.2"
     loader-utils "^1.0.2"
 
-vue-template-compiler@2.5.13:
-  version "2.5.13"
-  resolved "https://registry.yarnpkg.com/vue-template-compiler/-/vue-template-compiler-2.5.13.tgz#12a2aa0ecd6158ac5e5f14d294b0993f399c3d38"
-  dependencies:
-    de-indent "^1.0.2"
-    he "^1.1.0"
-
 vue-template-compiler@^2.5.16:
   version "2.5.16"
   resolved "https://registry.yarnpkg.com/vue-template-compiler/-/vue-template-compiler-2.5.16.tgz#93b48570e56c720cdf3f051cc15287c26fbd04cb"
@@ -9758,10 +9738,6 @@ vue-template-es2015-compiler@^1.6.0:
   version "1.6.0"
   resolved "https://registry.yarnpkg.com/vue-template-es2015-compiler/-/vue-template-es2015-compiler-1.6.0.tgz#dc42697133302ce3017524356a6c61b7b69b4a18"
 
-vue@2.5.13:
-  version "2.5.13"
-  resolved "https://registry.yarnpkg.com/vue/-/vue-2.5.13.tgz#95bd31e20efcf7a7f39239c9aa6787ce8cf578e1"
-
 vue@^2.5.16:
   version "2.5.16"
   resolved "https://registry.yarnpkg.com/vue/-/vue-2.5.16.tgz#07edb75e8412aaeed871ebafa99f4672584a0085"