Don't transfer props to mocked empty component

We currently automatically render empty components in place of mocks. However, we were accidentally transferring the props from the mocked descriptor to the empty component placeholder. Even children. This change just cleans that up and should only affect unit tests.

Author: sebmarkbage

src/core/instantiateReactComponent.js

@@ -26,47 +26,55 @@ var ReactLegacyDescriptor = require('ReactLegacyDescriptor');
 var ReactEmptyComponent = require('ReactEmptyComponent');
 
 /**
- * Given `type` and `props` invoke the type function and create an instance from
- * it. For the normal case it just runs the constructor. For mocks we need to
- * invoke the convenience constructor and resolve that into an instance.
+ * Given a `componentDescriptor` create an instance that will actually be
+ * mounted.
  *
- * @param {function} type
- * @param {*} props
- * @return {object} A new instance of `type`.
+ * @param {object} descriptor
+ * @return {object} A new instance of componentDescriptor's constructor.
  * @protected
  */
-function createInstance(type, props) {
+function instantiateReactComponent(descriptor) {
+ var instance;
+
  if (__DEV__) {
- if (type._mockedReactClassConstructor) {
+ warning(
+ descriptor && (typeof descriptor.type === 'function' ||
+ typeof descriptor.type === 'string'),
+ 'Only functions or strings can be mounted as React components.'
+ // Not really strings yet, but as soon as I solve the cyclic dep, they
+ // will be allowed here.
+ );
+
+ // Resolve mock instances
+ if (descriptor.type._mockedReactClassConstructor) {
  // If this is a mocked class, we treat the legacy factory as if it was the
  // class constructor for future proofing unit tests. Because this might
  // be mocked as a legacy factory, we ignore any warnings triggerd by
  // this temporary hack.
  ReactLegacyDescriptor._isLegacyCallWarningEnabled = false;
- var instance;
  try {
- instance = new type._mockedReactClassConstructor(props);
+ instance = new descriptor.type._mockedReactClassConstructor(
+ descriptor.props
+ );
  } finally {
  ReactLegacyDescriptor._isLegacyCallWarningEnabled = true;
  }
 
  // If the mock implementation was a legacy factory, then it returns a
  // descriptor. We need to turn this into a real component instance.
  if (ReactDescriptor.isValidDescriptor(instance)) {
- type = instance.type;
- props = instance.props;
- instance = new type(props);
+ instance = new instance.type(instance.props);
  }
 
  var render = instance.render;
  if (!render) {
  // For auto-mocked factories, the prototype isn't shimmed and therefore
  // there is no render function on the instance. We replace the whole
  // component with an empty component instance instead.
- var descriptor = ReactEmptyComponent.getEmptyComponent();
- type = descriptor.type;
- props = descriptor.props;
- instance = new type(props);
+ descriptor = ReactEmptyComponent.getEmptyComponent();
+ instance = new descriptor.type(descriptor.props);
+ instance.construct(descriptor);
+ return instance;
  } else if (render._isMockFunction && !render._getMockImplementation()) {
  // Auto-mocked components may have a prototype with a mocked render
  // function. For those, we'll need to mock the result of the render
@@ -75,32 +83,13 @@ function createInstance(type, props) {
  ReactEmptyComponent.getEmptyComponent
  );
  }
+ instance.construct(descriptor);
+ return instance;
  }
  }
- // Normal case for non-mocks
- return new type(props);
-}
-
-/**
- * Given a `componentDescriptor` create an instance that will actually be
- * mounted.
- *
- * @param {object} descriptor
- * @return {object} A new instance of componentDescriptor's constructor.
- * @protected
- */
-function instantiateReactComponent(descriptor) {
- if (__DEV__) {
- warning(
- descriptor && (typeof descriptor.type === 'function' ||
- typeof descriptor.type === 'string'),
- 'Only functions or strings can be mounted as React components.'
- // Not really strings yet, but as soon as I solve the cyclic dep, they
- // will be allowed here.
- );
- }
 
- var instance = createInstance(descriptor.type, descriptor.props);
+ // Normal case for non-mocks
+ instance = new descriptor.type(descriptor.props);
 
  if (__DEV__) {
  warning(
@@ -114,6 +103,7 @@ function instantiateReactComponent(descriptor) {
  // This actually sets up the internal instance. This will become decoupled
  // from the public instance in a future diff.
  instance.construct(descriptor);
+
  return instance;
 }