@samitouri / QOS-React / commits / a3ff8c3833

Improve tests (#8866)

* refactor one test suite to use jest's mock function * keep the comment

jddxf committed Jan 26, 2017 at 00:13 UTC a3ff8c3833eb1b31b9ad7822fb9f86b866d2ed0b
1 file changed +57 -65
src/renderers/shared/shared/__tests__/ReactTreeTraversal-test.js
+57 -65
@@ -52,14 +52,10 @@ function renderParentIntoDocument() {
52
53 describe('ReactTreeTraversal', () => {
54 var ReactTreeTraversal;
55 + var mockFn = jest.fn();
56
56 - var aggregatedArgs;
57 - function argAggregator(inst, phase, arg) {
58 - aggregatedArgs.push({
59 - node: ReactDOMComponentTree.getNodeFromInstance(inst).id,
60 - phase: phase,
61 - arg: arg,
62 - });
57 + function callback(inst, phase, arg) {
58 + mockFn(ReactDOMComponentTree.getNodeFromInstance(inst).id, phase, arg);
59 }
60
61 function getInst(node) {
@@ -68,151 +64,147 @@ describe('ReactTreeTraversal', () => {
64
65 beforeEach(() => {
66 ReactTreeTraversal = require('ReactTreeTraversal');
71 - aggregatedArgs = [];
67 + mockFn.mockReset();
68 });
69
70 describe('traverseTwoPhase', () => {
71 it('should not traverse when traversing outside DOM', () => {
76 - var expectedAggregation = [];
77 - ReactTreeTraversal.traverseTwoPhase(null, argAggregator, ARG);
78 - expect(aggregatedArgs).toEqual(expectedAggregation);
72 + ReactTreeTraversal.traverseTwoPhase(null, callback, ARG);
73 + expect(mockFn).not.toHaveBeenCalled();
74 });
75
76 it('should traverse two phase across component boundary', () => {
77 var parent = renderParentIntoDocument();
78 var target = getInst(parent.refs.P_P1_C1.refs.DIV_1);
84 - var expectedAggregation = [
85 - {node: 'P', phase: 'captured', arg: ARG},
86 - {node: 'P_P1', phase: 'captured', arg: ARG},
87 - {node: 'P_P1_C1__DIV', phase: 'captured', arg: ARG},
88 - {node: 'P_P1_C1__DIV_1', phase: 'captured', arg: ARG},
79 + var expectedCalls = [
80 + ['P', 'captured', ARG],
81 + ['P_P1', 'captured', ARG],
82 + ['P_P1_C1__DIV', 'captured', ARG],
83 + ['P_P1_C1__DIV_1', 'captured', ARG],
84
90 - {node: 'P_P1_C1__DIV_1', phase: 'bubbled', arg: ARG},
91 - {node: 'P_P1_C1__DIV', phase: 'bubbled', arg: ARG},
92 - {node: 'P_P1', phase: 'bubbled', arg: ARG},
93 - {node: 'P', phase: 'bubbled', arg: ARG},
85 + ['P_P1_C1__DIV_1', 'bubbled', ARG],
86 + ['P_P1_C1__DIV', 'bubbled', ARG],
87 + ['P_P1', 'bubbled', ARG],
88 + ['P', 'bubbled', ARG],
89 ];
95 - ReactTreeTraversal.traverseTwoPhase(target, argAggregator, ARG);
96 - expect(aggregatedArgs).toEqual(expectedAggregation);
90 + ReactTreeTraversal.traverseTwoPhase(target, callback, ARG);
91 + expect(mockFn.mock.calls).toEqual(expectedCalls);
92 });
93
94 it('should traverse two phase at shallowest node', () => {
95 var parent = renderParentIntoDocument();
96 var target = getInst(parent.refs.P);
102 - var expectedAggregation = [
103 - {node: 'P', phase: 'captured', arg: ARG},
104 - {node: 'P', phase: 'bubbled', arg: ARG},
97 + var expectedCalls = [
98 + ['P', 'captured', ARG],
99 + ['P', 'bubbled', ARG],
100 ];
106 - ReactTreeTraversal.traverseTwoPhase(target, argAggregator, ARG);
107 - expect(aggregatedArgs).toEqual(expectedAggregation);
101 + ReactTreeTraversal.traverseTwoPhase(target, callback, ARG);
102 + expect(mockFn.mock.calls).toEqual(expectedCalls);
103 });
104 });
105
106 describe('traverseEnterLeave', () => {
107 it('should not traverse when enter/leaving outside DOM', () => {
113 - var target = null;
114 - var expectedAggregation = [];
108 ReactTreeTraversal.traverseEnterLeave(
116 - target, target, argAggregator, ARG, ARG2
109 + null, null, callback, ARG, ARG2
110 );
118 - expect(aggregatedArgs).toEqual(expectedAggregation);
111 + expect(mockFn).not.toHaveBeenCalled();
112 });
113
114 it('should not traverse if enter/leave the same node', () => {
115 var parent = renderParentIntoDocument();
116 var leave = getInst(parent.refs.P_P1_C1.refs.DIV_1);
117 var enter = getInst(parent.refs.P_P1_C1.refs.DIV_1);
125 - var expectedAggregation = [];
118 ReactTreeTraversal.traverseEnterLeave(
127 - leave, enter, argAggregator, ARG, ARG2
119 + leave, enter, callback, ARG, ARG2
120 );
129 - expect(aggregatedArgs).toEqual(expectedAggregation);
121 + expect(mockFn).not.toHaveBeenCalled();
122 });
123
124 it('should traverse enter/leave to sibling - avoids parent', () => {
125 var parent = renderParentIntoDocument();
126 var leave = getInst(parent.refs.P_P1_C1.refs.DIV_1);
127 var enter = getInst(parent.refs.P_P1_C1.refs.DIV_2);
136 - var expectedAggregation = [
137 - {node: 'P_P1_C1__DIV_1', phase: 'bubbled', arg: ARG},
128 + var expectedCalls = [
129 + ['P_P1_C1__DIV_1', 'bubbled', ARG],
130 // enter/leave shouldn't fire anything on the parent
139 - {node: 'P_P1_C1__DIV_2', phase: 'captured', arg: ARG2},
131 + ['P_P1_C1__DIV_2', 'captured', ARG2],
132 ];
133 ReactTreeTraversal.traverseEnterLeave(
142 - leave, enter, argAggregator, ARG, ARG2
134 + leave, enter, callback, ARG, ARG2
135 );
144 - expect(aggregatedArgs).toEqual(expectedAggregation);
136 + expect(mockFn.mock.calls).toEqual(expectedCalls);
137 });
138
139 it('should traverse enter/leave to parent - avoids parent', () => {
140 var parent = renderParentIntoDocument();
141 var leave = getInst(parent.refs.P_P1_C1.refs.DIV_1);
142 var enter = getInst(parent.refs.P_P1_C1.refs.DIV);
151 - var expectedAggregation = [
152 - {node: 'P_P1_C1__DIV_1', phase: 'bubbled', arg: ARG},
143 + var expectedCalls = [
144 + ['P_P1_C1__DIV_1', 'bubbled', ARG],
145 ];
146 ReactTreeTraversal.traverseEnterLeave(
155 - leave, enter, argAggregator, ARG, ARG2
147 + leave, enter, callback, ARG, ARG2
148 );
157 - expect(aggregatedArgs).toEqual(expectedAggregation);
149 + expect(mockFn.mock.calls).toEqual(expectedCalls);
150 });
151
152 it('should enter from the window', () => {
153 var parent = renderParentIntoDocument();
154 var leave = null; // From the window or outside of the React sandbox.
155 var enter = getInst(parent.refs.P_P1_C1.refs.DIV);
164 - var expectedAggregation = [
165 - {node: 'P', phase: 'captured', arg: ARG2},
166 - {node: 'P_P1', phase: 'captured', arg: ARG2},
167 - {node: 'P_P1_C1__DIV', phase: 'captured', arg: ARG2},
156 + var expectedCalls = [
157 + ['P', 'captured', ARG2],
158 + ['P_P1', 'captured', ARG2],
159 + ['P_P1_C1__DIV', 'captured', ARG2],
160 ];
161 ReactTreeTraversal.traverseEnterLeave(
170 - leave, enter, argAggregator, ARG, ARG2
162 + leave, enter, callback, ARG, ARG2
163 );
172 - expect(aggregatedArgs).toEqual(expectedAggregation);
164 + expect(mockFn.mock.calls).toEqual(expectedCalls);
165 });
166
167 it('should enter from the window to the shallowest', () => {
168 var parent = renderParentIntoDocument();
169 var leave = null; // From the window or outside of the React sandbox.
170 var enter = getInst(parent.refs.P);
179 - var expectedAggregation = [
180 - {node: 'P', phase: 'captured', arg: ARG2},
171 + var expectedCalls = [
172 + ['P', 'captured', ARG2],
173 ];
174 ReactTreeTraversal.traverseEnterLeave(
183 - leave, enter, argAggregator, ARG, ARG2
175 + leave, enter, callback, ARG, ARG2
176 );
185 - expect(aggregatedArgs).toEqual(expectedAggregation);
177 + expect(mockFn.mock.calls).toEqual(expectedCalls);
178 });
179
180 it('should leave to the window', () => {
181 var parent = renderParentIntoDocument();
182 var enter = null; // From the window or outside of the React sandbox.
183 var leave = getInst(parent.refs.P_P1_C1.refs.DIV);
192 - var expectedAggregation = [
193 - {node: 'P_P1_C1__DIV', phase: 'bubbled', arg: ARG},
194 - {node: 'P_P1', phase: 'bubbled', arg: ARG},
195 - {node: 'P', phase: 'bubbled', arg: ARG},
184 + var expectedCalls = [
185 + ['P_P1_C1__DIV', 'bubbled', ARG],
186 + ['P_P1', 'bubbled', ARG],
187 + ['P', 'bubbled', ARG],
188 ];
189 ReactTreeTraversal.traverseEnterLeave(
198 - leave, enter, argAggregator, ARG, ARG2
190 + leave, enter, callback, ARG, ARG2
191 );
200 - expect(aggregatedArgs).toEqual(expectedAggregation);
192 + expect(mockFn.mock.calls).toEqual(expectedCalls);
193 });
194
195 it('should leave to the window from the shallowest', () => {
196 var parent = renderParentIntoDocument();
197 var enter = null; // From the window or outside of the React sandbox.
198 var leave = getInst(parent.refs.P_P1_C1.refs.DIV);
207 - var expectedAggregation = [
208 - {node: 'P_P1_C1__DIV', phase: 'bubbled', arg: ARG},
209 - {node: 'P_P1', phase: 'bubbled', arg: ARG},
210 - {node: 'P', phase: 'bubbled', arg: ARG},
199 + var expectedCalls = [
200 + ['P_P1_C1__DIV', 'bubbled', ARG],
201 + ['P_P1', 'bubbled', ARG],
202 + ['P', 'bubbled', ARG],
203 ];
204 ReactTreeTraversal.traverseEnterLeave(
213 - leave, enter, argAggregator, ARG, ARG2
205 + leave, enter, callback, ARG, ARG2
206 );
215 - expect(aggregatedArgs).toEqual(expectedAggregation);
207 + expect(mockFn.mock.calls).toEqual(expectedCalls);
208 });
209 });
210