update tests

test/specs/addons/Confirm/Confirm-test.js

@@ -31,14 +31,18 @@ describe('Confirm', () => {
   common.implementsShorthandProp(Confirm, {
     autoGenerateKey: false,
     propKey: 'header',
+    rendersPortal: true,
     ShorthandComponent: Modal.Header,
     mapValueToProps: (content) => ({ content }),
+    requiredProps: { open: true },
   })
   common.implementsShorthandProp(Confirm, {
     autoGenerateKey: false,
     propKey: 'content',
+    rendersPortal: true,
     ShorthandComponent: Modal.Content,
     mapValueToProps: (content) => ({ content }),
+    requiredProps: { open: true },
   })
 
   describe('children', () => {

test/specs/commonTests/classNameHelpers.js

@@ -1,5 +1,5 @@
 import _ from 'lodash'
-import React, { createElement } from 'react'
+import React from 'react'
 
 import { consoleUtil } from 'test/utils'
 
@@ -8,24 +8,24 @@ export const classNamePropValueBeforePropName = (Component, propKey, propValues,
 
   propValues.forEach((propVal) => {
     it(`adds "${propVal} ${className}" to className`, () => {
-      shallow(createElement(Component, { ...requiredProps, [propKey]: propVal }), {
-        autoNesting: true,
-      }).should.have.className(`${propVal} ${className}`)
+      const wrapper = mount(
+        React.createElement(Component, { ...requiredProps, [propKey]: propVal }),
+      )
+      const elementClassName = wrapper.childAt(0).getDOMNode().className
+
+      expect(elementClassName).include(`${propVal} ${className}`)
     })
   })
 }
 
 export const noClassNameFromBoolProps = (Component, propKey, propValues, options = {}) => {
-  const { className = propKey, nestingLevel = 0, requiredProps = {} } = options
+  const { className = propKey, requiredProps = {} } = options
 
   _.each([true, false], (bool) =>
     it(`does not add any className when ${bool}`, () => {
       consoleUtil.disableOnce()
 
-      const wrapper = shallow(createElement(Component, { ...requiredProps, [propKey]: bool }), {
-        autoNesting: true,
-        nestingLevel,
-      })
+      const wrapper = mount(React.createElement(Component, { ...requiredProps, [propKey]: bool }))
 
       wrapper.should.not.have.className(className)
       wrapper.should.not.have.className('true')
@@ -38,15 +38,18 @@ export const noClassNameFromBoolProps = (Component, propKey, propValues, options
 
 export const noDefaultClassNameFromProp = (Component, propKey, propValues, options = {}) => {
   const { defaultProps = {} } = Component
-  const { className = propKey, nestingLevel = 0, requiredProps = {} } = options
+  const { className = propKey, requiredProps = {} } = options
+
   // required props may include a prop that creates a className
   // if so, we cannot assert that it doesn't exist by default because it is required to exist
   // skip assertions for required props
   if (propKey in defaultProps) return
   if (propKey in requiredProps) return
 
   it('is not included in className when not defined', () => {
-    const wrapper = shallow(<Component {...requiredProps} />, { autoNesting: true, nestingLevel })
+    consoleUtil.disableOnce()
+    const wrapper = mount(<Component {...requiredProps} />)
+
     wrapper.should.not.have.className(className)
 
     // ensure that none of the prop option values are in className

test/specs/commonTests/implementsClassNameProps.js

@@ -55,12 +55,11 @@ export const propKeyOnlyToClassName = (Component, propKey, options = {}) => {
 
       const element = React.createElement(Component, { ...requiredProps, [propKey]: true })
       const wrapper = mount(element)
+      const elementClassName = wrapper.childAt(0).getDOMNode().className
 
       // ".should.have.className" with "mount" renderer does not handle properly cases when "className" contains
-      // multiple classes. That's why ".split()" is required.
-      className.split(' ').forEach((classNamePart) => {
-        wrapper.childAt(0).should.have.className(classNamePart)
-      })
+      // multiple classes.
+      expect(elementClassName).include(className)
     })
 
     it('does not add prop value to className', () => {
@@ -100,15 +99,13 @@ export const propKeyOrValueAndKeyToClassName = (Component, propKey, propValues,
     })
 
     it('adds only the name to className when true', () => {
-      shallow(React.createElement(Component, { ...requiredProps, [propKey]: true }), {
-        autoNesting: true,
-      }).should.have.className(className)
+      const wrapper = mount(React.createElement(Component, { ...requiredProps, [propKey]: true }))
+
+      wrapper.should.have.className(className)
     })
 
     it('adds no className when false', () => {
-      const wrapper = shallow(
-        React.createElement(Component, { ...requiredProps, [propKey]: false }),
-      )
+      const wrapper = mount(React.createElement(Component, { ...requiredProps, [propKey]: false }))
 
       wrapper.should.not.have.className(className)
       wrapper.should.not.have.className('true')

test/specs/commonTests/implementsCommonProps.js

@@ -110,6 +110,7 @@ export const implementsHTMLLabelProp = (Component, options = {}) => {
  */
 export const implementsIconProp = (Component, options = {}) => {
   implementsShorthandProp(Component, {
+    assertExactMatch: false,
     propKey: 'icon',
     ShorthandComponent: Icon,
     mapValueToProps: (val) => ({ name: val }),

test/specs/commonTests/implementsShorthandProp.js

@@ -1,5 +1,6 @@
 import _ from 'lodash'
-import React, { createElement } from 'react'
+import React from 'react'
+import ReactIs from 'react-is'
 
 import { createShorthand } from 'src/lib'
 import { consoleUtil, getComponentName } from 'test/utils'
@@ -28,6 +29,7 @@ const shorthandComponentName = (ShorthandComponent) => {
  * @param {function} options.mapValueToProps A function that maps a primitive value to the Component props.
  * @param {Boolean} [options.parentIsFragment=false] A flag that shows the type of the Component to test.
  * @param {Object} [options.requiredProps={}] Props required to render the component.
+ * @param {boolean} [options.rendersPortal=false] Does this component render a Portal powered component?
  * @param {Object} [options.shorthandDefaultProps] Default props for the shorthand component.
  * @param {Object} [options.shorthandOverrideProps] Override props for the shorthand component.
  */
@@ -39,13 +41,18 @@ export default (Component, options = {}) => {
     mapValueToProps,
     parentIsFragment = false,
     propKey,
-    ShorthandComponent,
     shorthandDefaultProps = {},
     shorthandOverrideProps = {},
+    rendersPortal = false,
     requiredProps = {},
   } = options
   const { assertRequired } = helpers('implementsShorthandProp', Component)
-  const assertMethod = assertExactMatch ? 'contain' : 'containMatchingElement'
+
+  const assertMethod = assertExactMatch ? 'equals' : 'matchesElement'
+  const ShorthandComponent =
+    options.ShorthandComponent.$$typeof === ReactIs.Memo
+      ? options.ShorthandComponent.type
+      : options.ShorthandComponent
 
   describe(`${propKey} shorthand prop (common)`, () => {
     assertRequired(Component, 'a `Component`')
@@ -60,39 +67,44 @@ export default (Component, options = {}) => {
         overrideProps: shorthandOverrideProps,
         autoGenerateKey,
       })
-      const element = createElement(Component, { ...requiredProps, [propKey]: value })
-      const wrapper = shallow(element)
+      const wrapper = mount(React.createElement(Component, { ...requiredProps, [propKey]: value }))
+
+      const result = wrapper.find(ShorthandComponent)
 
-      wrapper.should[assertMethod](expectedShorthandElement)
+      expect(result[assertMethod](expectedShorthandElement)).to.equal(true)
 
       // Enzyme's .key() method is not consistent with React for elements with
       // no key (`undefined` vs `null`), so use the underlying element instead
       // Will fail if more than one element of this type is found
       if (autoGenerateKey) {
-        const shorthandElement = wrapper.find(ShorthandComponent).getElement()
-        expect(shorthandElement.key).to.equal(expectedShorthandElement.key, "key doesn't match")
+        expect(result.getElement().key).to.equal(expectedShorthandElement.key, "key doesn't match")
       }
     }
 
     if (alwaysPresent || (Component.defaultProps && Component.defaultProps[propKey])) {
       it(`has default ${name} when not defined`, () => {
-        shallow(<Component {...requiredProps} />).should.have.descendants(ShorthandComponent)
+        const wrapper = mount(React.createElement(Component, requiredProps))
+
+        wrapper.should.have.descendants(ShorthandComponent)
       })
     } else {
-      if (!parentIsFragment) {
+      if (!parentIsFragment && !rendersPortal) {
         noDefaultClassNameFromProp(Component, propKey, [], options)
       }
 
       it(`has no ${name} when not defined`, () => {
-        shallow(<Component {...requiredProps} />).should.not.have.descendants(ShorthandComponent)
+        const wrapper = mount(React.createElement(Component, requiredProps))
+
+        wrapper.should.not.have.descendants(ShorthandComponent)
       })
     }
 
     if (!alwaysPresent) {
       it(`has no ${name} when null`, () => {
-        shallow(
-          createElement(Component, { ...requiredProps, [propKey]: null }),
-        ).should.not.have.descendants(ShorthandComponent)
+        const element = React.createElement(Component, { ...requiredProps, [propKey]: null })
+        const wrapper = mount(element)
+
+        wrapper.should.not.have.descendants(ShorthandComponent)
       })
     }