Apply codemod for React -> ReactDOM split

Ran the codemod automatically then ran

```
codemod.py -m -d src '(var React\b[^\n]*;)\n\n(var ReactDOM)' '\1\n\2'
```

to clean up spacing of requires.

src/addons/__tests__/ReactFragment-test.js

@@ -12,12 +12,14 @@
 'use strict';
 
 var React;
+var ReactDOM;
 var ReactFragment;
 
 describe('ReactFragment', function() {
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactFragment = require('ReactFragment');
   });
 
@@ -54,7 +56,7 @@ describe('ReactFragment', function() {
     var element = <div>{[children]}</div>;
     expect(console.error.calls.length).toBe(0);
     var container = document.createElement('div');
-    React.render(element, container);
+    ReactDOM.render(element, container);
     expect(console.error.calls.length).toBe(1);
     expect(console.error.calls[0].args[0]).toContain(
       'Any use of a keyed object'
@@ -78,7 +80,7 @@ describe('ReactFragment', function() {
     }
     expect(console.error.calls.length).toBe(0);
     var container = document.createElement('div');
-    React.render(<Foo />, container);
+    ReactDOM.render(<Foo />, container);
     expect(console.error.calls.length).toBe(1);
     expect(console.error.calls[0].args[0]).toContain(
       'Any use of a keyed object'

src/addons/transitions/ReactCSSTransitionGroupChild.js

@@ -13,6 +13,7 @@
 'use strict';
 
 var React = require('React');
+var ReactDOM = require('ReactDOM');
 
 var CSSCore = require('CSSCore');
 var ReactTransitionEvents = require('ReactTransitionEvents');
@@ -47,7 +48,7 @@ var ReactCSSTransitionGroupChild = React.createClass({
   displayName: 'ReactCSSTransitionGroupChild',
 
   transition: function(animationType, finishCallback) {
-    var node = React.findDOMNode(this);
+    var node = ReactDOM.findDOMNode(this);
 
     if (!node) {
       if (finishCallback) {
@@ -104,7 +105,7 @@ var ReactCSSTransitionGroupChild = React.createClass({
   flushClassNameQueue: function() {
     if (this.isMounted()) {
       this.classNameQueue.forEach(
-        CSSCore.addClass.bind(CSSCore, React.findDOMNode(this))
+        CSSCore.addClass.bind(CSSCore, ReactDOM.findDOMNode(this))
       );
     }
     this.classNameQueue.length = 0;

src/addons/transitions/__tests__/ReactCSSTransitionGroup-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React;
+var ReactDOM;
 var ReactCSSTransitionGroup;
 
 // Most of the real functionality is covered in other unit tests, this just
@@ -21,6 +22,7 @@ describe('ReactCSSTransitionGroup', function() {
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactCSSTransitionGroup = require('ReactCSSTransitionGroup');
 
     container = document.createElement('div');
@@ -28,25 +30,25 @@ describe('ReactCSSTransitionGroup', function() {
   });
 
   it('should warn after time with no transitionend', function() {
-    var a = React.render(
+    var a = ReactDOM.render(
       <ReactCSSTransitionGroup transitionName="yolo">
         <span key="one" id="one" />
       </ReactCSSTransitionGroup>,
       container
     );
-    expect(React.findDOMNode(a).childNodes.length).toBe(1);
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(1);
 
     setTimeout.mock.calls.length = 0;
 
-    React.render(
+    ReactDOM.render(
       <ReactCSSTransitionGroup transitionName="yolo">
         <span key="two" id="two" />
       </ReactCSSTransitionGroup>,
       container
     );
-    expect(React.findDOMNode(a).childNodes.length).toBe(2);
-    expect(React.findDOMNode(a).childNodes[0].id).toBe('two');
-    expect(React.findDOMNode(a).childNodes[1].id).toBe('one');
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(2);
+    expect(ReactDOM.findDOMNode(a).childNodes[0].id).toBe('two');
+    expect(ReactDOM.findDOMNode(a).childNodes[1].id).toBe('one');
 
     // For some reason jst is adding extra setTimeout()s and grunt test isn't,
     // so we need to do this disgusting hack.
@@ -57,31 +59,31 @@ describe('ReactCSSTransitionGroup', function() {
       }
     }
 
-    expect(React.findDOMNode(a).childNodes.length).toBe(2);
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(2);
     expect(console.error.argsForCall.length).toBe(1);
   });
 
   it('should keep both sets of DOM nodes around', function() {
-    var a = React.render(
+    var a = ReactDOM.render(
       <ReactCSSTransitionGroup transitionName="yolo">
         <span key="one" id="one" />
       </ReactCSSTransitionGroup>,
       container
     );
-    expect(React.findDOMNode(a).childNodes.length).toBe(1);
-    React.render(
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(1);
+    ReactDOM.render(
       <ReactCSSTransitionGroup transitionName="yolo">
         <span key="two" id="two" />
       </ReactCSSTransitionGroup>,
       container
     );
-    expect(React.findDOMNode(a).childNodes.length).toBe(2);
-    expect(React.findDOMNode(a).childNodes[0].id).toBe('two');
-    expect(React.findDOMNode(a).childNodes[1].id).toBe('one');
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(2);
+    expect(ReactDOM.findDOMNode(a).childNodes[0].id).toBe('two');
+    expect(ReactDOM.findDOMNode(a).childNodes[1].id).toBe('one');
   });
 
   it('should switch transitionLeave from false to true', function() {
-    var a = React.render(
+    var a = ReactDOM.render(
       <ReactCSSTransitionGroup
           transitionName="yolo"
           transitionEnter={false}
@@ -90,8 +92,8 @@ describe('ReactCSSTransitionGroup', function() {
       </ReactCSSTransitionGroup>,
       container
     );
-    expect(React.findDOMNode(a).childNodes.length).toBe(1);
-    React.render(
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(1);
+    ReactDOM.render(
       <ReactCSSTransitionGroup
           transitionName="yolo"
           transitionEnter={false}
@@ -100,8 +102,8 @@ describe('ReactCSSTransitionGroup', function() {
       </ReactCSSTransitionGroup>,
       container
     );
-    expect(React.findDOMNode(a).childNodes.length).toBe(1);
-    React.render(
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(1);
+    ReactDOM.render(
       <ReactCSSTransitionGroup
           transitionName="yolo"
           transitionEnter={false}
@@ -110,20 +112,20 @@ describe('ReactCSSTransitionGroup', function() {
       </ReactCSSTransitionGroup>,
       container
     );
-    expect(React.findDOMNode(a).childNodes.length).toBe(2);
-    expect(React.findDOMNode(a).childNodes[0].id).toBe('three');
-    expect(React.findDOMNode(a).childNodes[1].id).toBe('two');
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(2);
+    expect(ReactDOM.findDOMNode(a).childNodes[0].id).toBe('three');
+    expect(ReactDOM.findDOMNode(a).childNodes[1].id).toBe('two');
   });
 
   it('should work with no children', function() {
-    React.render(
+    ReactDOM.render(
       <ReactCSSTransitionGroup transitionName="yolo" />,
       container
     );
   });
 
   it('should work with a null child', function() {
-    React.render(
+    ReactDOM.render(
       <ReactCSSTransitionGroup transitionName="yolo">
         {[null]}
       </ReactCSSTransitionGroup>,
@@ -132,14 +134,14 @@ describe('ReactCSSTransitionGroup', function() {
   });
 
   it('should transition from one to null', function() {
-    var a = React.render(
+    var a = ReactDOM.render(
       <ReactCSSTransitionGroup transitionName="yolo">
         <span key="one" id="one" />
       </ReactCSSTransitionGroup>,
       container
     );
-    expect(React.findDOMNode(a).childNodes.length).toBe(1);
-    React.render(
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(1);
+    ReactDOM.render(
       <ReactCSSTransitionGroup transitionName="yolo">
         {null}
       </ReactCSSTransitionGroup>,
@@ -147,26 +149,26 @@ describe('ReactCSSTransitionGroup', function() {
     );
     // (Here, we expect the original child to stick around but test that no
     // exception is thrown)
-    expect(React.findDOMNode(a).childNodes.length).toBe(1);
-    expect(React.findDOMNode(a).childNodes[0].id).toBe('one');
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(1);
+    expect(ReactDOM.findDOMNode(a).childNodes[0].id).toBe('one');
   });
 
   it('should transition from false to one', function() {
-    var a = React.render(
+    var a = ReactDOM.render(
       <ReactCSSTransitionGroup transitionName="yolo">
         {false}
       </ReactCSSTransitionGroup>,
       container
     );
-    expect(React.findDOMNode(a).childNodes.length).toBe(0);
-    React.render(
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(0);
+    ReactDOM.render(
       <ReactCSSTransitionGroup transitionName="yolo">
         <span key="one" id="one" />
       </ReactCSSTransitionGroup>,
       container
     );
-    expect(React.findDOMNode(a).childNodes.length).toBe(1);
-    expect(React.findDOMNode(a).childNodes[0].id).toBe('one');
+    expect(ReactDOM.findDOMNode(a).childNodes.length).toBe(1);
+    expect(ReactDOM.findDOMNode(a).childNodes[0].id).toBe('one');
   });
 
 });

src/addons/transitions/__tests__/ReactTransitionGroup-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React;
+var ReactDOM;
 var ReactTransitionGroup;
 
 // Most of the real functionality is covered in other unit tests, this just
@@ -21,6 +22,7 @@ describe('ReactTransitionGroup', function() {
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTransitionGroup = require('ReactTransitionGroup');
 
     container = document.createElement('div');
@@ -76,7 +78,7 @@ describe('ReactTransitionGroup', function() {
       },
     });
 
-    var instance = React.render(<Component />, container);
+    var instance = ReactDOM.render(<Component />, container);
     expect(log).toEqual(['didMount', 'willAppear', 'didAppear']);
 
     log = [];
@@ -133,7 +135,7 @@ describe('ReactTransitionGroup', function() {
       },
     });
 
-    var instance = React.render(<Component />, container);
+    var instance = ReactDOM.render(<Component />, container);
     expect(log).toEqual(['didMount']);
     instance.setState({count: 2});
     expect(log).toEqual(['didMount', 'didMount', 'willEnter']);
@@ -193,7 +195,7 @@ describe('ReactTransitionGroup', function() {
       },
     });
 
-    var instance = React.render(<Component />, container);
+    var instance = ReactDOM.render(<Component />, container);
     expect(log).toEqual(['didMount']);
     instance.setState({count: 2});
     expect(log).toEqual(['didMount', 'didMount', 'willEnter']);
@@ -250,7 +252,7 @@ describe('ReactTransitionGroup', function() {
       },
     });
 
-    var instance = React.render(<Component />, container);
+    var instance = ReactDOM.render(<Component />, container);
     expect(log).toEqual(['didMount0']);
     log = [];
 

src/isomorphic/classic/__tests__/ReactContextValidator-test.js

@@ -18,6 +18,7 @@
 'use strict';
 
 var React;
+var ReactDOM;
 var ReactTestUtils;
 
 var reactComponentExpect;
@@ -27,6 +28,7 @@ describe('ReactContextValidator', function() {
     require('mock-modules').dumpCache();
 
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
     reactComponentExpect = require('reactComponentExpect');
 
@@ -122,8 +124,8 @@ describe('ReactContextValidator', function() {
     });
 
     var container = document.createElement('div');
-    React.render(<Parent foo="abc" />, container);
-    React.render(<Parent foo="def" />, container);
+    ReactDOM.render(<Parent foo="abc" />, container);
+    ReactDOM.render(<Parent foo="def" />, container);
     expect(actualComponentWillReceiveProps).toEqual({foo: 'def'});
     expect(actualShouldComponentUpdate).toEqual({foo: 'def'});
     expect(actualComponentWillUpdate).toEqual({foo: 'def'});

src/isomorphic/classic/class/__tests__/ReactClass-test.js

@@ -14,12 +14,14 @@
 var mocks = require('mocks');
 
 var React;
+var ReactDOM;
 var ReactTestUtils;
 
 describe('ReactClass-spec', function() {
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
     spyOn(console, 'error');
   });
@@ -311,7 +313,7 @@ describe('ReactClass-spec', function() {
     });
 
     var container = document.createElement('div');
-    React.render(<Outer />, container);
+    ReactDOM.render(<Outer />, container);
     expect(container.firstChild.className).toBe('foo');
   });
 
@@ -372,7 +374,7 @@ describe('ReactClass-spec', function() {
     });
 
     var container = document.createElement('div');
-    var instance = React.render(<MyComponent />, container);
+    var instance = ReactDOM.render(<MyComponent />, container);
 
     instance.getDOMNode();
 

src/isomorphic/classic/element/__tests__/ReactElement-test.js

@@ -15,6 +15,7 @@
 // classic JS without JSX.
 
 var React;
+var ReactDOM;
 var ReactTestUtils;
 
 describe('ReactElement', function() {
@@ -24,6 +25,7 @@ describe('ReactElement', function() {
     require('mock-modules').dumpCache();
 
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
     ComponentClass = React.createClass({
       render: function() {
@@ -220,13 +222,13 @@ describe('ReactElement', function() {
     });
 
     var container = document.createElement('div');
-    var instance = React.render(
+    var instance = ReactDOM.render(
       React.createElement(Component, {fruit: 'mango'}),
       container
     );
     expect(instance.props.fruit).toBe('mango');
 
-    React.render(React.createElement(Component), container);
+    ReactDOM.render(React.createElement(Component), container);
     expect(instance.props.fruit).toBe('persimmon');
   });
 
@@ -265,7 +267,7 @@ describe('ReactElement', function() {
       },
     });
     var outer = ReactTestUtils.renderIntoDocument(<Outer color="orange" />);
-    expect(React.findDOMNode(outer).className).toBe('moo');
+    expect(ReactDOM.findDOMNode(outer).className).toBe('moo');
   });
 
   it('throws when adding a prop (in dev) after element creation', function() {
@@ -284,9 +286,9 @@ describe('ReactElement', function() {
         return el;
       },
     });
-    var outer = React.render(<Outer />, container);
-    expect(React.findDOMNode(outer).textContent).toBe('meow');
-    expect(React.findDOMNode(outer).className).toBe('');
+    var outer = ReactDOM.render(<Outer />, container);
+    expect(ReactDOM.findDOMNode(outer).textContent).toBe('meow');
+    expect(ReactDOM.findDOMNode(outer).className).toBe('');
   });
 
   it('does not warn for NaN props', function() {

src/isomorphic/classic/element/__tests__/ReactElementClone-test.js

@@ -14,12 +14,14 @@
 require('mock-modules');
 
 var React;
+var ReactDOM;
 var ReactTestUtils;
 
 describe('ReactElementClone', function() {
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
   });
 
@@ -39,7 +41,7 @@ describe('ReactElementClone', function() {
       },
     });
     var component = ReactTestUtils.renderIntoDocument(<Grandparent />);
-    expect(React.findDOMNode(component).childNodes[0].className).toBe('xyz');
+    expect(ReactDOM.findDOMNode(component).childNodes[0].className).toBe('xyz');
   });
 
   it('should clone a composite component with new props', function() {
@@ -63,7 +65,7 @@ describe('ReactElementClone', function() {
       },
     });
     var component = ReactTestUtils.renderIntoDocument(<Grandparent />);
-    expect(React.findDOMNode(component).childNodes[0].className).toBe('xyz');
+    expect(ReactDOM.findDOMNode(component).childNodes[0].className).toBe('xyz');
   });
 
   it('should keep the original ref if it is not overridden', function() {

src/isomorphic/classic/element/__tests__/ReactElementValidator-test.js

@@ -15,6 +15,7 @@
 // classic JS without JSX.
 
 var React;
+var ReactDOM;
 var ReactFragment;
 var ReactTestUtils;
 
@@ -25,6 +26,7 @@ describe('ReactElementValidator', function() {
     require('mock-modules').dumpCache();
 
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactFragment = require('ReactFragment');
     ReactTestUtils = require('ReactTestUtils');
     ComponentClass = React.createClass({
@@ -486,7 +488,7 @@ describe('ReactElementValidator', function() {
         return <div />;
       },
       componentDidMount: function() {
-        React.findDOMNode(this).appendChild(this.props.children);
+        ReactDOM.findDOMNode(this).appendChild(this.props.children);
       },
     });
 

src/isomorphic/deprecated/__tests__/cloneWithProps-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React;
+var ReactDOM;
 var ReactTestUtils;
 
 var onlyChild;
@@ -23,6 +24,7 @@ describe('cloneWithProps', function() {
   beforeEach(function() {
     require('mock-modules').dumpCache();
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
     onlyChild = require('onlyChild');
     cloneWithProps = require('cloneWithProps');
@@ -65,7 +67,7 @@ describe('cloneWithProps', function() {
       },
     });
     var component = ReactTestUtils.renderIntoDocument(<Grandparent />);
-    expect(React.findDOMNode(component).childNodes[0].className)
+    expect(ReactDOM.findDOMNode(component).childNodes[0].className)
       .toBe('xyz child');
   });
 
@@ -92,7 +94,7 @@ describe('cloneWithProps', function() {
       },
     });
     var component = ReactTestUtils.renderIntoDocument(<Grandparent />);
-    expect(React.findDOMNode(component).childNodes[0].className)
+    expect(ReactDOM.findDOMNode(component).childNodes[0].className)
       .toBe('xyz child');
   });
 

src/isomorphic/modern/class/__tests__/ReactES6Class-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React;
+var ReactDOM;
 
 describe('ReactES6Class', function() {
 
@@ -26,6 +27,7 @@ describe('ReactES6Class', function() {
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     container = document.createElement('div');
     attachedListener = null;
     renderedName = null;
@@ -42,7 +44,7 @@ describe('ReactES6Class', function() {
   });
 
   function test(element, expectedTag, expectedClassName) {
-    var instance = React.render(element, container);
+    var instance = ReactDOM.render(element, container);
     expect(container.firstChild).not.toBeNull();
     expect(container.firstChild.tagName).toBe(expectedTag);
     expect(container.firstChild.className).toBe(expectedClassName);
@@ -57,7 +59,7 @@ describe('ReactES6Class', function() {
   it('throws if no render function is defined', function() {
     spyOn(console, 'error');
     class Foo extends React.Component { }
-    expect(() => React.render(<Foo />, container)).toThrow();
+    expect(() => ReactDOM.render(<Foo />, container)).toThrow();
 
     expect(console.error.calls.length).toBe(1);
     expect(console.error.calls[0].args[0]).toBe(
@@ -308,7 +310,7 @@ describe('ReactES6Class', function() {
       'did-update', freeze({value: 'foo'}), {},
     ]);
     lifeCycles = []; // reset
-    React.unmountComponentAtNode(container);
+    ReactDOM.unmountComponentAtNode(container);
     expect(lifeCycles).toEqual([
       'will-unmount',
     ]);
@@ -456,7 +458,7 @@ describe('ReactES6Class', function() {
 
   it('supports drilling through to the DOM using findDOMNode', function() {
     var instance = test(<Inner name="foo" />, 'DIV', 'foo');
-    var node = React.findDOMNode(instance);
+    var node = ReactDOM.findDOMNode(instance);
     expect(node).toBe(container.firstChild);
   });
 

src/isomorphic/modern/element/__tests__/ReactJSXElement-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React;
+var ReactDOM;
 var ReactTestUtils;
 
 describe('ReactJSXElement', function() {
@@ -21,6 +22,7 @@ describe('ReactJSXElement', function() {
     require('mock-modules').dumpCache();
 
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
     Component = class {
       render() {
@@ -161,13 +163,13 @@ describe('ReactJSXElement', function() {
     Component.defaultProps = {fruit: 'persimmon'};
 
     var container = document.createElement('div');
-    var instance = React.render(
+    var instance = ReactDOM.render(
       <Component fruit="mango" />,
       container
     );
     expect(instance.props.fruit).toBe('mango');
 
-    React.render(<Component />, container);
+    ReactDOM.render(<Component />, container);
     expect(instance.props.fruit).toBe('persimmon');
   });
 

src/renderers/dom/client/__tests__/ReactDOM-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React = require('React');
+var ReactDOM = require('ReactDOM');
 var ReactTestUtils = require('ReactTestUtils');
 var div = React.createFactory('div');
 
@@ -48,14 +49,14 @@ describe('ReactDOM', function() {
   it('allows a DOM element to be used with a string', function() {
     var element = React.createElement('div', {className: 'foo'});
     var instance = ReactTestUtils.renderIntoDocument(element);
-    expect(React.findDOMNode(instance).tagName).toBe('DIV');
+    expect(ReactDOM.findDOMNode(instance).tagName).toBe('DIV');
   });
 
   it('should allow children to be passed as an argument', function() {
     var argDiv = ReactTestUtils.renderIntoDocument(
       div(null, 'child')
     );
-    var argNode = React.findDOMNode(argDiv);
+    var argNode = ReactDOM.findDOMNode(argDiv);
     expect(argNode.innerHTML).toBe('child');
   });
 
@@ -63,7 +64,7 @@ describe('ReactDOM', function() {
     var conflictDiv = ReactTestUtils.renderIntoDocument(
       div({children: 'fakechild'}, 'child')
     );
-    var conflictNode = React.findDOMNode(conflictDiv);
+    var conflictNode = ReactDOM.findDOMNode(conflictDiv);
     expect(conflictNode.innerHTML).toBe('child');
   });
 
@@ -105,7 +106,7 @@ describe('ReactDOM', function() {
         <div key="theBird" className="bird" />,
       </div>
     );
-    var root = React.findDOMNode(myDiv);
+    var root = ReactDOM.findDOMNode(myDiv);
     var dog = root.childNodes[0];
     expect(dog.className).toBe('bigdog');
   });

src/renderers/dom/client/__tests__/ReactDOMSVG-test.js

@@ -12,15 +12,17 @@
 'use strict';
 
 var React;
+var ReactDOMServer;
 
 describe('ReactDOMSVG', function() {
 
   beforeEach(function() {
     React = require('React');
+    ReactDOMServer = require('ReactDOMServer');
   });
 
   it('creates initial namespaced markup', function() {
-    var markup = React.renderToString(
+    var markup = ReactDOMServer.renderToString(
       <svg>
         <image xlinkHref="http://i.imgur.com/w7GCRPb.png" />
       </svg>

src/renderers/dom/client/__tests__/ReactEventListener-test.js

@@ -19,6 +19,8 @@ var EVENT_TARGET_PARAM = 1;
 describe('ReactEventListener', function() {
   var React;
 
+  var ReactDOM;
+
   var ReactMount;
   var ReactEventListener;
   var ReactTestUtils;
@@ -28,6 +30,8 @@ describe('ReactEventListener', function() {
     require('mock-modules').dumpCache();
     React = require('React');
 
+    ReactDOM = require('ReactDOM');
+
     ReactMount = require('ReactMount');
     ReactEventListener = require('ReactEventListener');
     ReactTestUtils = require('ReactTestUtils');
@@ -47,8 +51,8 @@ describe('ReactEventListener', function() {
         fromElement: otherNode,
         target: otherNode,
         srcElement: otherNode,
-        toElement: React.findDOMNode(component),
-        relatedTarget: React.findDOMNode(component),
+        toElement: ReactDOM.findDOMNode(component),
+        relatedTarget: ReactDOM.findDOMNode(component),
         view: window,
         path: [otherNode, otherNode],
       },
@@ -65,19 +69,19 @@ describe('ReactEventListener', function() {
       childControl = ReactMount.render(childControl, childContainer);
       parentControl =
         ReactMount.render(parentControl, parentContainer);
-      React.findDOMNode(parentControl).appendChild(childContainer);
+      ReactDOM.findDOMNode(parentControl).appendChild(childContainer);
 
       var callback = ReactEventListener.dispatchEvent.bind(null, 'test');
       callback({
-        target: React.findDOMNode(childControl),
+        target: ReactDOM.findDOMNode(childControl),
       });
 
       var calls = handleTopLevel.mock.calls;
       expect(calls.length).toBe(2);
       expect(calls[0][EVENT_TARGET_PARAM])
-        .toBe(React.findDOMNode(childControl));
+        .toBe(ReactDOM.findDOMNode(childControl));
       expect(calls[1][EVENT_TARGET_PARAM])
-        .toBe(React.findDOMNode(parentControl));
+        .toBe(ReactDOM.findDOMNode(parentControl));
     });
 
     it('should propagate events two levels down', function() {
@@ -92,22 +96,22 @@ describe('ReactEventListener', function() {
         ReactMount.render(parentControl, parentContainer);
       grandParentControl =
         ReactMount.render(grandParentControl, grandParentContainer);
-      React.findDOMNode(parentControl).appendChild(childContainer);
-      React.findDOMNode(grandParentControl).appendChild(parentContainer);
+      ReactDOM.findDOMNode(parentControl).appendChild(childContainer);
+      ReactDOM.findDOMNode(grandParentControl).appendChild(parentContainer);
 
       var callback = ReactEventListener.dispatchEvent.bind(null, 'test');
       callback({
-        target: React.findDOMNode(childControl),
+        target: ReactDOM.findDOMNode(childControl),
       });
 
       var calls = handleTopLevel.mock.calls;
       expect(calls.length).toBe(3);
       expect(calls[0][EVENT_TARGET_PARAM])
-        .toBe(React.findDOMNode(childControl));
+        .toBe(ReactDOM.findDOMNode(childControl));
       expect(calls[1][EVENT_TARGET_PARAM])
-        .toBe(React.findDOMNode(parentControl));
+        .toBe(ReactDOM.findDOMNode(parentControl));
       expect(calls[2][EVENT_TARGET_PARAM])
-        .toBe(React.findDOMNode(grandParentControl));
+        .toBe(ReactDOM.findDOMNode(grandParentControl));
     });
 
     it('should not get confused by disappearing elements', function() {
@@ -118,13 +122,13 @@ describe('ReactEventListener', function() {
       childControl = ReactMount.render(childControl, childContainer);
       parentControl =
         ReactMount.render(parentControl, parentContainer);
-      React.findDOMNode(parentControl).appendChild(childContainer);
+      ReactDOM.findDOMNode(parentControl).appendChild(childContainer);
 
       // ReactBrowserEventEmitter.handleTopLevel might remove the
       // target from the DOM. Here, we have handleTopLevel remove the
       // node when the first event handlers are called; we'll still
       // expect to receive a second call for the parent control.
-      var childNode = React.findDOMNode(childControl);
+      var childNode = ReactDOM.findDOMNode(childControl);
       handleTopLevel.mockImplementation(
         function(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent) {
           if (topLevelTarget === childNode) {
@@ -142,7 +146,7 @@ describe('ReactEventListener', function() {
       expect(calls.length).toBe(2);
       expect(calls[0][EVENT_TARGET_PARAM]).toBe(childNode);
       expect(calls[1][EVENT_TARGET_PARAM])
-        .toBe(React.findDOMNode(parentControl));
+        .toBe(ReactDOM.findDOMNode(parentControl));
     });
 
     it('should batch between handlers from different roots', function() {
@@ -156,11 +160,11 @@ describe('ReactEventListener', function() {
         <div>Parent</div>,
         parentContainer
       );
-      React.findDOMNode(parentControl).appendChild(childContainer);
+      ReactDOM.findDOMNode(parentControl).appendChild(childContainer);
 
       // Suppose an event handler in each root enqueues an update to the
       // childControl element -- the two updates should get batched together.
-      var childNode = React.findDOMNode(childControl);
+      var childNode = ReactDOM.findDOMNode(childControl);
       handleTopLevel.mockImplementation(
         function(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent) {
           ReactMount.render(
@@ -202,12 +206,12 @@ describe('ReactEventListener', function() {
 
     var callback = ReactEventListener.dispatchEvent.bind(null, 'test');
     callback({
-      target: React.findDOMNode(instance.getInner()),
+      target: ReactDOM.findDOMNode(instance.getInner()),
     });
 
     var calls = handleTopLevel.mock.calls;
     expect(calls.length).toBe(1);
     expect(calls[0][EVENT_TARGET_PARAM])
-      .toBe(React.findDOMNode(instance.getInner()));
+      .toBe(ReactDOM.findDOMNode(instance.getInner()));
   });
 });

src/renderers/dom/client/__tests__/ReactMount-test.js

@@ -15,6 +15,8 @@ var mocks = require('mocks');
 
 describe('ReactMount', function() {
   var React = require('React');
+  var ReactDOM = require('ReactDOM');
+  var ReactDOMServer = require('ReactDOMServer');
   var ReactMount = require('ReactMount');
   var ReactTestUtils = require('ReactTestUtils');
   var WebComponents = WebComponents;
@@ -33,7 +35,7 @@ describe('ReactMount', function() {
     it('throws when given a non-node', function() {
       var nodeArray = document.getElementsByTagName('div');
       expect(function() {
-        React.unmountComponentAtNode(nodeArray);
+        ReactDOM.unmountComponentAtNode(nodeArray);
       }).toThrow(
         'Invariant Violation: unmountComponentAtNode(...): Target container ' +
         'is not a DOM element.'
@@ -114,21 +116,21 @@ describe('ReactMount', function() {
 
   it('should reuse markup if rendering to the same target twice', function() {
     var container = document.createElement('container');
-    var instance1 = React.render(<div />, container);
-    var instance2 = React.render(<div />, container);
+    var instance1 = ReactDOM.render(<div />, container);
+    var instance2 = ReactDOM.render(<div />, container);
 
     expect(instance1 === instance2).toBe(true);
   });
 
   it('should warn if mounting into dirty rendered markup', function() {
     var container = document.createElement('container');
-    container.innerHTML = React.renderToString(<div />) + ' ';
+    container.innerHTML = ReactDOMServer.renderToString(<div />) + ' ';
 
     spyOn(console, 'error');
     ReactMount.render(<div />, container);
     expect(console.error.calls.length).toBe(1);
 
-    container.innerHTML = ' ' + React.renderToString(<div />);
+    container.innerHTML = ' ' + ReactDOMServer.renderToString(<div />);
 
     ReactMount.render(<div />, container);
     expect(console.error.calls.length).toBe(2);
@@ -158,12 +160,12 @@ describe('ReactMount', function() {
 
   it('should account for escaping on a checksum mismatch', function () {
     var div = document.createElement('div');
-    var markup = React.renderToString(
+    var markup = ReactDOMServer.renderToString(
       <div>This markup contains an nbsp entity: &nbsp; server text</div>);
     div.innerHTML = markup;
 
     spyOn(console, 'error');
-    React.render(
+    ReactDOM.render(
       <div>This markup contains an nbsp entity: &nbsp; client text</div>,
       div
     );
@@ -182,15 +184,15 @@ describe('ReactMount', function() {
         createdCallback: {
           value: function() {
             shadowRoot = this.createShadowRoot();
-            React.render(<div>Hi, from within a WC!</div>, shadowRoot);
+            ReactDOM.render(<div>Hi, from within a WC!</div>, shadowRoot);
             expect(shadowRoot.firstChild.tagName).toBe('DIV');
-            React.render(<span>Hi, from within a WC!</span>, shadowRoot);
+            ReactDOM.render(<span>Hi, from within a WC!</span>, shadowRoot);
             expect(shadowRoot.firstChild.tagName).toBe('SPAN');
           },
         },
       });
       proto.unmount = function() {
-        React.unmountComponentAtNode(shadowRoot);
+        ReactDOM.unmountComponentAtNode(shadowRoot);
       };
       document.registerElement('x-foo', {prototype: proto});
       var element = document.createElement('x-foo');

src/renderers/dom/client/__tests__/ReactMountDestruction-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React = require('React');
+var ReactDOM = require('ReactDOM');
 
 describe('ReactMount', function() {
   it('should destroy a react root upon request', function() {
@@ -24,7 +25,7 @@ describe('ReactMount', function() {
     );
     var firstRootDiv = document.createElement('div');
     mainContainerDiv.appendChild(firstRootDiv);
-    React.render(instanceOne, firstRootDiv);
+    ReactDOM.render(instanceOne, firstRootDiv);
 
     var instanceTwo = (
       <div className="secondReactDiv">
@@ -32,16 +33,16 @@ describe('ReactMount', function() {
     );
     var secondRootDiv = document.createElement('div');
     mainContainerDiv.appendChild(secondRootDiv);
-    React.render(instanceTwo, secondRootDiv);
+    ReactDOM.render(instanceTwo, secondRootDiv);
 
     // Test that two react roots are rendered in isolation
     expect(firstRootDiv.firstChild.className).toBe('firstReactDiv');
     expect(secondRootDiv.firstChild.className).toBe('secondReactDiv');
 
     // Test that after unmounting each, they are no longer in the document.
-    React.unmountComponentAtNode(firstRootDiv);
+    ReactDOM.unmountComponentAtNode(firstRootDiv);
     expect(firstRootDiv.firstChild).toBeNull();
-    React.unmountComponentAtNode(secondRootDiv);
+    ReactDOM.unmountComponentAtNode(secondRootDiv);
     expect(secondRootDiv.firstChild).toBeNull();
   });
 });

src/renderers/dom/client/__tests__/ReactRenderDocument-test.js

@@ -12,6 +12,8 @@
 'use strict';
 
 var React;
+var ReactDOM;
+var ReactDOMServer;
 var ReactInstanceMap;
 var ReactMount;
 
@@ -31,6 +33,8 @@ describe('rendering React components at document', function() {
     require('mock-modules').dumpCache();
 
     React = require('React');
+    ReactDOM = require('ReactDOM');
+    ReactDOMServer = require('ReactDOMServer');
     ReactInstanceMap = require('ReactInstanceMap');
     ReactMount = require('ReactMount');
     getTestDocument = require('getTestDocument');
@@ -56,9 +60,9 @@ describe('rendering React components at document', function() {
       },
     });
 
-    var markup = React.renderToString(<Root />);
+    var markup = ReactDOMServer.renderToString(<Root />);
     testDocument = getTestDocument(markup);
-    var component = React.render(<Root />, testDocument);
+    var component = ReactDOM.render(<Root />, testDocument);
     expect(testDocument.body.innerHTML).toBe('Hello world');
 
     // TODO: This is a bad test. I have no idea what this is testing.
@@ -85,13 +89,13 @@ describe('rendering React components at document', function() {
       },
     });
 
-    var markup = React.renderToString(<Root />);
+    var markup = ReactDOMServer.renderToString(<Root />);
     testDocument = getTestDocument(markup);
-    React.render(<Root />, testDocument);
+    ReactDOM.render(<Root />, testDocument);
     expect(testDocument.body.innerHTML).toBe('Hello world');
 
     expect(function() {
-      React.unmountComponentAtNode(testDocument);
+      ReactDOM.unmountComponentAtNode(testDocument);
     }).toThrow(UNMOUNT_INVARIANT_MESSAGE);
 
     expect(testDocument.body.innerHTML).toBe('Hello world');
@@ -130,16 +134,16 @@ describe('rendering React components at document', function() {
       },
     });
 
-    var markup = React.renderToString(<Component />);
+    var markup = ReactDOMServer.renderToString(<Component />);
     testDocument = getTestDocument(markup);
 
-    React.render(<Component />, testDocument);
+    ReactDOM.render(<Component />, testDocument);
 
     expect(testDocument.body.innerHTML).toBe('Hello world');
 
     // Reactive update
     expect(function() {
-      React.render(<Component2 />, testDocument);
+      ReactDOM.render(<Component2 />, testDocument);
     }).toThrow(UNMOUNT_INVARIANT_MESSAGE);
 
     expect(testDocument.body.innerHTML).toBe('Hello world');
@@ -163,12 +167,12 @@ describe('rendering React components at document', function() {
       },
     });
 
-    var markup = React.renderToString(
+    var markup = ReactDOMServer.renderToString(
       <Component text="Hello world" />
     );
     testDocument = getTestDocument(markup);
 
-    React.render(<Component text="Hello world" />, testDocument);
+    ReactDOM.render(<Component text="Hello world" />, testDocument);
 
     expect(testDocument.body.innerHTML).toBe('Hello world');
   });
@@ -191,14 +195,14 @@ describe('rendering React components at document', function() {
       },
     });
 
-    var markup = React.renderToString(
+    var markup = ReactDOMServer.renderToString(
       <Component text="Goodbye world" />
     );
     testDocument = getTestDocument(markup);
 
     expect(function() {
       // Notice the text is different!
-      React.render(<Component text="Hello world" />, testDocument);
+      ReactDOM.render(<Component text="Hello world" />, testDocument);
     }).toThrow(
       'Invariant Violation: ' +
       'You\'re trying to render a component to the document using ' +
@@ -235,7 +239,7 @@ describe('rendering React components at document', function() {
     });
 
     expect(function() {
-      React.render(<Component />, container);
+      ReactDOM.render(<Component />, container);
     }).toThrow(
       'Invariant Violation: You\'re trying to render a component to the ' +
       'document but you didn\'t use server rendering. We can\'t do this ' +
@@ -255,10 +259,10 @@ describe('rendering React components at document', function() {
         </body>
       </html>;
 
-    var markup = React.renderToString(tree);
+    var markup = ReactDOMServer.renderToString(tree);
     testDocument = getTestDocument(markup);
-    var component = React.render(tree, testDocument);
+    var component = ReactDOM.render(tree, testDocument);
     expect(testDocument.body.innerHTML).toBe('Hello world');
-    expect(React.findDOMNode(component).tagName).toBe('HTML');
+    expect(ReactDOM.findDOMNode(component).tagName).toBe('HTML');
   });
 });

src/renderers/dom/client/__tests__/findDOMNode-test.js

@@ -12,11 +12,12 @@
 'use strict';
 
 var React = require('React');
+var ReactDOM = require('ReactDOM');
 var ReactTestUtils = require('ReactTestUtils');
 
 describe('findDOMNode', function() {
   it('findDOMNode should return null if passed null', function() {
-    expect(React.findDOMNode(null)).toBe(null);
+    expect(ReactDOM.findDOMNode(null)).toBe(null);
   });
 
   it('findDOMNode should find dom element', function() {
@@ -27,15 +28,15 @@ describe('findDOMNode', function() {
     });
 
     var myNode = ReactTestUtils.renderIntoDocument(<MyNode />);
-    var myDiv = React.findDOMNode(myNode);
-    var mySameDiv = React.findDOMNode(myDiv);
+    var myDiv = ReactDOM.findDOMNode(myNode);
+    var mySameDiv = ReactDOM.findDOMNode(myDiv);
     expect(myDiv.tagName).toBe('DIV');
     expect(mySameDiv).toBe(myDiv);
   });
 
   it('findDOMNode should reject random objects', function() {
     expect(function() {
-      React.findDOMNode({foo: 'bar'});
+      ReactDOM.findDOMNode({foo: 'bar'});
     })
       .toThrow('Invariant Violation: Element appears to be neither ' +
         'ReactComponent nor DOMNode (keys: foo)'
@@ -44,7 +45,7 @@ describe('findDOMNode', function() {
 
   it('findDOMNode should reject unmounted objects with render func', function() {
     expect(function() {
-      React.findDOMNode({render: function() {}});
+      ReactDOM.findDOMNode({render: function() {}});
     })
       .toThrow('Invariant Violation: Component (with keys: render) ' +
         'contains `render` method but is not mounted in the DOM'

src/renderers/dom/client/eventPlugins/__tests__/EnterLeaveEventPlugin-test.js

@@ -14,6 +14,7 @@
 var EnterLeaveEventPlugin;
 var EventConstants;
 var React;
+var ReactDOM;
 var ReactMount;
 
 var topLevelTypes;
@@ -25,6 +26,7 @@ describe('EnterLeaveEventPlugin', function() {
     EnterLeaveEventPlugin = require('EnterLeaveEventPlugin');
     EventConstants = require('EventConstants');
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactMount = require('ReactMount');
 
     topLevelTypes = EventConstants.topLevelTypes;
@@ -41,8 +43,8 @@ describe('EnterLeaveEventPlugin', function() {
     );
     iframeDocument.close();
 
-    var component = React.render(<div />, iframeDocument.body.getElementsByTagName('div')[0]);
-    var div = React.findDOMNode(component);
+    var component = ReactDOM.render(<div />, iframeDocument.body.getElementsByTagName('div')[0]);
+    var div = ReactDOM.findDOMNode(component);
 
     var extracted = EnterLeaveEventPlugin.extractEvents(
       topLevelTypes.topMouseOver,

src/renderers/dom/client/eventPlugins/__tests__/SelectEventPlugin-test.js

@@ -13,6 +13,7 @@
 
 var EventConstants;
 var React;
+var ReactDOM;
 var ReactMount;
 var ReactTestUtils;
 var SelectEventPlugin;
@@ -33,6 +34,7 @@ describe('SelectEventPlugin', function() {
   beforeEach(function() {
     EventConstants = require('EventConstants');
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactMount = require('ReactMount');
     ReactTestUtils = require('ReactTestUtils');
     SelectEventPlugin = require('SelectEventPlugin');
@@ -48,7 +50,7 @@ describe('SelectEventPlugin', function() {
     });
 
     var rendered = ReactTestUtils.renderIntoDocument(<WithoutSelect />);
-    var node = React.findDOMNode(rendered);
+    var node = ReactDOM.findDOMNode(rendered);
     node.focus();
 
     var mousedown = extract(node, topLevelTypes.topMouseDown);
@@ -72,7 +74,7 @@ describe('SelectEventPlugin', function() {
     var rendered = ReactTestUtils.renderIntoDocument(
       <WithSelect onSelect={cb} />
     );
-    var node = React.findDOMNode(rendered);
+    var node = ReactDOM.findDOMNode(rendered);
 
     node.selectionStart = 0;
     node.selectionEnd = 0;

src/renderers/dom/client/wrappers/__tests__/ReactDOMButton-test.js

@@ -16,19 +16,20 @@ var mocks = require('mocks');
 
 describe('ReactDOMButton', function() {
   var React;
+  var ReactDOM;
   var ReactTestUtils;
 
   var onClick = mocks.getMockFunction();
 
   function expectClickThru(button) {
     onClick.mockClear();
-    ReactTestUtils.Simulate.click(React.findDOMNode(button));
+    ReactTestUtils.Simulate.click(ReactDOM.findDOMNode(button));
     expect(onClick.mock.calls.length).toBe(1);
   }
 
   function expectNoClickThru(button) {
     onClick.mockClear();
-    ReactTestUtils.Simulate.click(React.findDOMNode(button));
+    ReactTestUtils.Simulate.click(ReactDOM.findDOMNode(button));
     expect(onClick.mock.calls.length).toBe(0);
   }
 
@@ -39,6 +40,7 @@ describe('ReactDOMButton', function() {
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
   });
 
@@ -54,11 +56,11 @@ describe('ReactDOMButton', function() {
 
   it('should forward clicks when it becomes not disabled', function() {
     var container = document.createElement('div');
-    var btn = React.render(
+    var btn = ReactDOM.render(
       <button disabled={true} onClick={onClick} />,
       container
     );
-    btn = React.render(
+    btn = ReactDOM.render(
       <button onClick={onClick} />,
       container
     );
@@ -67,11 +69,11 @@ describe('ReactDOMButton', function() {
 
   it('should not forward clicks when it becomes disabled', function() {
     var container = document.createElement('div');
-    var btn = React.render(
+    var btn = ReactDOM.render(
       <button onClick={onClick} />,
       container
     );
-    btn = React.render(
+    btn = ReactDOM.render(
       <button disabled={true} onClick={onClick} />,
       container
     );
@@ -80,11 +82,11 @@ describe('ReactDOMButton', function() {
 
   it('should work correctly if the listener is changed', function() {
     var container = document.createElement('div');
-    var btn = React.render(
+    var btn = ReactDOM.render(
       <button disabled={true} onClick={function() {}} />,
       container
     );
-    btn = React.render(
+    btn = ReactDOM.render(
       <button disabled={false} onClick={onClick} />,
       container
     );

src/renderers/dom/client/wrappers/__tests__/ReactDOMIframe-test.js

@@ -13,10 +13,12 @@
 
 describe('ReactDOMIframe', function() {
   var React;
+  var ReactDOM;
   var ReactTestUtils;
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
   });
 
@@ -28,7 +30,7 @@ describe('ReactDOMIframe', function() {
     var loadEvent = document.createEvent('Event');
     loadEvent.initEvent('load', false, false);
 
-    React.findDOMNode(iframe).dispatchEvent(loadEvent);
+    ReactDOM.findDOMNode(iframe).dispatchEvent(loadEvent);
 
     expect(onLoadSpy).toHaveBeenCalled();
   });

src/renderers/dom/client/wrappers/__tests__/ReactDOMInput-test.js

@@ -18,6 +18,7 @@ var mocks = require('mocks');
 describe('ReactDOMInput', function() {
   var EventConstants;
   var React;
+  var ReactDOM;
   var ReactLink;
   var ReactTestUtils;
 
@@ -25,6 +26,7 @@ describe('ReactDOMInput', function() {
     require('mock-modules').dumpCache();
     EventConstants = require('EventConstants');
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactLink = require('ReactLink');
     ReactTestUtils = require('ReactTestUtils');
     spyOn(console, 'error');
@@ -33,7 +35,7 @@ describe('ReactDOMInput', function() {
   it('should display `defaultValue` of number 0', function() {
     var stub = <input type="text" defaultValue={0} />;
     stub = ReactTestUtils.renderIntoDocument(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('0');
   });
@@ -41,7 +43,7 @@ describe('ReactDOMInput', function() {
   it('should display "true" for `defaultValue` of `true`', function() {
     var stub = <input type="text" defaultValue={true} />;
     stub = ReactTestUtils.renderIntoDocument(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('true');
   });
@@ -49,7 +51,7 @@ describe('ReactDOMInput', function() {
   it('should display "false" for `defaultValue` of `false`', function() {
     var stub = <input type="text" defaultValue={false} />;
     stub = ReactTestUtils.renderIntoDocument(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('false');
   });
@@ -63,7 +65,7 @@ describe('ReactDOMInput', function() {
 
     var stub = <input type="text" defaultValue={objToString} />;
     stub = ReactTestUtils.renderIntoDocument(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('foobar');
   });
@@ -71,7 +73,7 @@ describe('ReactDOMInput', function() {
   it('should display `value` of number 0', function() {
     var stub = <input type="text" value={0} />;
     stub = ReactTestUtils.renderIntoDocument(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('0');
   });
@@ -79,12 +81,12 @@ describe('ReactDOMInput', function() {
   it('should allow setting `value` to `true`', function() {
     var container = document.createElement('div');
     var stub = <input type="text" value="yolo" onChange={emptyFunction} />;
-    stub = React.render(stub, container);
-    var node = React.findDOMNode(stub);
+    stub = ReactDOM.render(stub, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('yolo');
 
-    stub = React.render(
+    stub = ReactDOM.render(
       <input type="text" value={true} onChange={emptyFunction} />,
       container
     );
@@ -94,12 +96,12 @@ describe('ReactDOMInput', function() {
   it('should allow setting `value` to `false`', function() {
     var container = document.createElement('div');
     var stub = <input type="text" value="yolo" onChange={emptyFunction} />;
-    stub = React.render(stub, container);
-    var node = React.findDOMNode(stub);
+    stub = ReactDOM.render(stub, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('yolo');
 
-    stub = React.render(
+    stub = ReactDOM.render(
       <input type="text" value={false} onChange={emptyFunction} />,
       container
     );
@@ -109,8 +111,8 @@ describe('ReactDOMInput', function() {
   it('should allow setting `value` to `objToString`', function() {
     var container = document.createElement('div');
     var stub = <input type="text" value="foo" onChange={emptyFunction} />;
-    stub = React.render(stub, container);
-    var node = React.findDOMNode(stub);
+    stub = ReactDOM.render(stub, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('foo');
 
@@ -119,7 +121,7 @@ describe('ReactDOMInput', function() {
         return 'foobar';
       },
     };
-    stub = React.render(
+    stub = ReactDOM.render(
       <input type="text" value={objToString} onChange={emptyFunction} />,
       container
     );
@@ -129,7 +131,7 @@ describe('ReactDOMInput', function() {
   it('should properly control a value of number `0`', function() {
     var stub = <input type="text" value={0} onChange={emptyFunction} />;
     stub = ReactTestUtils.renderIntoDocument(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     node.value = 'giraffe';
     ReactTestUtils.Simulate.change(node);
@@ -144,7 +146,7 @@ describe('ReactDOMInput', function() {
     };
     var stub = <input type="text" value={0} onChange={handler} />;
     var container = document.createElement('div');
-    var node = React.render(stub, container);
+    var node = ReactDOM.render(stub, container);
 
     node.value = 'giraffe';
 
@@ -163,7 +165,7 @@ describe('ReactDOMInput', function() {
   it('should not set a value for submit buttons unnecessarily', function() {
     var stub = <input type="submit" />;
     stub = ReactTestUtils.renderIntoDocument(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     // The value shouldn't be '', or else the button will have no text; it
     // should have the default "Submit" or "Submit Query" label. Most browsers
@@ -208,9 +210,9 @@ describe('ReactDOMInput', function() {
     });
 
     var stub = ReactTestUtils.renderIntoDocument(<RadioGroup />);
-    var aNode = React.findDOMNode(stub.refs.a);
-    var bNode = React.findDOMNode(stub.refs.b);
-    var cNode = React.findDOMNode(stub.refs.c);
+    var aNode = ReactDOM.findDOMNode(stub.refs.a);
+    var bNode = ReactDOM.findDOMNode(stub.refs.b);
+    var cNode = ReactDOM.findDOMNode(stub.refs.c);
 
     expect(aNode.checked).toBe(true);
     expect(bNode.checked).toBe(false);
@@ -238,12 +240,12 @@ describe('ReactDOMInput', function() {
 
     instance = ReactTestUtils.renderIntoDocument(instance);
 
-    expect(React.findDOMNode(instance).value).toBe('yolo');
+    expect(ReactDOM.findDOMNode(instance).value).toBe('yolo');
     expect(link.value).toBe('yolo');
     expect(link.requestChange.mock.calls.length).toBe(0);
 
-    React.findDOMNode(instance).value = 'test';
-    ReactTestUtils.Simulate.change(React.findDOMNode(instance));
+    ReactDOM.findDOMNode(instance).value = 'test';
+    ReactTestUtils.Simulate.change(ReactDOM.findDOMNode(instance));
 
     expect(link.requestChange.mock.calls.length).toBe(1);
     expect(link.requestChange.mock.calls[0][0]).toEqual('test');
@@ -279,7 +281,7 @@ describe('ReactDOMInput', function() {
     var link = new ReactLink('yolo', mocks.getMockFunction());
     var instance = <input type="text" valueLink={link} />;
 
-    expect(() => React.render(instance, node)).not.toThrow();
+    expect(() => ReactDOM.render(instance, node)).not.toThrow();
 
     instance =
       <input
@@ -288,10 +290,10 @@ describe('ReactDOMInput', function() {
         value="test"
         onChange={emptyFunction}
       />;
-    expect(() => React.render(instance, node)).toThrow();
+    expect(() => ReactDOM.render(instance, node)).toThrow();
 
     instance = <input type="text" valueLink={link} onChange={emptyFunction} />;
-    expect(() => React.render(instance, node)).toThrow();
+    expect(() => ReactDOM.render(instance, node)).toThrow();
 
   });
 
@@ -301,12 +303,12 @@ describe('ReactDOMInput', function() {
 
     instance = ReactTestUtils.renderIntoDocument(instance);
 
-    expect(React.findDOMNode(instance).checked).toBe(true);
+    expect(ReactDOM.findDOMNode(instance).checked).toBe(true);
     expect(link.value).toBe(true);
     expect(link.requestChange.mock.calls.length).toBe(0);
 
-    React.findDOMNode(instance).checked = false;
-    ReactTestUtils.Simulate.change(React.findDOMNode(instance));
+    ReactDOM.findDOMNode(instance).checked = false;
+    ReactTestUtils.Simulate.change(ReactDOM.findDOMNode(instance));
 
     expect(link.requestChange.mock.calls.length).toBe(1);
     expect(link.requestChange.mock.calls[0][0]).toEqual(false);
@@ -315,7 +317,7 @@ describe('ReactDOMInput', function() {
   it('should warn with checked and no onChange handler', function() {
     var node = document.createElement('div');
     var link = new ReactLink(true, mocks.getMockFunction());
-    React.render(<input type="checkbox" checkedLink={link} />, node);
+    ReactDOM.render(<input type="checkbox" checkedLink={link} />, node);
     expect(console.error.argsForCall.length).toBe(0);
 
     ReactTestUtils.renderIntoDocument(
@@ -353,7 +355,7 @@ describe('ReactDOMInput', function() {
     var link = new ReactLink(true, mocks.getMockFunction());
     var instance = <input type="checkbox" checkedLink={link} />;
 
-    expect(() => React.render(instance, node)).not.toThrow();
+    expect(() => ReactDOM.render(instance, node)).not.toThrow();
 
     instance =
       <input
@@ -362,11 +364,11 @@ describe('ReactDOMInput', function() {
         checked="false"
         onChange={emptyFunction}
       />;
-    expect(() => React.render(instance, node)).toThrow();
+    expect(() => ReactDOM.render(instance, node)).toThrow();
 
     instance =
       <input type="checkbox" checkedLink={link} onChange={emptyFunction} />;
-    expect(() => React.render(instance, node)).toThrow();
+    expect(() => ReactDOM.render(instance, node)).toThrow();
 
   });
 
@@ -375,13 +377,13 @@ describe('ReactDOMInput', function() {
     var link = new ReactLink(true, mocks.getMockFunction());
     var instance = <input type="checkbox" checkedLink={link} />;
 
-    expect(() => React.render(instance, node)).not.toThrow();
+    expect(() => ReactDOM.render(instance, node)).not.toThrow();
 
     instance = <input type="checkbox" valueLink={link} />;
-    expect(() => React.render(instance, node)).not.toThrow();
+    expect(() => ReactDOM.render(instance, node)).not.toThrow();
 
     instance =
       <input type="checkbox" checkedLink={link} valueLink={emptyFunction} />;
-    expect(() => React.render(instance, node)).toThrow();
+    expect(() => ReactDOM.render(instance, node)).toThrow();
   });
 });

src/renderers/dom/client/wrappers/__tests__/ReactDOMOption-test.js

@@ -14,17 +14,19 @@
 
 describe('ReactDOMOption', function() {
   var React;
+  var ReactDOM;
   var ReactTestUtils;
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
   });
 
   it('should flatten children to a string', function() {
     var stub = <option>{1} {'foo'}</option>;
     stub = ReactTestUtils.renderIntoDocument(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.innerHTML).toBe('1 foo');
   });
@@ -33,7 +35,7 @@ describe('ReactDOMOption', function() {
     spyOn(console, 'error');
     var stub = <option>{1} <div /> {2}</option>;
     stub = ReactTestUtils.renderIntoDocument(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.innerHTML).toBe('1  2');
     expect(console.error.calls.length).toBe(1);
@@ -56,10 +58,9 @@ describe('ReactDOMOption', function() {
     spyOn(console, 'error');
     stub = ReactTestUtils.renderIntoDocument(stub);
 
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(console.error.calls.length).toBe(0);
     expect(node.innerHTML).toBe('1  2');
   });
-
 });

src/renderers/dom/client/wrappers/__tests__/ReactDOMSelect-test.js

@@ -16,6 +16,8 @@ var mocks = require('mocks');
 
 describe('ReactDOMSelect', function() {
   var React;
+  var ReactDOM;
+  var ReactDOMServer;
   var ReactLink;
   var ReactTestUtils;
 
@@ -23,6 +25,8 @@ describe('ReactDOMSelect', function() {
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
+    ReactDOMServer = require('ReactDOMServer');
     ReactLink = require('ReactLink');
     ReactTestUtils = require('ReactTestUtils');
   });
@@ -36,13 +40,13 @@ describe('ReactDOMSelect', function() {
       </select>;
     var options = stub.props.children;
     var container = document.createElement('div');
-    stub = React.render(stub, container);
-    var node = React.findDOMNode(stub);
+    stub = ReactDOM.render(stub, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('giraffe');
 
     // Changing `defaultValue` should do nothing.
-    React.render(
+    ReactDOM.render(
       <select defaultValue="gorilla">{options}</select>,
       container
     );
@@ -65,13 +69,13 @@ describe('ReactDOMSelect', function() {
         <option value="gorilla">A gorilla!</option>
       </select>;
     var container = document.createElement('div');
-    var stub = React.render(el, container);
-    var node = React.findDOMNode(stub);
+    var stub = ReactDOM.render(el, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('giraffe');
 
     node.value = 'monkey';
-    React.render(el, container);
+    ReactDOM.render(el, container);
     // Uncontrolled selects shouldn't change the value after first mounting
     expect(node.value).toEqual('monkey');
   });
@@ -85,15 +89,15 @@ describe('ReactDOMSelect', function() {
       </select>;
     var options = stub.props.children;
     var container = document.createElement('div');
-    stub = React.render(stub, container);
-    var node = React.findDOMNode(stub);
+    stub = ReactDOM.render(stub, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.options[0].selected).toBe(false);  // monkey
     expect(node.options[1].selected).toBe(true);  // giraffe
     expect(node.options[2].selected).toBe(true);  // gorilla
 
     // Changing `defaultValue` should do nothing.
-    React.render(
+    ReactDOM.render(
       <select multiple={true} defaultValue={['monkey']}>{options}</select>,
       container
     );
@@ -112,13 +116,13 @@ describe('ReactDOMSelect', function() {
       </select>;
     var options = stub.props.children;
     var container = document.createElement('div');
-    stub = React.render(stub, container);
-    var node = React.findDOMNode(stub);
+    stub = ReactDOM.render(stub, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('giraffe');
 
     // Changing the `value` prop should change the selected option.
-    React.render(
+    ReactDOM.render(
       <select value="gorilla" onChange={noop}>{options}</select>,
       container
     );
@@ -142,15 +146,15 @@ describe('ReactDOMSelect', function() {
       </select>;
     var options = stub.props.children;
     var container = document.createElement('div');
-    stub = React.render(stub, container);
-    var node = React.findDOMNode(stub);
+    stub = ReactDOM.render(stub, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.options[0].selected).toBe(false);  // monkey
     expect(node.options[1].selected).toBe(true);  // giraffe
     expect(node.options[2].selected).toBe(true);  // gorilla
 
     // Changing the `value` prop should change the selected options.
-    React.render(
+    ReactDOM.render(
       <select multiple={true} value={['monkey']} onChange={noop}>
         {options}
       </select>,
@@ -170,7 +174,7 @@ describe('ReactDOMSelect', function() {
         <option value="12">twelve</option>
       </select>;
     stub = ReactTestUtils.renderIntoDocument(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.options[0].selected).toBe(false);  // one
     expect(node.options[1].selected).toBe(false);  // two
@@ -180,9 +184,9 @@ describe('ReactDOMSelect', function() {
   it('should reset child options selected when they are changed and `value` is set', function() {
     var stub = <select multiple={true} value={['a', 'b']} onChange={noop} />;
     var container = document.createElement('div');
-    stub = React.render(stub, container);
+    stub = ReactDOM.render(stub, container);
 
-    React.render(
+    ReactDOM.render(
       <select multiple={true} value={['a', 'b']} onChange={noop}>
         <option value="a">a</option>
         <option value="b">b</option>
@@ -191,7 +195,7 @@ describe('ReactDOMSelect', function() {
       container
     );
 
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.options[0].selected).toBe(true);  // a
     expect(node.options[1].selected).toBe(true);  // b
@@ -213,8 +217,8 @@ describe('ReactDOMSelect', function() {
         <option value="gorilla">A gorilla!</option>
       </select>;
     var container = document.createElement('div');
-    var stub = React.render(el, container);
-    var node = React.findDOMNode(stub);
+    var stub = ReactDOM.render(el, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.options[0].selected).toBe(false);  // monkey
     expect(node.options[1].selected).toBe(true);  // giraffe
@@ -222,7 +226,7 @@ describe('ReactDOMSelect', function() {
 
     // Changing the `value` prop should change the selected options.
     objectToString.animal = 'monkey';
-    React.render(el, container);
+    ReactDOM.render(el, container);
 
     expect(node.options[0].selected).toBe(true);  // monkey
     expect(node.options[1].selected).toBe(false);  // giraffe
@@ -238,15 +242,15 @@ describe('ReactDOMSelect', function() {
       </select>;
     var options = stub.props.children;
     var container = document.createElement('div');
-    stub = React.render(stub, container);
-    var node = React.findDOMNode(stub);
+    stub = ReactDOM.render(stub, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.options[0].selected).toBe(false);  // monkey
     expect(node.options[1].selected).toBe(true);  // giraffe
     expect(node.options[2].selected).toBe(false);  // gorilla
 
     // When making it multiple, giraffe and gorilla should be selected
-    React.render(
+    ReactDOM.render(
       <select multiple={true} defaultValue={['giraffe', 'gorilla']}>
         {options}
       </select>,
@@ -267,8 +271,8 @@ describe('ReactDOMSelect', function() {
       </select>;
     var options = stub.props.children;
     var container = document.createElement('div');
-    stub = React.render(stub, container);
-    var node = React.findDOMNode(stub);
+    stub = ReactDOM.render(stub, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.options[0].selected).toBe(false);  // monkey
     expect(node.options[1].selected).toBe(true);  // giraffe
@@ -276,7 +280,7 @@ describe('ReactDOMSelect', function() {
 
     // When removing multiple, defaultValue is applied again, being omitted
     // means that "monkey" will be selected
-    React.render(
+    ReactDOM.render(
       <select defaultValue="gorilla">{options}</select>,
       container
     );
@@ -296,14 +300,14 @@ describe('ReactDOMSelect', function() {
       </select>;
     var options = stub.props.children;
     var container = document.createElement('div');
-    stub = React.render(stub, container);
-    var node = React.findDOMNode(stub);
+    stub = ReactDOM.render(stub, container);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.options[0].selected).toBe(false);  // monkey
     expect(node.options[1].selected).toBe(true);  // giraffe
     expect(node.options[2].selected).toBe(false);  // gorilla
 
-    React.render(<select>{options}</select>, container);
+    ReactDOM.render(<select>{options}</select>, container);
 
     expect(node.options[0].selected).toBe(false);  // monkey
     expect(node.options[1].selected).toBe(true);  // giraffe
@@ -319,10 +323,10 @@ describe('ReactDOMSelect', function() {
       </select>;
     var options = stub.props.children;
     var container = document.createElement('div');
-    stub = React.render(stub, container);
-    var node = React.findDOMNode(stub);
+    stub = ReactDOM.render(stub, container);
+    var node = ReactDOM.findDOMNode(stub);
 
-    React.render(
+    ReactDOM.render(
       <select value="gorilla" onChange={noop}>{options}</select>,
       container
     );
@@ -331,7 +335,7 @@ describe('ReactDOMSelect', function() {
     expect(node.options[1].selected).toBe(false);  // giraffe
     expect(node.options[2].selected).toBe(true);  // gorilla
 
-    React.render(<select>{options}</select>, container);
+    ReactDOM.render(<select>{options}</select>, container);
 
     expect(node.options[0].selected).toBe(false);  // monkey
     expect(node.options[1].selected).toBe(false);  // giraffe
@@ -347,7 +351,7 @@ describe('ReactDOMSelect', function() {
         <option value="gorilla">A gorilla!</option>
       </select>;
     stub = ReactTestUtils.renderIntoDocument(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.options[0].selected).toBe(false);  // monkey
     expect(node.options[1].selected).toBe(true);  // giraffe
@@ -370,7 +374,7 @@ describe('ReactDOMSelect', function() {
         <option value="giraffe">A giraffe!</option>
         <option value="gorilla">A gorilla!</option>
       </select>;
-    var markup = React.renderToString(stub);
+    var markup = ReactDOMServer.renderToString(stub);
     expect(markup).toContain('<option selected="" value="giraffe"');
     expect(markup).not.toContain('<option selected="" value="monkey"');
     expect(markup).not.toContain('<option selected="" value="gorilla"');
@@ -383,7 +387,7 @@ describe('ReactDOMSelect', function() {
         <option value="giraffe">A giraffe!</option>
         <option value="gorilla">A gorilla!</option>
       </select>;
-    var markup = React.renderToString(stub);
+    var markup = ReactDOMServer.renderToString(stub);
     expect(markup).toContain('<option selected="" value="giraffe"');
     expect(markup).not.toContain('<option selected="" value="monkey"');
     expect(markup).not.toContain('<option selected="" value="gorilla"');
@@ -396,7 +400,7 @@ describe('ReactDOMSelect', function() {
         <option value="giraffe">A giraffe!</option>
         <option value="gorilla">A gorilla!</option>
       </select>;
-    var markup = React.renderToString(stub);
+    var markup = ReactDOMServer.renderToString(stub);
     expect(markup).toContain('<option selected="" value="giraffe"');
     expect(markup).toContain('<option selected="" value="gorilla"');
     expect(markup).not.toContain('<option selected="" value="monkey"');
@@ -405,7 +409,7 @@ describe('ReactDOMSelect', function() {
   it('should not control defaultValue if readding options', function() {
     var container = document.createElement('div');
 
-    var select = React.render(
+    var select = ReactDOM.render(
       <select multiple={true} defaultValue={['giraffe']}>
         <option key="monkey" value="monkey">A monkey!</option>
         <option key="giraffe" value="giraffe">A giraffe!</option>
@@ -413,13 +417,13 @@ describe('ReactDOMSelect', function() {
       </select>,
       container
     );
-    var node = React.findDOMNode(select);
+    var node = ReactDOM.findDOMNode(select);
 
     expect(node.options[0].selected).toBe(false);  // monkey
     expect(node.options[1].selected).toBe(true);  // giraffe
     expect(node.options[2].selected).toBe(false);  // gorilla
 
-    React.render(
+    ReactDOM.render(
       <select multiple={true} defaultValue={['giraffe']}>
         <option key="monkey" value="monkey">A monkey!</option>
         <option key="gorilla" value="gorilla">A gorilla!</option>
@@ -430,7 +434,7 @@ describe('ReactDOMSelect', function() {
     expect(node.options[0].selected).toBe(false);  // monkey
     expect(node.options[1].selected).toBe(false);  // gorilla
 
-    React.render(
+    ReactDOM.render(
       <select multiple={true} defaultValue={['giraffe']}>
         <option key="monkey" value="monkey">A monkey!</option>
         <option key="giraffe" value="giraffe">A giraffe!</option>

src/renderers/dom/client/wrappers/__tests__/ReactDOMTextarea-test.js

@@ -16,6 +16,7 @@ var mocks = require('mocks');
 
 describe('ReactDOMTextarea', function() {
   var React;
+  var ReactDOM;
   var ReactLink;
   var ReactTestUtils;
 
@@ -23,6 +24,7 @@ describe('ReactDOMTextarea', function() {
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactLink = require('ReactLink');
     ReactTestUtils = require('ReactTestUtils');
 
@@ -30,8 +32,8 @@ describe('ReactDOMTextarea', function() {
       if (!container) {
         container = document.createElement('div');
       }
-      var stub = React.render(component, container);
-      var node = React.findDOMNode(stub);
+      var stub = ReactDOM.render(component, container);
+      var node = ReactDOM.findDOMNode(stub);
       // Fixing jsdom's quirky behavior -- in reality, the parser should strip
       // off the leading newline but we need to do it by hand here.
       node.value = node.innerHTML.replace(/^\n/, '');
@@ -42,7 +44,7 @@ describe('ReactDOMTextarea', function() {
   it('should allow setting `defaultValue`', function() {
     var container = document.createElement('div');
     var stub = renderTextarea(<textarea defaultValue="giraffe" />, container);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('giraffe');
 
@@ -54,7 +56,7 @@ describe('ReactDOMTextarea', function() {
   it('should display `defaultValue` of number 0', function() {
     var stub = <textarea defaultValue={0} />;
     stub = renderTextarea(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('0');
   });
@@ -62,7 +64,7 @@ describe('ReactDOMTextarea', function() {
   it('should display "false" for `defaultValue` of `false`', function() {
     var stub = <textarea type="text" defaultValue={false} />;
     stub = renderTextarea(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('false');
   });
@@ -76,7 +78,7 @@ describe('ReactDOMTextarea', function() {
 
     var stub = <textarea type="text" defaultValue={objToString} />;
     stub = renderTextarea(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('foobar');
   });
@@ -84,7 +86,7 @@ describe('ReactDOMTextarea', function() {
   it('should not render value as an attribute', function() {
     var stub = <textarea value="giraffe" onChange={emptyFunction} />;
     stub = renderTextarea(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.getAttribute('value')).toBe(null);
   });
@@ -92,7 +94,7 @@ describe('ReactDOMTextarea', function() {
   it('should display `value` of number 0', function() {
     var stub = <textarea value={0} />;
     stub = renderTextarea(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('0');
   });
@@ -101,11 +103,11 @@ describe('ReactDOMTextarea', function() {
     var container = document.createElement('div');
     var stub = <textarea value="giraffe" onChange={emptyFunction} />;
     stub = renderTextarea(stub, container);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('giraffe');
 
-    stub = React.render(
+    stub = ReactDOM.render(
       <textarea value="gorilla" onChange={emptyFunction} />,
       container
     );
@@ -116,11 +118,11 @@ describe('ReactDOMTextarea', function() {
     var container = document.createElement('div');
     var stub = <textarea value="giraffe" onChange={emptyFunction} />;
     stub = renderTextarea(stub, container);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('giraffe');
 
-    stub = React.render(
+    stub = ReactDOM.render(
       <textarea value={true} onChange={emptyFunction} />,
       container
     );
@@ -131,11 +133,11 @@ describe('ReactDOMTextarea', function() {
     var container = document.createElement('div');
     var stub = <textarea value="giraffe" onChange={emptyFunction} />;
     stub = renderTextarea(stub, container);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('giraffe');
 
-    stub = React.render(
+    stub = ReactDOM.render(
       <textarea value={false} onChange={emptyFunction} />,
       container
     );
@@ -146,7 +148,7 @@ describe('ReactDOMTextarea', function() {
     var container = document.createElement('div');
     var stub = <textarea value="giraffe" onChange={emptyFunction} />;
     stub = renderTextarea(stub, container);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(node.value).toBe('giraffe');
 
@@ -155,7 +157,7 @@ describe('ReactDOMTextarea', function() {
         return 'foo';
       },
     };
-    stub = React.render(
+    stub = ReactDOM.render(
       <textarea value={objToString} onChange={emptyFunction} />,
       container
     );
@@ -165,7 +167,7 @@ describe('ReactDOMTextarea', function() {
   it('should properly control a value of number `0`', function() {
     var stub = <textarea value={0} onChange={emptyFunction} />;
     stub = renderTextarea(stub);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     node.value = 'giraffe';
     ReactTestUtils.Simulate.change(node);
@@ -178,26 +180,26 @@ describe('ReactDOMTextarea', function() {
     var container = document.createElement('div');
     var stub = <textarea>giraffe</textarea>;
     stub = renderTextarea(stub, container);
-    var node = React.findDOMNode(stub);
+    var node = ReactDOM.findDOMNode(stub);
 
     expect(console.error.argsForCall.length).toBe(1);
     expect(node.value).toBe('giraffe');
 
     // Changing children should do nothing, it functions like `defaultValue`.
-    stub = React.render(<textarea>gorilla</textarea>, container);
+    stub = ReactDOM.render(<textarea>gorilla</textarea>, container);
     expect(node.value).toEqual('giraffe');
   });
 
   it('should allow numbers as children', function() {
     spyOn(console, 'error');
-    var node = React.findDOMNode(renderTextarea(<textarea>{17}</textarea>));
+    var node = ReactDOM.findDOMNode(renderTextarea(<textarea>{17}</textarea>));
     expect(console.error.argsForCall.length).toBe(1);
     expect(node.value).toBe('17');
   });
 
   it('should allow booleans as children', function() {
     spyOn(console, 'error');
-    var node = React.findDOMNode(renderTextarea(<textarea>{false}</textarea>));
+    var node = ReactDOM.findDOMNode(renderTextarea(<textarea>{false}</textarea>));
     expect(console.error.argsForCall.length).toBe(1);
     expect(node.value).toBe('false');
   });
@@ -209,7 +211,7 @@ describe('ReactDOMTextarea', function() {
         return 'sharkswithlasers';
       },
     };
-    var node = React.findDOMNode(renderTextarea(<textarea>{obj}</textarea>));
+    var node = ReactDOM.findDOMNode(renderTextarea(<textarea>{obj}</textarea>));
     expect(console.error.argsForCall.length).toBe(1);
     expect(node.value).toBe('sharkswithlasers');
   });
@@ -227,7 +229,7 @@ describe('ReactDOMTextarea', function() {
 
     var node;
     expect(function() {
-      node = React.findDOMNode(renderTextarea(<textarea><strong /></textarea>));
+      node = ReactDOM.findDOMNode(renderTextarea(<textarea><strong /></textarea>));
     }).not.toThrow();
 
     expect(node.value).toBe('[object Object]');
@@ -241,12 +243,12 @@ describe('ReactDOMTextarea', function() {
 
     instance = renderTextarea(instance);
 
-    expect(React.findDOMNode(instance).value).toBe('yolo');
+    expect(ReactDOM.findDOMNode(instance).value).toBe('yolo');
     expect(link.value).toBe('yolo');
     expect(link.requestChange.mock.calls.length).toBe(0);
 
-    React.findDOMNode(instance).value = 'test';
-    ReactTestUtils.Simulate.change(React.findDOMNode(instance));
+    ReactDOM.findDOMNode(instance).value = 'test';
+    ReactTestUtils.Simulate.change(ReactDOM.findDOMNode(instance));
 
     expect(link.requestChange.mock.calls.length).toBe(1);
     expect(link.requestChange.mock.calls[0][0]).toEqual('test');
@@ -255,6 +257,6 @@ describe('ReactDOMTextarea', function() {
   it('should unmount', function() {
     var container = document.createElement('div');
     renderTextarea(<textarea />, container);
-    React.unmountComponentAtNode(container);
+    ReactDOM.unmountComponentAtNode(container);
   });
 });

src/renderers/dom/server/__tests__/ReactServerRendering-test.js

@@ -15,6 +15,7 @@ var mocks = require('mocks');
 
 var ExecutionEnvironment;
 var React;
+var ReactDOM;
 var ReactMarkupChecksum;
 var ReactReconcileTransaction;
 var ReactTestUtils;
@@ -26,6 +27,7 @@ describe('ReactServerRendering', function() {
   beforeEach(function() {
     require('mock-modules').dumpCache();
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactMarkupChecksum = require('ReactMarkupChecksum');
     ReactTestUtils = require('ReactTestUtils');
     ReactReconcileTransaction = require('ReactReconcileTransaction');
@@ -185,20 +187,20 @@ describe('ReactServerRendering', function() {
       });
 
       var element = document.createElement('div');
-      React.render(<TestComponent />, element);
+      ReactDOM.render(<TestComponent />, element);
 
       var lastMarkup = element.innerHTML;
 
       // Exercise the update path. Markup should not change,
       // but some lifecycle methods should be run again.
-      React.render(<TestComponent name="x" />, element);
+      ReactDOM.render(<TestComponent name="x" />, element);
       expect(mountCount).toEqual(1);
 
       // Unmount and remount. We should get another mount event and
       // we should get different markup, as the IDs are unique each time.
-      React.unmountComponentAtNode(element);
+      ReactDOM.unmountComponentAtNode(element);
       expect(element.innerHTML).toEqual('');
-      React.render(<TestComponent name="x" />, element);
+      ReactDOM.render(<TestComponent name="x" />, element);
       expect(mountCount).toEqual(2);
       expect(element.innerHTML).not.toEqual(lastMarkup);
 
@@ -206,7 +208,7 @@ describe('ReactServerRendering', function() {
       // we used server rendering. We should mount again, but the markup should
       // be unchanged. We will append a sentinel at the end of innerHTML to be
       // sure that innerHTML was not changed.
-      React.unmountComponentAtNode(element);
+      ReactDOM.unmountComponentAtNode(element);
       expect(element.innerHTML).toEqual('');
 
       ExecutionEnvironment.canUseDOM = false;
@@ -216,16 +218,16 @@ describe('ReactServerRendering', function() {
       ExecutionEnvironment.canUseDOM = true;
       element.innerHTML = lastMarkup;
 
-      React.render(<TestComponent name="x" />, element);
+      ReactDOM.render(<TestComponent name="x" />, element);
       expect(mountCount).toEqual(3);
       expect(element.innerHTML).toBe(lastMarkup);
-      React.unmountComponentAtNode(element);
+      ReactDOM.unmountComponentAtNode(element);
       expect(element.innerHTML).toEqual('');
 
       // Now simulate a situation where the app is not idempotent. React should
       // warn but do the right thing.
       element.innerHTML = lastMarkup;
-      var instance = React.render(<TestComponent name="y" />, element);
+      var instance = ReactDOM.render(<TestComponent name="y" />, element);
       expect(mountCount).toEqual(4);
       expect(console.error.argsForCall.length).toBe(1);
       expect(element.innerHTML.length > 0).toBe(true);
@@ -233,7 +235,7 @@ describe('ReactServerRendering', function() {
 
       // Ensure the events system works
       expect(numClicks).toEqual(0);
-      ReactTestUtils.Simulate.click(React.findDOMNode(instance.refs.span));
+      ReactTestUtils.Simulate.click(ReactDOM.findDOMNode(instance.refs.span));
       expect(numClicks).toEqual(1);
     });
 

src/renderers/dom/shared/__tests__/CSSPropertyOperations-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React = require('React');
+var ReactDOM = require('ReactDOM');
 
 describe('CSSPropertyOperations', function() {
   var CSSPropertyOperations;
@@ -91,7 +92,7 @@ describe('CSSPropertyOperations', function() {
     };
     var div = <div style={styles} />;
     var root = document.createElement('div');
-    div = React.render(div, root);
+    div = ReactDOM.render(div, root);
     expect(/style=".*"/.test(root.innerHTML)).toBe(true);
   });
 
@@ -102,7 +103,7 @@ describe('CSSPropertyOperations', function() {
     };
     var div = <div style={styles} />;
     var root = document.createElement('div');
-    React.render(div, root);
+    ReactDOM.render(div, root);
     expect(/style=".*"/.test(root.innerHTML)).toBe(false);
   });
 
@@ -126,8 +127,8 @@ describe('CSSPropertyOperations', function() {
       '-webkit-transform': 'translate3d(0, 0, 0)',
     };
 
-    React.render(<div />, root);
-    React.render(<div style={styles} />, root);
+    ReactDOM.render(<div />, root);
+    ReactDOM.render(<div style={styles} />, root);
 
     expect(console.error.argsForCall.length).toBe(2);
     expect(console.error.argsForCall[0][0]).toContain('msTransform');

src/renderers/dom/shared/__tests__/ReactDOMComponent-test.js

@@ -17,9 +17,14 @@ var mocks = require('mocks');
 describe('ReactDOMComponent', function() {
   var React;
 
+  var ReactDOM;
+  var ReactDOMServer;
+
   beforeEach(function() {
     require('mock-modules').dumpCache();
     React = require('React');
+    ReactDOM = require('ReactDOM');
+    ReactDOMServer = require('ReactDOMServer');
   });
 
   describe('updateDOM', function() {
@@ -31,31 +36,31 @@ describe('ReactDOMComponent', function() {
 
     it('should handle className', function() {
       var container = document.createElement('div');
-      React.render(<div style={{}} />, container);
+      ReactDOM.render(<div style={{}} />, container);
 
-      React.render(<div className={'foo'} />, container);
+      ReactDOM.render(<div className={'foo'} />, container);
       expect(container.firstChild.className).toEqual('foo');
-      React.render(<div className={'bar'} />, container);
+      ReactDOM.render(<div className={'bar'} />, container);
       expect(container.firstChild.className).toEqual('bar');
-      React.render(<div className={null} />, container);
+      ReactDOM.render(<div className={null} />, container);
       expect(container.firstChild.className).toEqual('');
     });
 
     it('should gracefully handle various style value types', function() {
       var container = document.createElement('div');
-      React.render(<div style={{}} />, container);
+      ReactDOM.render(<div style={{}} />, container);
       var stubStyle = container.firstChild.style;
 
       // set initial style
       var setup = {display: 'block', left: '1', top: 2, fontFamily: 'Arial'};
-      React.render(<div style={setup} />, container);
+      ReactDOM.render(<div style={setup} />, container);
       expect(stubStyle.display).toEqual('block');
       expect(stubStyle.left).toEqual('1px');
       expect(stubStyle.fontFamily).toEqual('Arial');
 
       // reset the style to their default state
       var reset = {display: '', left: null, top: false, fontFamily: true};
-      React.render(<div style={reset} />, container);
+      ReactDOM.render(<div style={reset} />, container);
       expect(stubStyle.display).toEqual('');
       expect(stubStyle.left).toEqual('');
       expect(stubStyle.top).toEqual('');
@@ -69,7 +74,7 @@ describe('ReactDOMComponent', function() {
 
       var styles = {display: 'none', fontFamily: 'Arial', lineHeight: 1.2};
       var container = document.createElement('div');
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
 
       var stubStyle = container.firstChild.style;
       stubStyle.display = styles.display;
@@ -77,26 +82,26 @@ describe('ReactDOMComponent', function() {
 
       styles.display = 'block';
 
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
       expect(stubStyle.display).toEqual('block');
       expect(stubStyle.fontFamily).toEqual('Arial');
       expect(stubStyle.lineHeight).toEqual('1.2');
 
       styles.fontFamily = 'Helvetica';
 
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
       expect(stubStyle.display).toEqual('block');
       expect(stubStyle.fontFamily).toEqual('Helvetica');
       expect(stubStyle.lineHeight).toEqual('1.2');
 
       styles.lineHeight = 0.5;
 
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
       expect(stubStyle.display).toEqual('block');
       expect(stubStyle.fontFamily).toEqual('Helvetica');
       expect(stubStyle.lineHeight).toEqual('0.5');
 
-      React.render(<div style={undefined} />, container);
+      ReactDOM.render(<div style={undefined} />, container);
       expect(stubStyle.display).toBe('');
       expect(stubStyle.fontFamily).toBe('');
       expect(stubStyle.lineHeight).toBe('');
@@ -136,73 +141,73 @@ describe('ReactDOMComponent', function() {
 
       style = {background: 'red'};
       var div = document.createElement('div');
-      React.render(<span style={style}></span>, div);
+      ReactDOM.render(<span style={style}></span>, div);
       style.background = 'blue';
-      React.render(<span style={style}></span>, div);
+      ReactDOM.render(<span style={style}></span>, div);
       expect(console.error.argsForCall.length).toBe(2);
     });
 
     it('should update styles if initially null', function() {
       var styles = null;
       var container = document.createElement('div');
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
 
       var stubStyle = container.firstChild.style;
 
       styles = {display: 'block'};
 
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
       expect(stubStyle.display).toEqual('block');
     });
 
     it('should update styles if updated to null multiple times', function() {
       var styles = null;
       var container = document.createElement('div');
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
 
       styles = {display: 'block'};
       var stubStyle = container.firstChild.style;
 
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
       expect(stubStyle.display).toEqual('block');
 
-      React.render(<div style={null} />, container);
+      ReactDOM.render(<div style={null} />, container);
       expect(stubStyle.display).toEqual('');
 
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
       expect(stubStyle.display).toEqual('block');
 
-      React.render(<div style={null} />, container);
+      ReactDOM.render(<div style={null} />, container);
       expect(stubStyle.display).toEqual('');
     });
 
     it('should remove attributes', function() {
       var container = document.createElement('div');
-      React.render(<img height="17" />, container);
+      ReactDOM.render(<img height="17" />, container);
 
       expect(container.firstChild.hasAttribute('height')).toBe(true);
-      React.render(<img />, container);
+      ReactDOM.render(<img />, container);
       expect(container.firstChild.hasAttribute('height')).toBe(false);
     });
 
     it('should remove properties', function() {
       var container = document.createElement('div');
-      React.render(<div className="monkey" />, container);
+      ReactDOM.render(<div className="monkey" />, container);
 
       expect(container.firstChild.className).toEqual('monkey');
-      React.render(<div />, container);
+      ReactDOM.render(<div />, container);
       expect(container.firstChild.className).toEqual('');
     });
 
     it('should clear a single style prop when changing `style`', function() {
       var styles = {display: 'none', color: 'red'};
       var container = document.createElement('div');
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
 
       var stubStyle = container.firstChild.style;
 
       styles = {color: 'green'};
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
       expect(stubStyle.display).toEqual('');
       expect(stubStyle.color).toEqual('green');
     });
@@ -216,7 +221,7 @@ describe('ReactDOMComponent', function() {
           {'blah" onclick="beevil" noise="hi': 'selected'},
           null
         );
-        React.render(element, container);
+        ReactDOM.render(element, container);
       }
       expect(console.error.argsForCall.length).toBe(1);
       expect(console.error.argsForCall[0][0]).toEqual(
@@ -229,14 +234,14 @@ describe('ReactDOMComponent', function() {
       for (var i = 0; i < 3; i++) {
         var container = document.createElement('div');
         var beforeUpdate = React.createElement('x-foo-component', {}, null);
-        React.render(beforeUpdate, container);
+        ReactDOM.render(beforeUpdate, container);
 
         var afterUpdate = React.createElement(
           'x-foo-component',
           {'blah" onclick="beevil" noise="hi': 'selected'},
           null
         );
-        React.render(afterUpdate, container);
+        ReactDOM.render(afterUpdate, container);
       }
       expect(console.error.argsForCall.length).toBe(1);
       expect(console.error.argsForCall[0][0]).toEqual(
@@ -248,10 +253,10 @@ describe('ReactDOMComponent', function() {
       var container = document.createElement('div');
 
       var beforeUpdate = React.createElement('x-foo-component', {}, null);
-      React.render(beforeUpdate, container);
+      ReactDOM.render(beforeUpdate, container);
 
       var afterUpdate = <x-foo-component myattr="myval" />;
-      React.render(afterUpdate, container);
+      ReactDOM.render(afterUpdate, container);
 
       expect(container.childNodes[0].getAttribute('myattr')).toBe('myval');
     });
@@ -259,11 +264,11 @@ describe('ReactDOMComponent', function() {
     it('should clear all the styles when removing `style`', function() {
       var styles = {display: 'none', color: 'red'};
       var container = document.createElement('div');
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
 
       var stubStyle = container.firstChild.style;
 
-      React.render(<div />, container);
+      ReactDOM.render(<div />, container);
       expect(stubStyle.display).toEqual('');
       expect(stubStyle.color).toEqual('');
     });
@@ -271,9 +276,9 @@ describe('ReactDOMComponent', function() {
     it('should update styles when `style` changes from null to object', function() {
       var container = document.createElement('div');
       var styles = {color: 'red'};
-      React.render(<div style={styles} />, container);
-      React.render(<div />, container);
-      React.render(<div style={styles} />, container);
+      ReactDOM.render(<div style={styles} />, container);
+      ReactDOM.render(<div />, container);
+      ReactDOM.render(<div style={styles} />, container);
 
       var stubStyle = container.firstChild.style;
       expect(stubStyle.color).toEqual('red');
@@ -281,19 +286,19 @@ describe('ReactDOMComponent', function() {
 
     it('should empty element when removing innerHTML', function() {
       var container = document.createElement('div');
-      React.render(<div dangerouslySetInnerHTML={{__html: ':)'}} />, container);
+      ReactDOM.render(<div dangerouslySetInnerHTML={{__html: ':)'}} />, container);
 
       expect(container.firstChild.innerHTML).toEqual(':)');
-      React.render(<div />, container);
+      ReactDOM.render(<div />, container);
       expect(container.firstChild.innerHTML).toEqual('');
     });
 
     it('should transition from string content to innerHTML', function() {
       var container = document.createElement('div');
-      React.render(<div>hello</div>, container);
+      ReactDOM.render(<div>hello</div>, container);
 
       expect(container.firstChild.innerHTML).toEqual('hello');
-      React.render(
+      ReactDOM.render(
         <div dangerouslySetInnerHTML={{__html: 'goodbye'}} />,
         container
       );
@@ -302,34 +307,34 @@ describe('ReactDOMComponent', function() {
 
     it('should transition from innerHTML to string content', function() {
       var container = document.createElement('div');
-      React.render(
+      ReactDOM.render(
         <div dangerouslySetInnerHTML={{__html: 'bonjour'}} />,
         container
       );
 
       expect(container.firstChild.innerHTML).toEqual('bonjour');
-      React.render(<div>adieu</div>, container);
+      ReactDOM.render(<div>adieu</div>, container);
       expect(container.firstChild.innerHTML).toEqual('adieu');
     });
 
     it('should transition from innerHTML to children in nested el', function() {
       var container = document.createElement('div');
-      React.render(
+      ReactDOM.render(
         <div><div dangerouslySetInnerHTML={{__html: 'bonjour'}} /></div>,
         container
       );
 
       expect(container.textContent).toEqual('bonjour');
-      React.render(<div><div><span>adieu</span></div></div>, container);
+      ReactDOM.render(<div><div><span>adieu</span></div></div>, container);
       expect(container.textContent).toEqual('adieu');
     });
 
     it('should transition from children to innerHTML in nested el', function() {
       var container = document.createElement('div');
-      React.render(<div><div><span>adieu</span></div></div>, container);
+      ReactDOM.render(<div><div><span>adieu</span></div></div>, container);
 
       expect(container.textContent).toEqual('adieu');
-      React.render(
+      ReactDOM.render(
         <div><div dangerouslySetInnerHTML={{__html: 'bonjour'}} /></div>,
         container
       );
@@ -338,7 +343,7 @@ describe('ReactDOMComponent', function() {
 
     it('should not incur unnecessary DOM mutations', function() {
       var container = document.createElement('div');
-      React.render(<div value="" />, container);
+      ReactDOM.render(<div value="" />, container);
 
       var node = container.firstChild;
       var nodeValue = ''; // node.value always returns undefined
@@ -352,16 +357,16 @@ describe('ReactDOMComponent', function() {
         }),
       });
 
-      React.render(<div value="" />, container);
+      ReactDOM.render(<div value="" />, container);
       expect(nodeValueSetter.mock.calls.length).toBe(0);
 
-      React.render(<div />, container);
+      ReactDOM.render(<div />, container);
       expect(nodeValueSetter.mock.calls.length).toBe(1);
     });
 
     it('should ignore attribute whitelist for elements with the "is: attribute', function() {
       var container = document.createElement('div');
-      React.render(<button is="test" cowabunga="chevynova"/>, container);
+      ReactDOM.render(<button is="test" cowabunga="chevynova"/>, container);
       expect(container.firstChild.hasAttribute('cowabunga')).toBe(true);
     });
   });
@@ -466,7 +471,7 @@ describe('ReactDOMComponent', function() {
     beforeEach(function() {
       mountComponent = function(props) {
         var container = document.createElement('div');
-        React.render(<div {...props} />, container);
+        ReactDOM.render(<div {...props} />, container);
       };
     });
 
@@ -476,7 +481,7 @@ describe('ReactDOMComponent', function() {
             return React.createElement('BR', null);
           },
       });
-      var returnedValue = React.renderToString(<Container/>);
+      var returnedValue = ReactDOMServer.renderToString(<Container/>);
       expect(returnedValue).not.toContain('</BR>');
     });
 
@@ -485,7 +490,7 @@ describe('ReactDOMComponent', function() {
 
       var container = document.createElement('div');
 
-      React.render(<input>children</input>, container);
+      ReactDOM.render(<input>children</input>, container);
 
       expect(console.error.argsForCall.length).toBe(1);
       expect(console.error.argsForCall[0][0]).toContain('void element');
@@ -496,7 +501,7 @@ describe('ReactDOMComponent', function() {
 
       var container = document.createElement('div');
 
-      React.render(
+      ReactDOM.render(
         <input dangerouslySetInnerHTML={{__html: 'content'}} />,
         container
       );
@@ -510,11 +515,11 @@ describe('ReactDOMComponent', function() {
 
       var container = document.createElement('div');
 
-      var returnedValue = React.renderToString(<menu><menuitem /></menu>);
+      var returnedValue = ReactDOMServer.renderToString(<menu><menuitem /></menu>);
 
       expect(returnedValue).toContain('</menuitem>');
 
-      React.render(<menu><menuitem>children</menuitem></menu>, container);
+      ReactDOM.render(<menu><menuitem>children</menuitem></menu>, container);
 
       expect(console.error.argsForCall.length).toBe(1);
       expect(console.error.argsForCall[0][0]).toContain('void element');
@@ -589,14 +594,14 @@ describe('ReactDOMComponent', function() {
       SimpleEventPlugin.willDeleteListener = mocks.getMockFunction();
 
       var container = document.createElement('div');
-      React.render(
+      ReactDOM.render(
         <div onClick={() => true} />,
         container
       );
 
       expect(SimpleEventPlugin.didPutListener.mock.calls.length).toBe(1);
 
-      React.unmountComponentAtNode(container);
+      ReactDOM.unmountComponentAtNode(container);
 
       expect(SimpleEventPlugin.willDeleteListener.mock.calls.length).toBe(1);
     });
@@ -608,27 +613,27 @@ describe('ReactDOMComponent', function() {
       SimpleEventPlugin.willDeleteListener = mocks.getMockFunction();
       var container = document.createElement('div');
 
-      React.render(<div onClick={null} />, container);
+      ReactDOM.render(<div onClick={null} />, container);
       expect(SimpleEventPlugin.didPutListener.mock.calls.length).toBe(0);
       expect(SimpleEventPlugin.willDeleteListener.mock.calls.length).toBe(0);
 
-      React.render(<div onClick={() => 'apple'} />, container);
+      ReactDOM.render(<div onClick={() => 'apple'} />, container);
       expect(SimpleEventPlugin.didPutListener.mock.calls.length).toBe(1);
       expect(SimpleEventPlugin.willDeleteListener.mock.calls.length).toBe(0);
 
-      React.render(<div onClick={() => 'banana'} />, container);
+      ReactDOM.render(<div onClick={() => 'banana'} />, container);
       expect(SimpleEventPlugin.didPutListener.mock.calls.length).toBe(2);
       expect(SimpleEventPlugin.willDeleteListener.mock.calls.length).toBe(0);
 
-      React.render(<div onClick={null} />, container);
+      ReactDOM.render(<div onClick={null} />, container);
       expect(SimpleEventPlugin.didPutListener.mock.calls.length).toBe(2);
       expect(SimpleEventPlugin.willDeleteListener.mock.calls.length).toBe(1);
 
-      React.render(<div />, container);
+      ReactDOM.render(<div />, container);
       expect(SimpleEventPlugin.didPutListener.mock.calls.length).toBe(2);
       expect(SimpleEventPlugin.willDeleteListener.mock.calls.length).toBe(1);
 
-      React.unmountComponentAtNode(container);
+      ReactDOM.unmountComponentAtNode(container);
       expect(SimpleEventPlugin.didPutListener.mock.calls.length).toBe(2);
       expect(SimpleEventPlugin.willDeleteListener.mock.calls.length).toBe(1);
     });
@@ -641,7 +646,7 @@ describe('ReactDOMComponent', function() {
         },
       });
       var container = document.createElement('div');
-      React.render(<X />, container);
+      ReactDOM.render(<X />, container);
       expect(console.error.argsForCall.length).toBe(1);
       expect(console.error.argsForCall[0][0]).toBe(
         'Warning: input is a void element tag and must not have `children` ' +
@@ -660,8 +665,8 @@ describe('ReactDOMComponent', function() {
     it('should warn against children for void elements', function() {
       spyOn(console, 'error');
 
-      React.render(<input />, container);
-      React.render(<input>children</input>, container);
+      ReactDOM.render(<input />, container);
+      ReactDOM.render(<input>children</input>, container);
 
       expect(console.error.argsForCall.length).toBe(1);
       expect(console.error.argsForCall[0][0]).toContain('void element');
@@ -670,8 +675,8 @@ describe('ReactDOMComponent', function() {
     it('should warn against dangerouslySetInnerHTML for void elements', function() {
       spyOn(console, 'error');
 
-      React.render(<input />, container);
-      React.render(
+      ReactDOM.render(<input />, container);
+      ReactDOM.render(
         <input dangerouslySetInnerHTML={{__html: 'content'}} />,
         container
       );
@@ -681,10 +686,10 @@ describe('ReactDOMComponent', function() {
     });
 
     it('should validate against multiple children props', function() {
-      React.render(<div></div>, container);
+      ReactDOM.render(<div></div>, container);
 
       expect(function() {
-        React.render(
+        ReactDOM.render(
           <div children="" dangerouslySetInnerHTML={{__html: ''}}></div>,
           container
         );
@@ -696,7 +701,7 @@ describe('ReactDOMComponent', function() {
 
     it('should warn about contentEditable and children', function() {
       spyOn(console, 'error');
-      React.render(
+      ReactDOM.render(
         <div contentEditable={true}><div /></div>,
         container
       );
@@ -705,10 +710,10 @@ describe('ReactDOMComponent', function() {
     });
 
     it('should validate against invalid styles', function() {
-      React.render(<div></div>, container);
+      ReactDOM.render(<div></div>, container);
 
       expect(function() {
-        React.render(<div style={1}></div>, container);
+        ReactDOM.render(<div style={1}></div>, container);
       }).toThrow(
         'Invariant Violation: The `style` prop expects a mapping from style ' +
         'properties to values, not a string. For example, ' +
@@ -718,7 +723,7 @@ describe('ReactDOMComponent', function() {
 
     it('should properly escape text content and attributes values', function() {
       expect(
-        React.renderToStaticMarkup(
+        ReactDOMServer.renderToStaticMarkup(
           React.DOM.div({
             title: '\'"<>&',
             style: {
@@ -744,16 +749,16 @@ describe('ReactDOMComponent', function() {
 
       var callback = function() {};
       var instance = <div onClick={callback} />;
-      instance = React.render(instance, container);
+      instance = ReactDOM.render(instance, container);
 
-      var rootNode = React.findDOMNode(instance);
+      var rootNode = ReactDOM.findDOMNode(instance);
       var rootNodeID = ReactMount.getID(rootNode);
       expect(
         ReactBrowserEventEmitter.getListener(rootNodeID, 'onClick')
       ).toBe(callback);
-      expect(rootNode).toBe(React.findDOMNode(instance));
+      expect(rootNode).toBe(ReactDOM.findDOMNode(instance));
 
-      React.unmountComponentAtNode(container);
+      ReactDOM.unmountComponentAtNode(container);
 
       expect(
         ReactBrowserEventEmitter.getListener(rootNodeID, 'onClick')
@@ -825,7 +830,7 @@ describe('ReactDOMComponent', function() {
     it('warns on invalid nesting at root', () => {
       spyOn(console, 'error');
       var p = document.createElement('p');
-      React.render(<span><p /></span>, p);
+      ReactDOM.render(<span><p /></span>, p);
 
       expect(console.error.calls.length).toBe(1);
       expect(console.error.calls[0].args[0]).toBe(
@@ -954,8 +959,8 @@ describe('ReactDOMComponent', function() {
         },
       });
       var container = document.createElement('div');
-      React.render(<Animal />, container);
-      React.unmountComponentAtNode(container);
+      ReactDOM.render(<Animal />, container);
+      ReactDOM.unmountComponentAtNode(container);
       expect(innerDiv.isMounted()).toBe(false);
 
       expect(console.error.calls.length).toBe(5);
@@ -1011,5 +1016,4 @@ describe('ReactDOMComponent', function() {
       expect(typeof node.firstChild.getDOMNode).toBe('undefined');
     });
   });
-
 });

src/renderers/dom/shared/__tests__/ReactDOMTextComponent-test.js

@@ -12,34 +12,38 @@
 'use strict';
 
 var React;
+var ReactDOM;
+var ReactDOMServer;
 
 describe('ReactDOMTextComponent', function() {
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
+    ReactDOMServer = require('ReactDOMServer');
   });
 
   it('should escape the rootID', function() {
     var ThisThingShouldBeEscaped = '">>> LULZ <<<"';
     var ThisThingWasBeEscaped = '&quot;&gt;&gt;&gt; LULZ &lt;&lt;&lt;&quot;';
     var thing = <div><span key={ThisThingShouldBeEscaped}>LULZ</span></div>;
-    var html = React.renderToString(thing);
+    var html = ReactDOMServer.renderToString(thing);
     expect(html).not.toContain(ThisThingShouldBeEscaped);
     expect(html).toContain(ThisThingWasBeEscaped);
   });
 
   it('updates a mounted text component in place', function() {
     var el = document.createElement('div');
-    var inst = React.render(<div>{'foo'}{'bar'}</div>, el);
+    var inst = ReactDOM.render(<div>{'foo'}{'bar'}</div>, el);
 
-    var foo = React.findDOMNode(inst).children[0];
-    var bar = React.findDOMNode(inst).children[1];
+    var foo = ReactDOM.findDOMNode(inst).children[0];
+    var bar = ReactDOM.findDOMNode(inst).children[1];
     expect(foo.tagName).toBe('SPAN');
     expect(bar.tagName).toBe('SPAN');
 
-    inst = React.render(<div>{'baz'}{'qux'}</div>, el);
+    inst = ReactDOM.render(<div>{'baz'}{'qux'}</div>, el);
     // After the update, the spans should have stayed in place (as opposed to
     // getting unmounted and remounted)
-    expect(React.findDOMNode(inst).children[0]).toBe(foo);
-    expect(React.findDOMNode(inst).children[1]).toBe(bar);
+    expect(ReactDOM.findDOMNode(inst).children[0]).toBe(foo);
+    expect(ReactDOM.findDOMNode(inst).children[1]).toBe(bar);
   });
 });

src/renderers/shared/reconciler/__tests__/ReactComponent-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React;
+var ReactDOM;
 var ReactTestUtils;
 
 var mocks;
@@ -20,6 +21,7 @@ describe('ReactComponent', function() {
   beforeEach(function() {
     mocks = require('mocks');
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
   });
 
@@ -27,14 +29,14 @@ describe('ReactComponent', function() {
     var container = document.createElement('div');
     // jQuery objects are basically arrays; people often pass them in by mistake
     expect(function() {
-      React.render(<div></div>, [container]);
+      ReactDOM.render(<div></div>, [container]);
     }).toThrow(
       'Invariant Violation: _registerComponent(...): Target container ' +
       'is not a DOM element.'
     );
 
     expect(function() {
-      React.render(<div></div>, null);
+      ReactDOM.render(<div></div>, null);
     }).toThrow(
       'Invariant Violation: _registerComponent(...): Target container ' +
       'is not a DOM element.'
@@ -162,7 +164,7 @@ describe('ReactComponent', function() {
       componentDidMount: function() {
         // Check .props.title to make sure we got the right elements back
         expect(this.wrapperRef.getTitle()).toBe('wrapper');
-        expect(React.findDOMNode(this.innerRef).title).toBe('inner');
+        expect(ReactDOM.findDOMNode(this.innerRef).title).toBe('inner');
         mounted = true;
       },
     });
@@ -218,11 +220,11 @@ describe('ReactComponent', function() {
     // mount, update, unmount
     var el = document.createElement('div');
     log.push('start mount');
-    React.render(<Outer />, el);
+    ReactDOM.render(<Outer />, el);
     log.push('start update');
-    React.render(<Outer />, el);
+    ReactDOM.render(<Outer />, el);
     log.push('start unmount');
-    React.unmountComponentAtNode(el);
+    ReactDOM.unmountComponentAtNode(el);
 
     expect(log).toEqual([
       'start mount',
@@ -256,11 +258,11 @@ describe('ReactComponent', function() {
   it('fires the callback after a component is rendered', function() {
     var callback = mocks.getMockFunction();
     var container = document.createElement('div');
-    React.render(<div />, container, callback);
+    ReactDOM.render(<div />, container, callback);
     expect(callback.mock.calls.length).toBe(1);
-    React.render(<div className="foo" />, container, callback);
+    ReactDOM.render(<div className="foo" />, container, callback);
     expect(callback.mock.calls.length).toBe(2);
-    React.render(<span />, container, callback);
+    ReactDOM.render(<span />, container, callback);
     expect(callback.mock.calls.length).toBe(3);
   });
 
@@ -273,7 +275,7 @@ describe('ReactComponent', function() {
       },
     });
     var container = document.createElement('div');
-    var instance = React.render(<Potato />, container);
+    var instance = ReactDOM.render(<Potato />, container);
 
     instance.getDOMNode();
 

src/renderers/shared/reconciler/__tests__/ReactComponentLifeCycle-test.js

@@ -14,6 +14,7 @@
 var keyMirror = require('keyMirror');
 
 var React;
+var ReactDOM;
 var ReactInstanceMap;
 var ReactTestUtils;
 
@@ -99,6 +100,7 @@ describe('ReactComponentLifeCycle', function() {
   beforeEach(function() {
     require('mock-modules').dumpCache();
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
     ReactInstanceMap = require('ReactInstanceMap');
   });
@@ -116,9 +118,9 @@ describe('ReactComponentLifeCycle', function() {
       },
     });
     var element = <StatefulComponent />;
-    var firstInstance = React.render(element, container);
-    React.unmountComponentAtNode(container);
-    var secondInstance = React.render(element, container);
+    var firstInstance = ReactDOM.render(element, container);
+    ReactDOM.unmountComponentAtNode(container);
+    var secondInstance = ReactDOM.render(element, container);
     expect(firstInstance).not.toBe(secondInstance);
   });
 
@@ -291,11 +293,11 @@ describe('ReactComponentLifeCycle', function() {
     });
 
     var container = document.createElement('div');
-    var instance = React.render(<Component />, container);
+    var instance = ReactDOM.render(<Component />, container);
 
     expect(instance.isMounted()).toBe(true);
 
-    React.unmountComponentAtNode(container);
+    ReactDOM.unmountComponentAtNode(container);
 
     expect(instance.isMounted()).toBe(false);
   });
@@ -311,7 +313,7 @@ describe('ReactComponentLifeCycle', function() {
       },
       render: function() {
         if (this.state.isMounted) {
-          expect(React.findDOMNode(this).tagName).toBe('DIV');
+          expect(ReactDOM.findDOMNode(this).tagName).toBe('DIV');
         }
         return <div/>;
       },
@@ -384,7 +386,7 @@ describe('ReactComponentLifeCycle', function() {
     // yet initialized, or rendered.
     //
     var container = document.createElement('div');
-    var instance = React.render(<LifeCycleComponent />, container);
+    var instance = ReactDOM.render(<LifeCycleComponent />, container);
 
     // getInitialState
     expect(instance._testJournal.returnedFromGetInitialState).toEqual(
@@ -428,7 +430,7 @@ describe('ReactComponentLifeCycle', function() {
 
     expect(getLifeCycleState(instance)).toBe(ComponentLifeCycle.MOUNTED);
 
-    React.unmountComponentAtNode(container);
+    ReactDOM.unmountComponentAtNode(container);
 
     expect(instance._testJournal.stateAtStartOfWillUnmount)
       .toEqual(WILL_UNMOUNT_STATE);
@@ -499,7 +501,7 @@ describe('ReactComponentLifeCycle', function() {
       updateTooltip: function() {
         // Even though this.props.tooltip has an owner, updating it shouldn't
         // throw here because it's mounted as a root component
-        React.render(this.props.tooltip, this.container);
+        ReactDOM.render(this.props.tooltip, this.container);
       },
     });
     var Component = React.createClass({
@@ -515,14 +517,14 @@ describe('ReactComponentLifeCycle', function() {
     });
 
     var container = document.createElement('div');
-    React.render(
+    ReactDOM.render(
       <Component text="uno" tooltipText="one" />,
       container
     );
 
     // Since `instance` is a root component, we can set its props. This also
     // makes Tooltip rerender the tooltip component, which shouldn't throw.
-    React.render(
+    ReactDOM.render(
       <Component text="dos" tooltipText="two" />,
       container
     );
@@ -591,7 +593,7 @@ describe('ReactComponentLifeCycle', function() {
 
     var container = document.createElement('div');
     log = [];
-    React.render(<Outer x={17} />, container);
+    ReactDOM.render(<Outer x={17} />, container);
     expect(log).toEqual([
       'outer componentWillMount',
       'inner componentWillMount',
@@ -600,7 +602,7 @@ describe('ReactComponentLifeCycle', function() {
     ]);
 
     log = [];
-    React.render(<Outer x={42} />, container);
+    ReactDOM.render(<Outer x={42} />, container);
     expect(log).toEqual([
       'outer componentWillReceiveProps',
       'outer shouldComponentUpdate',
@@ -613,7 +615,7 @@ describe('ReactComponentLifeCycle', function() {
     ]);
 
     log = [];
-    React.unmountComponentAtNode(container);
+    ReactDOM.unmountComponentAtNode(container);
     expect(log).toEqual([
       'outer componentWillUnmount',
       'inner componentWillUnmount',

src/renderers/shared/reconciler/__tests__/ReactCompositeComponent-test.js

@@ -14,6 +14,7 @@
 var ChildUpdates;
 var MorphingComponent;
 var React;
+var ReactDOM;
 var ReactCurrentOwner;
 var ReactMount;
 var ReactPropTypes;
@@ -29,6 +30,7 @@ describe('ReactCompositeComponent', function() {
     require('mock-modules').dumpCache();
     reactComponentExpect = require('reactComponentExpect');
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactCurrentOwner = require('ReactCurrentOwner');
     ReactPropTypes = require('ReactPropTypes');
     ReactTestUtils = require('ReactTestUtils');
@@ -107,7 +109,7 @@ describe('ReactCompositeComponent', function() {
     var container = document.createElement('div');
     container.innerHTML = markup;
 
-    React.render(<Parent />, container);
+    ReactDOM.render(<Parent />, container);
     expect(console.error).not.toHaveBeenCalled();
   });
 
@@ -129,11 +131,11 @@ describe('ReactCompositeComponent', function() {
     var instance = <MorphingComponent />;
     instance = ReactTestUtils.renderIntoDocument(instance);
 
-    expect(React.findDOMNode(instance.refs.x).tagName).toBe('A');
+    expect(ReactDOM.findDOMNode(instance.refs.x).tagName).toBe('A');
     instance._toggleActivatedState();
-    expect(React.findDOMNode(instance.refs.x).tagName).toBe('B');
+    expect(ReactDOM.findDOMNode(instance.refs.x).tagName).toBe('B');
     instance._toggleActivatedState();
-    expect(React.findDOMNode(instance.refs.x).tagName).toBe('A');
+    expect(ReactDOM.findDOMNode(instance.refs.x).tagName).toBe('A');
   });
 
   it('should not cache old DOM nodes when switching constructors', function() {
@@ -144,7 +146,7 @@ describe('ReactCompositeComponent', function() {
     // rerender
     instance.setProps({renderAnchor: true, anchorClassOn: false});
     var anchor = instance.getAnchor();
-    var actualDOMAnchorNode = React.findDOMNode(anchor);
+    var actualDOMAnchorNode = ReactDOM.findDOMNode(anchor);
     expect(actualDOMAnchorNode.className).toBe('');
     expect(actualDOMAnchorNode).toBe(anchor.getDOMNode());
   });
@@ -262,12 +264,12 @@ describe('ReactCompositeComponent', function() {
     var instance = <Component />;
     expect(instance.forceUpdate).not.toBeDefined();
 
-    instance = React.render(instance, container);
+    instance = ReactDOM.render(instance, container);
     instance.forceUpdate();
 
     expect(console.error.calls.length).toBe(0);
 
-    React.unmountComponentAtNode(container);
+    ReactDOM.unmountComponentAtNode(container);
 
     instance.forceUpdate();
     expect(console.error.calls.length).toBe(1);
@@ -298,7 +300,7 @@ describe('ReactCompositeComponent', function() {
     var instance = <Component />;
     expect(instance.setState).not.toBeDefined();
 
-    instance = React.render(instance, container);
+    instance = ReactDOM.render(instance, container);
 
     expect(renders).toBe(1);
 
@@ -308,7 +310,7 @@ describe('ReactCompositeComponent', function() {
 
     expect(renders).toBe(2);
 
-    React.unmountComponentAtNode(container);
+    ReactDOM.unmountComponentAtNode(container);
     instance.setState({value: 2});
 
     expect(renders).toBe(2);
@@ -344,12 +346,12 @@ describe('ReactCompositeComponent', function() {
       },
     });
 
-    var instance = React.render(<Component />, container);
+    var instance = ReactDOM.render(<Component />, container);
 
     instance.setState({value: 1});
     expect(console.error.calls.length).toBe(0);
 
-    React.unmountComponentAtNode(container);
+    ReactDOM.unmountComponentAtNode(container);
     expect(console.error.calls.length).toBe(0);
     expect(cbCalled).toBe(false);
   });
@@ -377,7 +379,7 @@ describe('ReactCompositeComponent', function() {
 
     expect(console.error.calls.length).toBe(0);
 
-    var instance = React.render(<Component />, container);
+    var instance = ReactDOM.render(<Component />, container);
 
     expect(console.error.calls.length).toBe(1);
     expect(console.error.argsForCall[0][0]).toBe(
@@ -394,7 +396,7 @@ describe('ReactCompositeComponent', function() {
     expect(instance.state.value).toBe(1);
 
     // Forcing a rerender anywhere will cause the update to happen.
-    var instance2 = React.render(<Component prop={123} />, container);
+    var instance2 = ReactDOM.render(<Component prop={123} />, container);
     expect(instance).toBe(instance2);
     expect(renderedState).toBe(1);
     expect(instance2.state.value).toBe(1);
@@ -413,13 +415,13 @@ describe('ReactCompositeComponent', function() {
     var instance = <Component />;
     expect(instance.setProps).not.toBeDefined();
 
-    instance = React.render(instance, container);
+    instance = ReactDOM.render(instance, container);
     expect(function() {
       instance.setProps({value: 1});
     }).not.toThrow();
     expect(console.error.calls.length).toBe(1);  // setProps deprecated
 
-    React.unmountComponentAtNode(container);
+    ReactDOM.unmountComponentAtNode(container);
     expect(function() {
       instance.setProps({value: 2});
     }).not.toThrow();
@@ -452,7 +454,7 @@ describe('ReactCompositeComponent', function() {
         innerInstance = this.refs.inner;
       },
     });
-    React.render(<Component />, container);
+    ReactDOM.render(<Component />, container);
 
     expect(innerInstance).not.toBe(undefined);
     expect(function() {
@@ -513,8 +515,8 @@ describe('ReactCompositeComponent', function() {
       },
     });
 
-    React.render(<Component />, container);
-    React.unmountComponentAtNode(container);
+    ReactDOM.render(<Component />, container);
+    ReactDOM.unmountComponentAtNode(container);
     expect(innerUnmounted).toBe(true);
 
     // The text and both <div /> elements and their wrappers each call
@@ -603,7 +605,7 @@ describe('ReactCompositeComponent', function() {
     });
 
     var component = ReactTestUtils.renderIntoDocument(<Parent />);
-    expect(React.findDOMNode(component).innerHTML).toBe('bar');
+    expect(ReactDOM.findDOMNode(component).innerHTML).toBe('bar');
   });
 
   it('should pass context when re-rendered for static child', function() {
@@ -848,13 +850,13 @@ describe('ReactCompositeComponent', function() {
     });
 
     var div = document.createElement('div');
-    React.render(<Parent cntxt="noise" />, div);
+    ReactDOM.render(<Parent cntxt="noise" />, div);
     expect(div.children[0].innerHTML).toBe('noise');
     div.children[0].innerHTML = 'aliens';
     div.children[0].id = 'aliens';
     expect(div.children[0].innerHTML).toBe('aliens');
     expect(div.children[0].id).toBe('aliens');
-    React.render(<Parent cntxt="bar" />, div);
+    ReactDOM.render(<Parent cntxt="bar" />, div);
     expect(div.children[0].innerHTML).toBe('bar');
     expect(div.children[0].id).toBe('aliens');
   });
@@ -899,10 +901,10 @@ describe('ReactCompositeComponent', function() {
     });
 
     var container = document.createElement('div');
-    var instance = React.render(<Component update={0} />, container);
+    var instance = ReactDOM.render(<Component update={0} />, container);
     expect(renders).toBe(1);
     expect(instance.state.updated).toBe(false);
-    React.render(<Component update={1} />, container);
+    ReactDOM.render(<Component update={1} />, container);
     expect(renders).toBe(2);
     expect(instance.state.updated).toBe(true);
   });
@@ -937,24 +939,24 @@ describe('ReactCompositeComponent', function() {
     });
 
     var container = document.createElement('div');
-    var comp = React.render(<Component flipped={false} />, container);
-    expect(React.findDOMNode(comp.refs.static0).textContent).toBe('A');
-    expect(React.findDOMNode(comp.refs.static1).textContent).toBe('B');
+    var comp = ReactDOM.render(<Component flipped={false} />, container);
+    expect(ReactDOM.findDOMNode(comp.refs.static0).textContent).toBe('A');
+    expect(ReactDOM.findDOMNode(comp.refs.static1).textContent).toBe('B');
 
-    expect(React.findDOMNode(comp.refs.static0))
+    expect(ReactDOM.findDOMNode(comp.refs.static0))
       .toBe(comp.refs.static0.getDOMNode());
-    expect(React.findDOMNode(comp.refs.static1))
+    expect(ReactDOM.findDOMNode(comp.refs.static1))
       .toBe(comp.refs.static1.getDOMNode());
 
     // When flipping the order, the refs should update even though the actual
     // contents do not
-    React.render(<Component flipped={true} />, container);
-    expect(React.findDOMNode(comp.refs.static0).textContent).toBe('B');
-    expect(React.findDOMNode(comp.refs.static1).textContent).toBe('A');
+    ReactDOM.render(<Component flipped={true} />, container);
+    expect(ReactDOM.findDOMNode(comp.refs.static0).textContent).toBe('B');
+    expect(ReactDOM.findDOMNode(comp.refs.static1).textContent).toBe('A');
 
-    expect(React.findDOMNode(comp.refs.static0))
+    expect(ReactDOM.findDOMNode(comp.refs.static0))
       .toBe(comp.refs.static0.getDOMNode());
-    expect(React.findDOMNode(comp.refs.static1))
+    expect(ReactDOM.findDOMNode(comp.refs.static1))
       .toBe(comp.refs.static1.getDOMNode());
   });
 
@@ -963,11 +965,11 @@ describe('ReactCompositeComponent', function() {
     var b = null;
     var Component = React.createClass({
       componentDidMount: function() {
-        a = React.findDOMNode(this);
+        a = ReactDOM.findDOMNode(this);
         expect(a).toBe(this.getDOMNode());
       },
       componentWillUnmount: function() {
-        b = React.findDOMNode(this);
+        b = ReactDOM.findDOMNode(this);
         expect(b).toBe(this.getDOMNode());
       },
       render: function() {
@@ -976,8 +978,8 @@ describe('ReactCompositeComponent', function() {
     });
     var container = document.createElement('div');
     expect(a).toBe(container.firstChild);
-    React.render(<Component />, container);
-    React.unmountComponentAtNode(container);
+    ReactDOM.render(<Component />, container);
+    ReactDOM.unmountComponentAtNode(container);
     expect(a).toBe(b);
   });
 
@@ -1022,7 +1024,7 @@ describe('ReactCompositeComponent', function() {
     });
 
     var div = document.createElement('div');
-    React.render(<Parent><Component /></Parent>, div);
+    ReactDOM.render(<Parent><Component /></Parent>, div);
 
     expect(console.error.argsForCall.length).toBe(0);
   });
@@ -1098,11 +1100,11 @@ describe('ReactCompositeComponent', function() {
 
     var Component = React.createClass({
       componentWillMount: function() {
-        React.render(<div />, layer);
+        ReactDOM.render(<div />, layer);
       },
 
       componentWillUnmount: function() {
-        React.unmountComponentAtNode(layer);
+        ReactDOM.unmountComponentAtNode(layer);
       },
 
       render: function() {
@@ -1116,11 +1118,11 @@ describe('ReactCompositeComponent', function() {
       },
     });
 
-    React.render(<Outer><Component /></Outer>, container);
+    ReactDOM.render(<Outer><Component /></Outer>, container);
 
     expect(console.error.calls.length).toBe(0);
 
-    React.render(<Outer />, container);
+    ReactDOM.render(<Outer />, container);
 
     expect(console.error.calls.length).toBe(0);
   });

src/renderers/shared/reconciler/__tests__/ReactCompositeComponentNestedState-test.js

@@ -14,12 +14,14 @@
 var mocks = require('mocks');
 
 var React;
+var ReactDOM;
 var ReactTestUtils;
 
 describe('ReactCompositeComponentNestedState-state', function() {
 
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
   });
 
@@ -92,7 +94,7 @@ describe('ReactCompositeComponentNestedState-state', function() {
 
     var logger = mocks.getMockFunction();
 
-    void React.render(
+    void ReactDOM.render(
       <ParentComponent logger={logger} />,
       container
     );

src/renderers/shared/reconciler/__tests__/ReactCompositeComponentState-test.js

@@ -14,6 +14,7 @@
 var mocks = require('mocks');
 
 var React;
+var ReactDOM;
 
 var TestComponent;
 
@@ -22,6 +23,8 @@ describe('ReactCompositeComponent-state', function() {
   beforeEach(function() {
     React = require('React');
 
+    ReactDOM = require('ReactDOM');
+
     TestComponent = React.createClass({
       peekAtState: function(from, state) {
         state = state || this.state;
@@ -123,7 +126,6 @@ describe('ReactCompositeComponent-state', function() {
         this.peekAtState('componentWillUnmount');
       },
     });
-
   });
 
   it('should support setting state', function() {
@@ -131,14 +133,14 @@ describe('ReactCompositeComponent-state', function() {
     document.body.appendChild(container);
 
     var stateListener = mocks.getMockFunction();
-    var instance = React.render(
+    var instance = ReactDOM.render(
       <TestComponent stateListener={stateListener} />,
       container,
       function peekAtInitialCallback() {
         this.peekAtState('initial-callback');
       }
     );
-    React.render(
+    ReactDOM.render(
       <TestComponent stateListener={stateListener} nextColor="green" />,
       container,
       instance.peekAtCallback('setProps')
@@ -146,7 +148,7 @@ describe('ReactCompositeComponent-state', function() {
     instance.setFavoriteColor('blue');
     instance.forceUpdate(instance.peekAtCallback('forceUpdate'));
 
-    React.unmountComponentAtNode(container);
+    ReactDOM.unmountComponentAtNode(container);
 
     expect(stateListener.mock.calls.join('\n')).toEqual([
       // there is no state when getInitialState() is called
@@ -238,9 +240,9 @@ describe('ReactCompositeComponent-state', function() {
     });
 
     var container = document.createElement('div');
-    outer = React.render(<Outer />, container);
+    outer = ReactDOM.render(<Outer />, container);
     expect(() => {
-      React.unmountComponentAtNode(container);
+      ReactDOM.unmountComponentAtNode(container);
     }).not.toThrow();
   });
 });

src/renderers/shared/reconciler/__tests__/ReactEmptyComponent-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React;
+var ReactDOM;
 var ReactEmptyComponent;
 var ReactTestUtils;
 var TogglingComponent;
@@ -23,6 +24,7 @@ describe('ReactEmptyComponent', function() {
     require('mock-modules').dumpCache();
 
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactEmptyComponent = require('ReactEmptyComponent');
     ReactTestUtils = require('ReactTestUtils');
 
@@ -33,11 +35,11 @@ describe('ReactEmptyComponent', function() {
         return {component: this.props.firstComponent};
       },
       componentDidMount: function() {
-        console.log(React.findDOMNode(this));
+        console.log(ReactDOM.findDOMNode(this));
         this.setState({component: this.props.secondComponent});
       },
       componentDidUpdate: function() {
-        console.log(React.findDOMNode(this));
+        console.log(ReactDOM.findDOMNode(this));
       },
       render: function() {
         var Component = this.state.component;
@@ -188,13 +190,13 @@ describe('ReactEmptyComponent', function() {
       componentDidMount: function() {
         // Make sure the DOM node resolves properly even if we're replacing a
         // `null` component
-        expect(React.findDOMNode(this)).not.toBe(null);
+        expect(ReactDOM.findDOMNode(this)).not.toBe(null);
         assertions++;
       },
       componentWillUnmount: function() {
         // Even though we're getting replaced by `null`, we haven't been
         // replaced yet!
-        expect(React.findDOMNode(this)).not.toBe(null);
+        expect(ReactDOM.findDOMNode(this)).not.toBe(null);
         assertions++;
       },
     });
@@ -208,16 +210,16 @@ describe('ReactEmptyComponent', function() {
     var component;
 
     // Render the <Inner /> component...
-    component = React.render(<Wrapper showInner={true} />, el);
-    expect(React.findDOMNode(component)).not.toBe(null);
+    component = ReactDOM.render(<Wrapper showInner={true} />, el);
+    expect(ReactDOM.findDOMNode(component)).not.toBe(null);
 
     // Switch to null...
-    component = React.render(<Wrapper showInner={false} />, el);
-    expect(React.findDOMNode(component)).toBe(null);
+    component = ReactDOM.render(<Wrapper showInner={false} />, el);
+    expect(ReactDOM.findDOMNode(component)).toBe(null);
 
     // ...then switch back.
-    component = React.render(<Wrapper showInner={true} />, el);
-    expect(React.findDOMNode(component)).not.toBe(null);
+    component = ReactDOM.render(<Wrapper showInner={true} />, el);
+    expect(ReactDOM.findDOMNode(component)).not.toBe(null);
 
     expect(assertions).toBe(3);
   });
@@ -226,7 +228,7 @@ describe('ReactEmptyComponent', function() {
     // TODO: This should actually work since `null` is a valid ReactNode
     var div = document.createElement('div');
     expect(function() {
-      React.render(null, div);
+      ReactDOM.render(null, div);
     }).toThrow(
       'Invariant Violation: React.render(): Invalid component element.'
     );

src/renderers/shared/reconciler/__tests__/ReactIdentity-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React;
+var ReactDOM;
 var ReactFragment;
 var ReactTestUtils;
 var ReactMount;
@@ -21,6 +22,7 @@ describe('ReactIdentity', function() {
   beforeEach(function() {
     require('mock-modules').dumpCache();
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactFragment = require('ReactFragment');
     ReactTestUtils = require('ReactTestUtils');
     ReactMount = require('ReactMount');
@@ -48,8 +50,8 @@ describe('ReactIdentity', function() {
         })}
       </div>;
 
-    instance = React.render(instance, document.createElement('div'));
-    var node = React.findDOMNode(instance);
+    instance = ReactDOM.render(instance, document.createElement('div'));
+    var node = ReactDOM.findDOMNode(instance);
     expect(node.childNodes.length).toBe(2);
     checkID(node.childNodes[0], '.0.$first:0');
     checkID(node.childNodes[1], '.0.$second:0');
@@ -64,8 +66,8 @@ describe('ReactIdentity', function() {
         <div key={123} />
       </div>;
 
-    instance = React.render(instance, document.createElement('div'));
-    var node = React.findDOMNode(instance);
+    instance = ReactDOM.render(instance, document.createElement('div'));
+    var node = ReactDOM.findDOMNode(instance);
     expect(node.childNodes.length).toBe(4);
     checkID(node.childNodes[0], '.0.$apple');
     checkID(node.childNodes[1], '.0.$banana');
@@ -88,8 +90,8 @@ describe('ReactIdentity', function() {
         <Wrapper><span key="chipmunk" /></Wrapper>
       </div>;
 
-    instance = React.render(instance, document.createElement('div'));
-    var node = React.findDOMNode(instance);
+    instance = ReactDOM.render(instance, document.createElement('div'));
+    var node = ReactDOM.findDOMNode(instance);
     expect(node.childNodes.length).toBe(3);
 
     checkID(node.childNodes[0], '.0.$wrap1');
@@ -115,17 +117,17 @@ describe('ReactIdentity', function() {
 
     });
 
-    var instance = React.render(<Wrapper />, container);
+    var instance = ReactDOM.render(<Wrapper />, container);
     var span1 = instance.refs.span1;
     var span2 = instance.refs.span2;
 
-    expect(React.findDOMNode(span1)).not.toBe(null);
-    expect(React.findDOMNode(span2)).not.toBe(null);
+    expect(ReactDOM.findDOMNode(span1)).not.toBe(null);
+    expect(ReactDOM.findDOMNode(span2)).not.toBe(null);
 
     key = key.replace(/=/g, '=0');
 
-    checkID(React.findDOMNode(span1), '.0.$' + key);
-    checkID(React.findDOMNode(span2), '.0.1:$' + key + ':0');
+    checkID(ReactDOM.findDOMNode(span1), '.0.$' + key);
+    checkID(ReactDOM.findDOMNode(span2), '.0.1:$' + key + ':0');
   }
 
   it('should allow any character as a key, in a detached parent', function() {
@@ -294,13 +296,13 @@ describe('ReactIdentity', function() {
 
     var wrapped = <TestContainer first={instance0} second={instance1} />;
 
-    wrapped = React.render(wrapped, document.createElement('div'));
+    wrapped = ReactDOM.render(wrapped, document.createElement('div'));
 
-    var beforeID = ReactMount.getID(React.findDOMNode(wrapped).firstChild);
+    var beforeID = ReactMount.getID(ReactDOM.findDOMNode(wrapped).firstChild);
 
     wrapped.swap();
 
-    var afterID = ReactMount.getID(React.findDOMNode(wrapped).firstChild);
+    var afterID = ReactMount.getID(ReactDOM.findDOMNode(wrapped).firstChild);
 
     expect(beforeID).not.toEqual(afterID);
 

src/renderers/shared/reconciler/__tests__/ReactMultiChild-test.js

@@ -16,9 +16,12 @@ var mocks = require('mocks');
 describe('ReactMultiChild', function() {
   var React;
 
+  var ReactDOM;
+
   beforeEach(function() {
     require('mock-modules').dumpCache();
     React = require('React');
+    ReactDOM = require('ReactDOM');
   });
 
   describe('reconciliation', function() {
@@ -42,13 +45,13 @@ describe('ReactMultiChild', function() {
       expect(mockUpdate.mock.calls.length).toBe(0);
       expect(mockUnmount.mock.calls.length).toBe(0);
 
-      React.render(<div><MockComponent /></div>, container);
+      ReactDOM.render(<div><MockComponent /></div>, container);
 
       expect(mockMount.mock.calls.length).toBe(1);
       expect(mockUpdate.mock.calls.length).toBe(0);
       expect(mockUnmount.mock.calls.length).toBe(0);
 
-      React.render(<div><MockComponent /></div>, container);
+      ReactDOM.render(<div><MockComponent /></div>, container);
 
       expect(mockMount.mock.calls.length).toBe(1);
       expect(mockUpdate.mock.calls.length).toBe(1);
@@ -72,12 +75,12 @@ describe('ReactMultiChild', function() {
       expect(mockMount.mock.calls.length).toBe(0);
       expect(mockUnmount.mock.calls.length).toBe(0);
 
-      React.render(<div><MockComponent /></div>, container);
+      ReactDOM.render(<div><MockComponent /></div>, container);
 
       expect(mockMount.mock.calls.length).toBe(1);
       expect(mockUnmount.mock.calls.length).toBe(0);
 
-      React.render(<div><span /></div>, container);
+      ReactDOM.render(<div><span /></div>, container);
 
       expect(mockMount.mock.calls.length).toBe(1);
       expect(mockUnmount.mock.calls.length).toBe(1);
@@ -106,12 +109,12 @@ describe('ReactMultiChild', function() {
       expect(mockMount.mock.calls.length).toBe(0);
       expect(mockUnmount.mock.calls.length).toBe(0);
 
-      React.render(<WrapperComponent />, container);
+      ReactDOM.render(<WrapperComponent />, container);
 
       expect(mockMount.mock.calls.length).toBe(1);
       expect(mockUnmount.mock.calls.length).toBe(0);
 
-      React.render(
+      ReactDOM.render(
         <WrapperComponent><MockComponent /></WrapperComponent>,
         container
       );
@@ -137,12 +140,12 @@ describe('ReactMultiChild', function() {
       expect(mockMount.mock.calls.length).toBe(0);
       expect(mockUnmount.mock.calls.length).toBe(0);
 
-      React.render(<div><MockComponent key="A" /></div>, container);
+      ReactDOM.render(<div><MockComponent key="A" /></div>, container);
 
       expect(mockMount.mock.calls.length).toBe(1);
       expect(mockUnmount.mock.calls.length).toBe(0);
 
-      React.render(<div><MockComponent key="B" /></div>, container);
+      ReactDOM.render(<div><MockComponent key="B" /></div>, container);
 
       expect(mockMount.mock.calls.length).toBe(2);
       expect(mockUnmount.mock.calls.length).toBe(1);
@@ -172,7 +175,7 @@ describe('ReactMultiChild', function() {
     it('should only set `innerHTML` once on update', function() {
       var container = document.createElement('div');
 
-      React.render(
+      ReactDOM.render(
         <div>
           <p><span /></p>
           <p><span /></p>
@@ -181,7 +184,7 @@ describe('ReactMultiChild', function() {
         container
       );
       // Warm the cache used by `getMarkupWrap`.
-      React.render(
+      ReactDOM.render(
         <div>
           <p><span /><span /></p>
           <p><span /><span /></p>
@@ -192,7 +195,7 @@ describe('ReactMultiChild', function() {
       expect(setInnerHTML).toHaveBeenCalled();
       var callCountOnMount = setInnerHTML.calls.length;
 
-      React.render(
+      ReactDOM.render(
         <div>
           <p><span /><span /><span /></p>
           <p><span /><span /><span /></p>

src/renderers/shared/reconciler/__tests__/ReactMultiChildReconcile-test.js

@@ -14,6 +14,7 @@
 require('mock-modules');
 
 var React = require('React');
+var ReactDOM = require('ReactDOM');
 var ReactInstanceMap = require('ReactInstanceMap');
 var ReactMount = require('ReactMount');
 
@@ -186,7 +187,7 @@ function verifyStatesPreserved(lastInternalStates, statusDisplays) {
  * accurately reflects what is in the DOM.
  */
 function verifyDomOrderingAccurate(parentInstance, statusDisplays) {
-  var containerNode = React.findDOMNode(parentInstance);
+  var containerNode = ReactDOM.findDOMNode(parentInstance);
   var statusDisplayNodes = containerNode.childNodes;
   var i;
   var orderedDomIDs = [];
@@ -212,7 +213,7 @@ function verifyDomOrderingAccurate(parentInstance, statusDisplays) {
 function testPropsSequence(sequence) {
   var i;
   var container = document.createElement('div');
-  var parentInstance = React.render(
+  var parentInstance = ReactDOM.render(
     <FriendsStatusDisplay {...sequence[0]} />,
     container
   );
@@ -221,7 +222,7 @@ function testPropsSequence(sequence) {
   verifyStatuses(statusDisplays, sequence[0]);
 
   for (i = 1; i < sequence.length; i++) {
-    React.render(
+    ReactDOM.render(
       <FriendsStatusDisplay {...sequence[i]} />,
       container
     );
@@ -248,7 +249,7 @@ describe('ReactMultiChildReconcile', function() {
     };
 
     var container = document.createElement('div');
-    var parentInstance = React.render(
+    var parentInstance = ReactDOM.render(
       <FriendsStatusDisplay {...props} />,
       container
     );
@@ -256,7 +257,7 @@ describe('ReactMultiChildReconcile', function() {
     var startingInternalState = statusDisplays.jcw.getInternalState();
 
     // Now remove the child.
-    React.render(
+    ReactDOM.render(
       <FriendsStatusDisplay />,
       container
     );
@@ -264,7 +265,7 @@ describe('ReactMultiChildReconcile', function() {
     expect(statusDisplays.jcw).toBeFalsy();
 
     // Now reset the props that cause there to be a child
-    React.render(
+    ReactDOM.render(
       <FriendsStatusDisplay {...props} />,
       container
     );

src/renderers/shared/reconciler/__tests__/ReactMultiChildText-test.js

@@ -14,6 +14,7 @@
 require('mock-modules');
 
 var React = require('React');
+var ReactDOM = require('ReactDOM');
 var ReactFragment = require('ReactFragment');
 var ReactTestUtils = require('ReactTestUtils');
 
@@ -30,17 +31,17 @@ var testAllPermutations = function(testCases) {
       var expectedResultAfterUpdate = testCases[j + 1];
 
       var container = document.createElement('div');
-      var d = React.render(<div>{renderWithChildren}</div>, container);
+      var d = ReactDOM.render(<div>{renderWithChildren}</div>, container);
       expectChildren(d, expectedResultAfterRender);
 
-      d = React.render(<div>{updateWithChildren}</div>, container);
+      d = ReactDOM.render(<div>{updateWithChildren}</div>, container);
       expectChildren(d, expectedResultAfterUpdate);
     }
   }
 };
 
 var expectChildren = function(d, children) {
-  var outerNode = React.findDOMNode(d);
+  var outerNode = ReactDOM.findDOMNode(d);
   var textNode;
   if (typeof children === 'string') {
     textNode = outerNode.firstChild;

src/renderers/shared/reconciler/__tests__/ReactUpdates-test.js

@@ -12,12 +12,14 @@
 'use strict';
 
 var React;
+var ReactDOM;
 var ReactTestUtils;
 var ReactUpdates;
 
 describe('ReactUpdates', function() {
   beforeEach(function() {
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
     ReactUpdates = require('ReactUpdates');
   });
@@ -96,12 +98,12 @@ describe('ReactUpdates', function() {
     });
 
     var container = document.createElement('div');
-    var instance = React.render(<Component x={0} />, container);
+    var instance = ReactDOM.render(<Component x={0} />, container);
     expect(instance.props.x).toBe(0);
     expect(instance.state.y).toBe(0);
 
     ReactUpdates.batchedUpdates(function() {
-      React.render(<Component x={1} />, container);
+      ReactDOM.render(<Component x={1} />, container);
       instance.setState({y: 2});
       expect(instance.props.x).toBe(0);
       expect(instance.state.y).toBe(0);
@@ -501,16 +503,16 @@ describe('ReactUpdates', function() {
 
     // Initial renders aren't batched together yet...
     ReactUpdates.batchedUpdates(function() {
-      React.render(<Component text="A1" />, containerA);
-      React.render(<Component text="B1" />, containerB);
+      ReactDOM.render(<Component text="A1" />, containerA);
+      ReactDOM.render(<Component text="B1" />, containerB);
     });
     expect(ReconcileTransaction.getPooled.calls.length).toBe(2);
 
     // ...but updates are! Here only one more transaction is used, which means
     // we only have to initialize and close the wrappers once.
     ReactUpdates.batchedUpdates(function() {
-      React.render(<Component text="A2" />, containerA);
-      React.render(<Component text="B2" />, containerB);
+      ReactDOM.render(<Component text="A2" />, containerA);
+      ReactDOM.render(<Component text="B2" />, containerB);
     });
     expect(ReconcileTransaction.getPooled.calls.length).toBe(3);
   });
@@ -530,7 +532,7 @@ describe('ReactUpdates', function() {
         return {x: 0};
       },
       componentDidUpdate: function() {
-        expect(React.findDOMNode(b).textContent).toBe('B1');
+        expect(ReactDOM.findDOMNode(b).textContent).toBe('B1');
         aUpdated = true;
       },
       render: function() {
@@ -641,12 +643,12 @@ describe('ReactUpdates', function() {
       componentDidMount: function() {
         instances.push(this);
         if (this.props.depth < this.props.count) {
-          React.render(
+          ReactDOM.render(
             <MockComponent
               depth={this.props.depth + 1}
               count={this.props.count}
             />,
-            React.findDOMNode(this)
+            ReactDOM.findDOMNode(this)
           );
         }
       },
@@ -715,10 +717,10 @@ describe('ReactUpdates', function() {
 
     x = ReactTestUtils.renderIntoDocument(<X />);
     y = ReactTestUtils.renderIntoDocument(<Y />);
-    expect(React.findDOMNode(x).textContent).toBe('0');
+    expect(ReactDOM.findDOMNode(x).textContent).toBe('0');
 
     y.forceUpdate();
-    expect(React.findDOMNode(x).textContent).toBe('1');
+    expect(ReactDOM.findDOMNode(x).textContent).toBe('1');
   });
 
   it('should queue updates from during mount', function() {
@@ -756,7 +758,7 @@ describe('ReactUpdates', function() {
     });
 
     expect(a.state.x).toBe(1);
-    expect(React.findDOMNode(a).textContent).toBe('A1');
+    expect(ReactDOM.findDOMNode(a).textContent).toBe('A1');
   });
 
   it('calls componentWillReceiveProps setState callback properly', function() {
@@ -779,8 +781,8 @@ describe('ReactUpdates', function() {
     });
 
     var container = document.createElement('div');
-    React.render(<A x={1} />, container);
-    React.render(<A x={2} />, container);
+    ReactDOM.render(<A x={1} />, container);
+    ReactDOM.render(<A x={2} />, container);
     expect(callbackCount).toBe(1);
   });
 

src/renderers/shared/reconciler/__tests__/refs-destruction-test.js

@@ -12,6 +12,7 @@
 'use strict';
 
 var React;
+var ReactDOM;
 var ReactTestUtils;
 
 var TestComponent;
@@ -21,6 +22,7 @@ describe('refs-destruction', function() {
     require('mock-modules').dumpCache();
 
     React = require('React');
+    ReactDOM = require('ReactDOM');
     ReactTestUtils = require('ReactTestUtils');
 
     TestComponent = React.createClass({
@@ -40,21 +42,21 @@ describe('refs-destruction', function() {
 
   it('should remove refs when destroying the parent', function() {
     var container = document.createElement('div');
-    var testInstance = React.render(<TestComponent />, container);
+    var testInstance = ReactDOM.render(<TestComponent />, container);
     expect(ReactTestUtils.isDOMComponent(testInstance.refs.theInnerDiv))
       .toBe(true);
     expect(Object.keys(testInstance.refs || {}).length).toEqual(1);
-    React.unmountComponentAtNode(container);
+    ReactDOM.unmountComponentAtNode(container);
     expect(Object.keys(testInstance.refs || {}).length).toEqual(0);
   });
 
   it('should remove refs when destroying the child', function() {
     var container = document.createElement('div');
-    var testInstance = React.render(<TestComponent />, container);
+    var testInstance = ReactDOM.render(<TestComponent />, container);
     expect(ReactTestUtils.isDOMComponent(testInstance.refs.theInnerDiv))
       .toBe(true);
     expect(Object.keys(testInstance.refs || {}).length).toEqual(1);
-    React.render(<TestComponent destroy={true} />, container);
+    ReactDOM.render(<TestComponent destroy={true} />, container);
     expect(Object.keys(testInstance.refs || {}).length).toEqual(0);
   });
 });

src/test/ReactTestUtils.js

@@ -15,6 +15,7 @@ var EventConstants = require('EventConstants');
 var EventPluginHub = require('EventPluginHub');
 var EventPropagators = require('EventPropagators');
 var React = require('React');
+var ReactDOM = require('ReactDOM');
 var ReactElement = require('ReactElement');
 var ReactEmptyComponent = require('ReactEmptyComponent');
 var ReactBrowserEventEmitter = require('ReactBrowserEventEmitter');
@@ -79,7 +80,7 @@ var ReactTestUtils = {
     // clean up, so we're going to stop honoring the name of this method
     // (and probably rename it eventually) if no problems arise.
     // document.documentElement.appendChild(div);
-    return React.render(instance, div);
+    return ReactDOM.render(instance, div);
   },
 
   isElement: function(element) {
@@ -177,7 +178,7 @@ var ReactTestUtils = {
   scryRenderedDOMComponentsWithClass: function(root, className) {
     return ReactTestUtils.findAllInRenderedTree(root, function(inst) {
       if (ReactTestUtils.isDOMComponent(inst)) {
-        var instClassName = React.findDOMNode(inst).className;
+        var instClassName = ReactDOM.findDOMNode(inst).className;
         return (
           instClassName &&
           (('' + instClassName).split(/\s+/)).indexOf(className) !== -1

src/test/__tests__/ReactTestUtils-test.js

@@ -12,6 +12,8 @@
 'use strict';
 
 var React;
+var ReactDOM;
+var ReactDOMServer;
 var ReactTestUtils;
 
 var mocks;
@@ -22,6 +24,8 @@ describe('ReactTestUtils', function() {
     mocks = require('mocks');
 
     React = require('React');
+    ReactDOM = require('ReactDOM');
+    ReactDOMServer = require('ReactDOMServer');
     ReactTestUtils = require('ReactTestUtils');
   });
 
@@ -206,14 +210,14 @@ describe('ReactTestUtils', function() {
     });
 
     var container = document.createElement('div');
-    React.render(
+    ReactDOM.render(
       <Wrapper>
         {null}
         <div>purple</div>
       </Wrapper>,
       container
     );
-    var tree = React.render(
+    var tree = ReactDOM.render(
       <Wrapper>
         <div>orange</div>
         <div>purple</div>
@@ -224,7 +228,7 @@ describe('ReactTestUtils', function() {
     var log = [];
     ReactTestUtils.findAllInRenderedTree(tree, function(child) {
       if (ReactTestUtils.isDOMComponent(child)) {
-        log.push(React.findDOMNode(child).textContent);
+        log.push(ReactDOM.findDOMNode(child).textContent);
       }
     });
 
@@ -298,9 +302,9 @@ describe('ReactTestUtils', function() {
       },
     });
 
-    var markup = React.renderToString(<Root />);
+    var markup = ReactDOMServer.renderToString(<Root />);
     var testDocument = getTestDocument(markup);
-    var component = React.render(<Root />, testDocument);
+    var component = ReactDOM.render(<Root />, testDocument);
 
     expect(component.refs.html.tagName).toBe('HTML');
     expect(component.refs.head.tagName).toBe('HEAD');