@samitouri / QOS-React-2 / commits / f06ddf7905

Turn ReactInstanceHandles-test into ReactDOMTreeTraversal-test

This test relied on the fact that ReactDOMComponent still produced hierarchical IDs -- although this module could be used standalone, we're replacing it completely so it makes more sense to just move the tests over to test ReactDOMTreeTraversal.

Ben Alpert committed Oct 18, 2015 at 15:35 UTC f06ddf79054a1df0c5a33e4b56226c3ed0d29470
2 files changed +273 -383
src/renderers/dom/client/__tests__/ReactDOMTreeTraversal-test.js new
+273
@@ -0,0 +1,273 @@
1 +/**
2 + * Copyright 2013-2015, Facebook, Inc.
3 + * All rights reserved.
4 + *
5 + * This source code is licensed under the BSD-style license found in the
6 + * LICENSE file in the root directory of this source tree. An additional grant
7 + * of patent rights can be found in the PATENTS file in the same directory.
8 + *
9 + * @emails react-core
10 + */
11 +
12 +'use strict';
13 +
14 +var React = require('React');
15 +var ReactDOMComponentTree = require('ReactDOMComponentTree');
16 +var ReactTestUtils = require('ReactTestUtils');
17 +
18 +/**
19 + * Ensure that all callbacks are invoked, passing this unique argument.
20 + */
21 +var ARG = {arg: true};
22 +var ARG2 = {arg2: true};
23 +
24 +var ChildComponent = React.createClass({
25 + render: function() {
26 + return (
27 + <div ref="DIV">
28 + <div ref="DIV_1" />
29 + <div ref="DIV_2" />
30 + </div>
31 + );
32 + },
33 +});
34 +
35 +var ParentComponent = React.createClass({
36 + render: function() {
37 + return (
38 + <div ref="P">
39 + <div ref="P_P1">
40 + <ChildComponent ref="P_P1_C1" />
41 + <ChildComponent ref="P_P1_C2" />
42 + </div>
43 + <div ref="P_OneOff" />
44 + </div>
45 + );
46 + },
47 +});
48 +
49 +function renderParentIntoDocument() {
50 + return ReactTestUtils.renderIntoDocument(<ParentComponent />);
51 +}
52 +
53 +describe('ReactDOMTreeTraversal', function() {
54 + var ReactDOMTreeTraversal;
55 +
56 + var aggregatedArgs;
57 + function argAggregator(inst, isUp, arg) {
58 + aggregatedArgs.push({
59 + node: ReactDOMComponentTree.getNodeFromInstance(inst),
60 + isUp: isUp,
61 + arg: arg,
62 + });
63 + }
64 +
65 + function getInst(node) {
66 + return ReactDOMComponentTree.getInstanceFromNode(node);
67 + }
68 +
69 + beforeEach(function() {
70 + ReactDOMTreeTraversal = require('ReactDOMTreeTraversal');
71 + aggregatedArgs = [];
72 + });
73 +
74 + describe('traverseTwoPhase', function() {
75 + it('should not traverse when traversing outside DOM', function() {
76 + var expectedAggregation = [];
77 + ReactDOMTreeTraversal.traverseTwoPhase(null, argAggregator, ARG);
78 + expect(aggregatedArgs).toEqual(expectedAggregation);
79 + });
80 +
81 + it('should traverse two phase across component boundary', function() {
82 + var parent = renderParentIntoDocument();
83 + var target = getInst(parent.refs.P_P1_C1.refs.DIV_1);
84 + var expectedAggregation = [
85 + {node: parent.refs.P, isUp: false, arg: ARG},
86 + {node: parent.refs.P_P1, isUp: false, arg: ARG},
87 + {node: parent.refs.P_P1_C1.refs.DIV, isUp: false, arg: ARG},
88 + {node: parent.refs.P_P1_C1.refs.DIV_1, isUp: false, arg: ARG},
89 +
90 + {node: parent.refs.P_P1_C1.refs.DIV_1, isUp: true, arg: ARG},
91 + {node: parent.refs.P_P1_C1.refs.DIV, isUp: true, arg: ARG},
92 + {node: parent.refs.P_P1, isUp: true, arg: ARG},
93 + {node: parent.refs.P, isUp: true, arg: ARG},
94 + ];
95 + ReactDOMTreeTraversal.traverseTwoPhase(target, argAggregator, ARG);
96 + expect(aggregatedArgs).toEqual(expectedAggregation);
97 + });
98 +
99 + it('should traverse two phase at shallowest node', function() {
100 + var parent = renderParentIntoDocument();
101 + var target = getInst(parent.refs.P);
102 + var expectedAggregation = [
103 + {node: parent.refs.P, isUp: false, arg: ARG},
104 + {node: parent.refs.P, isUp: true, arg: ARG},
105 + ];
106 + ReactDOMTreeTraversal.traverseTwoPhase(target, argAggregator, ARG);
107 + expect(aggregatedArgs).toEqual(expectedAggregation);
108 + });
109 + });
110 +
111 + describe('traverseEnterLeave', function() {
112 + it('should not traverse when enter/leaving outside DOM', function() {
113 + var target = null;
114 + var expectedAggregation = [];
115 + ReactDOMTreeTraversal.traverseEnterLeave(
116 + target, target, argAggregator, ARG, ARG2
117 + );
118 + expect(aggregatedArgs).toEqual(expectedAggregation);
119 + });
120 +
121 + it('should not traverse if enter/leave the same node', function() {
122 + var parent = renderParentIntoDocument();
123 + var leave = getInst(parent.refs.P_P1_C1.refs.DIV_1);
124 + var enter = getInst(parent.refs.P_P1_C1.refs.DIV_1);
125 + var expectedAggregation = [];
126 + ReactDOMTreeTraversal.traverseEnterLeave(
127 + leave, enter, argAggregator, ARG, ARG2
128 + );
129 + expect(aggregatedArgs).toEqual(expectedAggregation);
130 + });
131 +
132 + it('should traverse enter/leave to sibling - avoids parent', function() {
133 + var parent = renderParentIntoDocument();
134 + var leave = getInst(parent.refs.P_P1_C1.refs.DIV_1);
135 + var enter = getInst(parent.refs.P_P1_C1.refs.DIV_2);
136 + var expectedAggregation = [
137 + {node: parent.refs.P_P1_C1.refs.DIV_1, isUp: true, arg: ARG},
138 + // enter/leave shouldn't fire antyhing on the parent
139 + {node: parent.refs.P_P1_C1.refs.DIV_2, isUp: false, arg: ARG2},
140 + ];
141 + ReactDOMTreeTraversal.traverseEnterLeave(
142 + leave, enter, argAggregator, ARG, ARG2
143 + );
144 + expect(aggregatedArgs).toEqual(expectedAggregation);
145 + });
146 +
147 + it('should traverse enter/leave to parent - avoids parent', function() {
148 + var parent = renderParentIntoDocument();
149 + var leave = getInst(parent.refs.P_P1_C1.refs.DIV_1);
150 + var enter = getInst(parent.refs.P_P1_C1.refs.DIV);
151 + var expectedAggregation = [
152 + {node: parent.refs.P_P1_C1.refs.DIV_1, isUp: true, arg: ARG},
153 + ];
154 + ReactDOMTreeTraversal.traverseEnterLeave(
155 + leave, enter, argAggregator, ARG, ARG2
156 + );
157 + expect(aggregatedArgs).toEqual(expectedAggregation);
158 + });
159 +
160 + it('should enter from the window', function() {
161 + var parent = renderParentIntoDocument();
162 + var leave = null; // From the window or outside of the React sandbox.
163 + var enter = getInst(parent.refs.P_P1_C1.refs.DIV);
164 + var expectedAggregation = [
165 + {node: parent.refs.P, isUp: false, arg: ARG2},
166 + {node: parent.refs.P_P1, isUp: false, arg: ARG2},
167 + {node: parent.refs.P_P1_C1.refs.DIV, isUp: false, arg: ARG2},
168 + ];
169 + ReactDOMTreeTraversal.traverseEnterLeave(
170 + leave, enter, argAggregator, ARG, ARG2
171 + );
172 + expect(aggregatedArgs).toEqual(expectedAggregation);
173 + });
174 +
175 + it('should enter from the window to the shallowest', function() {
176 + var parent = renderParentIntoDocument();
177 + var leave = null; // From the window or outside of the React sandbox.
178 + var enter = getInst(parent.refs.P);
179 + var expectedAggregation = [
180 + {node: parent.refs.P, isUp: false, arg: ARG2},
181 + ];
182 + ReactDOMTreeTraversal.traverseEnterLeave(
183 + leave, enter, argAggregator, ARG, ARG2
184 + );
185 + expect(aggregatedArgs).toEqual(expectedAggregation);
186 + });
187 +
188 + it('should leave to the window', function() {
189 + var parent = renderParentIntoDocument();
190 + var enter = null; // From the window or outside of the React sandbox.
191 + var leave = getInst(parent.refs.P_P1_C1.refs.DIV);
192 + var expectedAggregation = [
193 + {node: parent.refs.P_P1_C1.refs.DIV, isUp: true, arg: ARG},
194 + {node: parent.refs.P_P1, isUp: true, arg: ARG},
195 + {node: parent.refs.P, isUp: true, arg: ARG},
196 + ];
197 + ReactDOMTreeTraversal.traverseEnterLeave(
198 + leave, enter, argAggregator, ARG, ARG2
199 + );
200 + expect(aggregatedArgs).toEqual(expectedAggregation);
201 + });
202 +
203 + it('should leave to the window from the shallowest', function() {
204 + var parent = renderParentIntoDocument();
205 + var enter = null; // From the window or outside of the React sandbox.
206 + var leave = getInst(parent.refs.P_P1_C1.refs.DIV);
207 + var expectedAggregation = [
208 + {node: parent.refs.P_P1_C1.refs.DIV, isUp: true, arg: ARG},
209 + {node: parent.refs.P_P1, isUp: true, arg: ARG},
210 + {node: parent.refs.P, isUp: true, arg: ARG},
211 + ];
212 + ReactDOMTreeTraversal.traverseEnterLeave(
213 + leave, enter, argAggregator, ARG, ARG2
214 + );
215 + expect(aggregatedArgs).toEqual(expectedAggregation);
216 + });
217 + });
218 +
219 + describe('getFirstCommonAncestor', function() {
220 + it('should determine the first common ancestor correctly', function() {
221 + var parent = renderParentIntoDocument();
222 + var ancestors = [
223 + // Common ancestor with self is self.
224 + {one: parent.refs.P_P1_C1.refs.DIV_1,
225 + two: parent.refs.P_P1_C1.refs.DIV_1,
226 + com: parent.refs.P_P1_C1.refs.DIV_1,
227 + },
228 + // Common ancestor with self is self - even if topmost DOM.
229 + {one: parent.refs.P, two: parent.refs.P, com: parent.refs.P},
230 + // Siblings
231 + {
232 + one: parent.refs.P_P1_C1.refs.DIV_1,
233 + two: parent.refs.P_P1_C1.refs.DIV_2,
234 + com: parent.refs.P_P1_C1.refs.DIV,
235 + },
236 + // Common ancestor with parent is the parent.
237 + {
238 + one: parent.refs.P_P1_C1.refs.DIV_1,
239 + two: parent.refs.P_P1_C1.refs.DIV,
240 + com: parent.refs.P_P1_C1.refs.DIV,
241 + },
242 + // Common ancestor with grandparent is the grandparent.
243 + {
244 + one: parent.refs.P_P1_C1.refs.DIV_1,
245 + two: parent.refs.P_P1,
246 + com: parent.refs.P_P1,
247 + },
248 + // Grantparent across subcomponent boundaries.
249 + {
250 + one: parent.refs.P_P1_C1.refs.DIV_1,
251 + two: parent.refs.P_P1_C2.refs.DIV_1,
252 + com: parent.refs.P_P1,
253 + },
254 + // Something deep with something one-off.
255 + {
256 + one: parent.refs.P_P1_C1.refs.DIV_1,
257 + two: parent.refs.P_OneOff,
258 + com: parent.refs.P,
259 + },
260 + ];
261 + var i;
262 + for (i = 0; i < ancestors.length; i++) {
263 + var plan = ancestors[i];
264 + var firstCommon = ReactDOMTreeTraversal.getLowestCommonAncestor(
265 + getInst(plan.one),
266 + getInst(plan.two)
267 + );
268 + expect(firstCommon).toBe(getInst(plan.com));
269 + }
270 + });
271 + });
272 +
273 +});
src/renderers/shared/reconciler/__tests__/ReactInstanceHandles-test.js deleted
-383
@@ -1,383 +0,0 @@
1 -/**
2 - * Copyright 2013-2015, Facebook, Inc.
3 - * All rights reserved.
4 - *
5 - * This source code is licensed under the BSD-style license found in the
6 - * LICENSE file in the root directory of this source tree. An additional grant
7 - * of patent rights can be found in the PATENTS file in the same directory.
8 - *
9 - * @emails react-core
10 - */
11 -
12 -'use strict';
13 -
14 -var React = require('React');
15 -var ReactTestUtils = require('ReactTestUtils');
16 -
17 -/**
18 - * Ensure that all callbacks are invoked, passing this unique argument.
19 - */
20 -var ARG = {arg: true};
21 -var ARG2 = {arg2: true};
22 -
23 -var ChildComponent = React.createClass({
24 - render: function() {
25 - return (
26 - <div ref="DIV">
27 - <div ref="DIV_1" />
28 - <div ref="DIV_2" />
29 - </div>
30 - );
31 - },
32 -});
33 -
34 -var ParentComponent = React.createClass({
35 - render: function() {
36 - return (
37 - <div ref="P">
38 - <div ref="P_P1">
39 - <ChildComponent ref="P_P1_C1" />
40 - <ChildComponent ref="P_P1_C2" />
41 - </div>
42 - <div ref="P_OneOff" />
43 - </div>
44 - );
45 - },
46 -});
47 -
48 -function renderParentIntoDocument() {
49 - return ReactTestUtils.renderIntoDocument(<ParentComponent />);
50 -}
51 -
52 -describe('ReactInstanceHandles', function() {
53 - var ReactInstanceHandles;
54 -
55 - var aggregatedArgs;
56 - function argAggregator(id, isUp, arg) {
57 - aggregatedArgs.push({
58 - id: id,
59 - isUp: isUp,
60 - arg: arg,
61 - });
62 - }
63 -
64 - function getNodeID(el) {
65 - if (el === null) {
66 - return '';
67 - }
68 - return el.getAttribute('data-reactid');
69 - }
70 -
71 - beforeEach(function() {
72 - ReactInstanceHandles = require('ReactInstanceHandles');
73 - aggregatedArgs = [];
74 - });
75 -
76 - describe('getReactRootIDFromNodeID', function() {
77 - it('should support strings', function() {
78 - var test = '.s_0_1.0..1';
79 - var expected = '.s_0_1';
80 - var actual = ReactInstanceHandles.getReactRootIDFromNodeID(test);
81 - expect(actual).toEqual(expected);
82 - });
83 - });
84 -
85 - describe('getReactRootIDFromNodeID', function() {
86 - it('should return null for invalid IDs', function() {
87 - var getReactRootIDFromNodeID = (
88 - ReactInstanceHandles.getReactRootIDFromNodeID
89 - );
90 -
91 - expect(getReactRootIDFromNodeID(null)).toEqual(null);
92 - expect(getReactRootIDFromNodeID('.')).toEqual(null);
93 - expect(getReactRootIDFromNodeID('#')).toEqual(null);
94 - });
95 - });
96 -
97 - describe('traverseTwoPhase', function() {
98 - it('should not traverse when traversing outside DOM', function() {
99 - var targetID = '';
100 - var expectedAggregation = [];
101 - ReactInstanceHandles.traverseTwoPhase(targetID, argAggregator, ARG);
102 - expect(aggregatedArgs).toEqual(expectedAggregation);
103 - });
104 -
105 - it('should traverse two phase across component boundary', function() {
106 - var parent = renderParentIntoDocument();
107 - var targetID = getNodeID(parent.refs.P_P1_C1.refs.DIV_1);
108 - var expectedAggregation = [
109 - {id: getNodeID(parent.refs.P), isUp: false, arg: ARG},
110 - {id: getNodeID(parent.refs.P_P1), isUp: false, arg: ARG},
111 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV), isUp: false, arg: ARG},
112 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV_1), isUp: false, arg: ARG},
113 -
114 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV_1), isUp: true, arg: ARG},
115 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV), isUp: true, arg: ARG},
116 - {id: getNodeID(parent.refs.P_P1), isUp: true, arg: ARG},
117 - {id: getNodeID(parent.refs.P), isUp: true, arg: ARG},
118 - ];
119 - ReactInstanceHandles.traverseTwoPhase(targetID, argAggregator, ARG);
120 - expect(aggregatedArgs).toEqual(expectedAggregation);
121 - });
122 -
123 - it('should traverse two phase at shallowest node', function() {
124 - var parent = renderParentIntoDocument();
125 - var targetID = getNodeID(parent.refs.P);
126 - var expectedAggregation = [
127 - {id: getNodeID(parent.refs.P), isUp: false, arg: ARG},
128 - {id: getNodeID(parent.refs.P), isUp: true, arg: ARG},
129 - ];
130 - ReactInstanceHandles.traverseTwoPhase(targetID, argAggregator, ARG);
131 - expect(aggregatedArgs).toEqual(expectedAggregation);
132 - });
133 - });
134 -
135 - describe('traverseTwoPhaseSkipTarget', function() {
136 - it('should not traverse when traversing outside DOM', function() {
137 - var targetID = '';
138 - var expectedAggregation = [];
139 - ReactInstanceHandles.traverseTwoPhaseSkipTarget(
140 - targetID,
141 - argAggregator,
142 - ARG
143 - );
144 - expect(aggregatedArgs).toEqual(expectedAggregation);
145 - });
146 -
147 - it('should traverse two phase across component boundary', function() {
148 - var parent = renderParentIntoDocument();
149 - var targetID = getNodeID(parent.refs.P_P1_C1.refs.DIV_1);
150 - var expectedAggregation = [
151 - {id: getNodeID(parent.refs.P), isUp: false, arg: ARG},
152 - {id: getNodeID(parent.refs.P_P1), isUp: false, arg: ARG},
153 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV), isUp: false, arg: ARG},
154 -
155 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV), isUp: true, arg: ARG},
156 - {id: getNodeID(parent.refs.P_P1), isUp: true, arg: ARG},
157 - {id: getNodeID(parent.refs.P), isUp: true, arg: ARG},
158 - ];
159 - ReactInstanceHandles.traverseTwoPhaseSkipTarget(
160 - targetID,
161 - argAggregator,
162 - ARG
163 - );
164 - expect(aggregatedArgs).toEqual(expectedAggregation);
165 - });
166 -
167 - it('should traverse two phase at shallowest node', function() {
168 - var parent = renderParentIntoDocument();
169 - var targetID = getNodeID(parent.refs.P);
170 - var expectedAggregation = [];
171 - ReactInstanceHandles.traverseTwoPhaseSkipTarget(
172 - targetID,
173 - argAggregator,
174 - ARG
175 - );
176 - expect(aggregatedArgs).toEqual(expectedAggregation);
177 - });
178 - });
179 -
180 - describe('traverseEnterLeave', function() {
181 - it('should not traverse when enter/leaving outside DOM', function() {
182 - var targetID = '';
183 - var expectedAggregation = [];
184 - ReactInstanceHandles.traverseEnterLeave(
185 - targetID, targetID, argAggregator, ARG, ARG2
186 - );
187 - expect(aggregatedArgs).toEqual(expectedAggregation);
188 - });
189 -
190 - it('should not traverse if enter/leave the same node', function() {
191 - var parent = renderParentIntoDocument();
192 - var leaveID = getNodeID(parent.refs.P_P1_C1.refs.DIV_1);
193 - var enterID = getNodeID(parent.refs.P_P1_C1.refs.DIV_1);
194 - var expectedAggregation = [];
195 - ReactInstanceHandles.traverseEnterLeave(
196 - leaveID, enterID, argAggregator, ARG, ARG2
197 - );
198 - expect(aggregatedArgs).toEqual(expectedAggregation);
199 - });
200 -
201 - it('should traverse enter/leave to sibling - avoids parent', function() {
202 - var parent = renderParentIntoDocument();
203 - var leaveID = getNodeID(parent.refs.P_P1_C1.refs.DIV_1);
204 - var enterID = getNodeID(parent.refs.P_P1_C1.refs.DIV_2);
205 - var expectedAggregation = [
206 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV_1), isUp: true, arg: ARG},
207 - // enter/leave shouldn't fire antyhing on the parent
208 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV_2), isUp: false, arg: ARG2},
209 - ];
210 - ReactInstanceHandles.traverseEnterLeave(
211 - leaveID, enterID, argAggregator, ARG, ARG2
212 - );
213 - expect(aggregatedArgs).toEqual(expectedAggregation);
214 - });
215 -
216 - it('should traverse enter/leave to parent - avoids parent', function() {
217 - var parent = renderParentIntoDocument();
218 - var leaveID = getNodeID(parent.refs.P_P1_C1.refs.DIV_1);
219 - var enterID = getNodeID(parent.refs.P_P1_C1.refs.DIV);
220 - var expectedAggregation = [
221 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV_1), isUp: true, arg: ARG},
222 - ];
223 - ReactInstanceHandles.traverseEnterLeave(
224 - leaveID, enterID, argAggregator, ARG, ARG2
225 - );
226 - expect(aggregatedArgs).toEqual(expectedAggregation);
227 - });
228 -
229 - it('should enter from the window', function() {
230 - var parent = renderParentIntoDocument();
231 - var leaveID = ''; // From the window or outside of the React sandbox.
232 - var enterID = getNodeID(parent.refs.P_P1_C1.refs.DIV);
233 - var expectedAggregation = [
234 - {id: getNodeID(parent.refs.P), isUp: false, arg: ARG2},
235 - {id: getNodeID(parent.refs.P_P1), isUp: false, arg: ARG2},
236 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV), isUp: false, arg: ARG2},
237 - ];
238 - ReactInstanceHandles.traverseEnterLeave(
239 - leaveID, enterID, argAggregator, ARG, ARG2
240 - );
241 - expect(aggregatedArgs).toEqual(expectedAggregation);
242 - });
243 -
244 - it('should enter from the window to the shallowest', function() {
245 - var parent = renderParentIntoDocument();
246 - var leaveID = ''; // From the window or outside of the React sandbox.
247 - var enterID = getNodeID(parent.refs.P);
248 - var expectedAggregation = [
249 - {id: getNodeID(parent.refs.P), isUp: false, arg: ARG2},
250 - ];
251 - ReactInstanceHandles.traverseEnterLeave(
252 - leaveID, enterID, argAggregator, ARG, ARG2
253 - );
254 - expect(aggregatedArgs).toEqual(expectedAggregation);
255 - });
256 -
257 - it('should leave to the window', function() {
258 - var parent = renderParentIntoDocument();
259 - var enterID = ''; // From the window or outside of the React sandbox.
260 - var leaveID = getNodeID(parent.refs.P_P1_C1.refs.DIV);
261 - var expectedAggregation = [
262 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV), isUp: true, arg: ARG},
263 - {id: getNodeID(parent.refs.P_P1), isUp: true, arg: ARG},
264 - {id: getNodeID(parent.refs.P), isUp: true, arg: ARG},
265 - ];
266 - ReactInstanceHandles.traverseEnterLeave(
267 - leaveID, enterID, argAggregator, ARG, ARG2
268 - );
269 - expect(aggregatedArgs).toEqual(expectedAggregation);
270 - });
271 -
272 - it('should leave to the window from the shallowest', function() {
273 - var parent = renderParentIntoDocument();
274 - var enterID = ''; // From the window or outside of the React sandbox.
275 - var leaveID = getNodeID(parent.refs.P_P1_C1.refs.DIV);
276 - var expectedAggregation = [
277 - {id: getNodeID(parent.refs.P_P1_C1.refs.DIV), isUp: true, arg: ARG},
278 - {id: getNodeID(parent.refs.P_P1), isUp: true, arg: ARG},
279 - {id: getNodeID(parent.refs.P), isUp: true, arg: ARG},
280 - ];
281 - ReactInstanceHandles.traverseEnterLeave(
282 - leaveID, enterID, argAggregator, ARG, ARG2
283 - );
284 - expect(aggregatedArgs).toEqual(expectedAggregation);
285 - });
286 - });
287 -
288 - describe('getNextDescendantID', function() {
289 - it('should return next descendent from window', function() {
290 - var parent = renderParentIntoDocument();
291 - expect(
292 - ReactInstanceHandles._getNextDescendantID(
293 - '',
294 - getNodeID(parent.refs.P_P1)
295 - )
296 - ).toBe(getNodeID(parent.refs.P));
297 - });
298 -
299 - it('should return window for next descendent towards window', function() {
300 - expect(ReactInstanceHandles._getNextDescendantID('', '')).toBe('');
301 - });
302 -
303 - it('should return self for next descendent towards self', function() {
304 - var parent = renderParentIntoDocument();
305 - expect(
306 - ReactInstanceHandles._getNextDescendantID(
307 - getNodeID(parent.refs.P_P1),
308 - getNodeID(parent.refs.P_P1)
309 - )
310 - ).toBe(getNodeID(parent.refs.P_P1));
311 - });
312 - });
313 -
314 - describe('getFirstCommonAncestorID', function() {
315 - it('should determine the first common ancestor correctly', function() {
316 - var parent = renderParentIntoDocument();
317 - var ancestors = [
318 - // Common ancestor from window to deep element is ''.
319 - {one: null,
320 - two: parent.refs.P_P1_C1.refs.DIV_1,
321 - com: null,
322 - },
323 - // Same as previous - reversed direction.
324 - {one: parent.refs.P_P1_C1.refs.DIV_1,
325 - two: null,
326 - com: null,
327 - },
328 - // Common ancestor from window to shallow id is ''.
329 - {one: parent.refs.P,
330 - two: null,
331 - com: null,
332 - },
333 - // Common ancestor with self is self.
334 - {one: parent.refs.P_P1_C1.refs.DIV_1,
335 - two: parent.refs.P_P1_C1.refs.DIV_1,
336 - com: parent.refs.P_P1_C1.refs.DIV_1,
337 - },
338 - // Common ancestor with self is self - even if topmost DOM.
339 - {one: parent.refs.P, two: parent.refs.P, com: parent.refs.P},
340 - // Siblings
341 - {
342 - one: parent.refs.P_P1_C1.refs.DIV_1,
343 - two: parent.refs.P_P1_C1.refs.DIV_2,
344 - com: parent.refs.P_P1_C1.refs.DIV,
345 - },
346 - // Common ancestor with parent is the parent.
347 - {
348 - one: parent.refs.P_P1_C1.refs.DIV_1,
349 - two: parent.refs.P_P1_C1.refs.DIV,
350 - com: parent.refs.P_P1_C1.refs.DIV,
351 - },
352 - // Common ancestor with grandparent is the grandparent.
353 - {
354 - one: parent.refs.P_P1_C1.refs.DIV_1,
355 - two: parent.refs.P_P1,
356 - com: parent.refs.P_P1,
357 - },
358 - // Grantparent across subcomponent boundaries.
359 - {
360 - one: parent.refs.P_P1_C1.refs.DIV_1,
361 - two: parent.refs.P_P1_C2.refs.DIV_1,
362 - com: parent.refs.P_P1,
363 - },
364 - // Something deep with something one-off.
365 - {
366 - one: parent.refs.P_P1_C1.refs.DIV_1,
367 - two: parent.refs.P_OneOff,
368 - com: parent.refs.P,
369 - },
370 - ];
371 - var i;
372 - for (i = 0; i < ancestors.length; i++) {
373 - var plan = ancestors[i];
374 - var firstCommon = ReactInstanceHandles.getFirstCommonAncestorID(
375 - getNodeID(plan.one),
376 - getNodeID(plan.two)
377 - );
378 - expect(firstCommon).toBe(getNodeID(plan.com));
379 - }
380 - });
381 - });
382 -
383 -});