jasmine-core 2.2.0 → 2.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/lib/jasmine-core/boot.js +6 -6
- data/lib/jasmine-core/boot/boot.js +6 -6
- data/lib/jasmine-core/example/spec/SpecHelper.js +1 -1
- data/lib/jasmine-core/jasmine-html.js +43 -13
- data/lib/jasmine-core/jasmine.css +6 -3
- data/lib/jasmine-core/jasmine.js +399 -149
- data/lib/jasmine-core/spec/core/ClockSpec.js +214 -22
- data/lib/jasmine-core/spec/core/DelayedFunctionSchedulerSpec.js +0 -41
- data/lib/jasmine-core/spec/core/EnvSpec.js +20 -0
- data/lib/jasmine-core/spec/core/PrettyPrintSpec.js +57 -27
- data/lib/jasmine-core/spec/core/SpecSpec.js +140 -1
- data/lib/jasmine-core/spec/core/SuiteSpec.js +47 -244
- data/lib/jasmine-core/spec/core/TreeProcessorSpec.js +633 -0
- data/lib/jasmine-core/spec/core/asymmetric_equality/AnySpec.js +2 -3
- data/lib/jasmine-core/spec/core/asymmetric_equality/ObjectContainingSpec.js +31 -0
- data/lib/jasmine-core/spec/core/integration/EnvSpec.js +35 -6
- data/lib/jasmine-core/spec/core/integration/SpecRunningSpec.js +108 -15
- data/lib/jasmine-core/spec/core/matchers/matchersUtilSpec.js +27 -0
- data/lib/jasmine-core/spec/core/matchers/toThrowErrorSpec.js +0 -2
- data/lib/jasmine-core/spec/html/HtmlReporterSpec.js +115 -1
- data/lib/jasmine-core/spec/npmPackage/npmPackageSpec.js +2 -5
- data/lib/jasmine-core/version.rb +1 -1
- metadata +96 -95
@@ -0,0 +1,633 @@
|
|
1
|
+
describe("TreeProcessor", function() {
|
2
|
+
var nodeNumber = 0, leafNumber = 0;
|
3
|
+
|
4
|
+
function Node(attrs) {
|
5
|
+
attrs = attrs || {};
|
6
|
+
this.id = 'node' + nodeNumber++;
|
7
|
+
this.children = attrs.children || [];
|
8
|
+
this.canBeReentered = function() {
|
9
|
+
return !attrs.noReenter;
|
10
|
+
};
|
11
|
+
this.isExecutable = function() {
|
12
|
+
return attrs.executable !== false;
|
13
|
+
};
|
14
|
+
this.sharedUserContext = function() {
|
15
|
+
return attrs.userContext || {};
|
16
|
+
};
|
17
|
+
this.getResult = jasmine.createSpy(this.id + '#execute');
|
18
|
+
this.beforeAllFns = attrs.beforeAllFns || [];
|
19
|
+
this.afterAllFns = attrs.afterAllFns || [];
|
20
|
+
}
|
21
|
+
|
22
|
+
function Leaf(attrs) {
|
23
|
+
attrs = attrs || {};
|
24
|
+
this.id = 'leaf' + leafNumber++;
|
25
|
+
this.isExecutable = function() {
|
26
|
+
return attrs.executable !== false;
|
27
|
+
};
|
28
|
+
this.execute = jasmine.createSpy(this.id + '#execute');
|
29
|
+
}
|
30
|
+
|
31
|
+
it("processes a single executable leaf", function() {
|
32
|
+
var leaf = new Leaf(),
|
33
|
+
processor = new j$.TreeProcessor({ tree: leaf, runnableIds: [leaf.id] }),
|
34
|
+
result = processor.processTree();
|
35
|
+
|
36
|
+
expect(result.valid).toBe(true);
|
37
|
+
|
38
|
+
expect(result[leaf.id]).toEqual({
|
39
|
+
executable: true,
|
40
|
+
segments: jasmine.any(Array)
|
41
|
+
});
|
42
|
+
});
|
43
|
+
|
44
|
+
it("processes a single non-executable leaf", function() {
|
45
|
+
var leaf = new Leaf({ executable: false }),
|
46
|
+
processor = new j$.TreeProcessor({ tree: leaf, runnableIds: [leaf.id] }),
|
47
|
+
result = processor.processTree();
|
48
|
+
|
49
|
+
expect(result.valid).toBe(true);
|
50
|
+
|
51
|
+
expect(result[leaf.id]).toEqual({
|
52
|
+
executable: false,
|
53
|
+
segments: jasmine.any(Array)
|
54
|
+
});
|
55
|
+
});
|
56
|
+
|
57
|
+
it("processes a single non-specified leaf", function() {
|
58
|
+
var leaf = new Leaf(),
|
59
|
+
processor = new j$.TreeProcessor({ tree: leaf, runnableIds: [] }),
|
60
|
+
result = processor.processTree();
|
61
|
+
|
62
|
+
expect(result.valid).toBe(true);
|
63
|
+
|
64
|
+
expect(result[leaf.id]).toEqual({
|
65
|
+
executable: false,
|
66
|
+
segments: jasmine.any(Array)
|
67
|
+
});
|
68
|
+
});
|
69
|
+
|
70
|
+
it("processes a tree with a single leaf with the root specified", function() {
|
71
|
+
var leaf = new Leaf(),
|
72
|
+
parent = new Node({ children: [leaf] }),
|
73
|
+
processor = new j$.TreeProcessor({ tree: parent, runnableIds: [parent.id] }),
|
74
|
+
result = processor.processTree();
|
75
|
+
|
76
|
+
expect(result.valid).toBe(true);
|
77
|
+
|
78
|
+
expect(result[parent.id]).toEqual({
|
79
|
+
executable: true,
|
80
|
+
segments: jasmine.any(Array)
|
81
|
+
});
|
82
|
+
|
83
|
+
expect(result[leaf.id]).toEqual({
|
84
|
+
executable: true,
|
85
|
+
segments: jasmine.any(Array)
|
86
|
+
});
|
87
|
+
});
|
88
|
+
|
89
|
+
it("processes a tree with a single non-executable leaf, with the root specified", function() {
|
90
|
+
var leaf = new Leaf({ executable: false }),
|
91
|
+
parent = new Node({ children: [leaf] }),
|
92
|
+
processor = new j$.TreeProcessor({ tree: parent, runnableIds: [parent.id] }),
|
93
|
+
result = processor.processTree();
|
94
|
+
|
95
|
+
expect(result.valid).toBe(true);
|
96
|
+
|
97
|
+
expect(result[parent.id]).toEqual({
|
98
|
+
executable: false,
|
99
|
+
segments: jasmine.any(Array)
|
100
|
+
});
|
101
|
+
|
102
|
+
expect(result[leaf.id]).toEqual({
|
103
|
+
executable: false,
|
104
|
+
segments: jasmine.any(Array)
|
105
|
+
});
|
106
|
+
});
|
107
|
+
|
108
|
+
it("processes a complicated tree with the root specified", function() {
|
109
|
+
var nonExecutable = new Leaf({ executable: false }),
|
110
|
+
executable = new Leaf({ executable: true }),
|
111
|
+
parent = new Node({ children: [nonExecutable, executable] }),
|
112
|
+
childless = new Node(),
|
113
|
+
childOfDisabled = new Leaf({ executable: true }),
|
114
|
+
disabledNode = new Node({ executable: false, children: [childOfDisabled] }),
|
115
|
+
root = new Node({ children: [parent, childless, disabledNode] }),
|
116
|
+
processor = new j$.TreeProcessor({ tree: root, runnableIds: [root.id] }),
|
117
|
+
result = processor.processTree();
|
118
|
+
|
119
|
+
expect(result.valid).toBe(true);
|
120
|
+
|
121
|
+
expect(result[root.id]).toEqual({
|
122
|
+
executable: true,
|
123
|
+
segments: jasmine.any(Array)
|
124
|
+
});
|
125
|
+
|
126
|
+
expect(result[childless.id]).toEqual({
|
127
|
+
executable: false,
|
128
|
+
segments: jasmine.any(Array)
|
129
|
+
});
|
130
|
+
|
131
|
+
expect(result[nonExecutable.id]).toEqual({
|
132
|
+
executable: false,
|
133
|
+
segments: jasmine.any(Array)
|
134
|
+
});
|
135
|
+
|
136
|
+
expect(result[executable.id]).toEqual({
|
137
|
+
executable: true,
|
138
|
+
segments: jasmine.any(Array)
|
139
|
+
});
|
140
|
+
|
141
|
+
expect(result[parent.id]).toEqual({
|
142
|
+
executable: true,
|
143
|
+
segments: jasmine.any(Array)
|
144
|
+
});
|
145
|
+
|
146
|
+
expect(result[disabledNode.id]).toEqual({
|
147
|
+
executable: false,
|
148
|
+
segments: jasmine.any(Array)
|
149
|
+
});
|
150
|
+
|
151
|
+
expect(result[childOfDisabled.id]).toEqual({
|
152
|
+
executable: false,
|
153
|
+
segments: jasmine.any(Array)
|
154
|
+
});
|
155
|
+
});
|
156
|
+
|
157
|
+
it("marks the run order invalid if it would re-enter a node that does not allow re-entry", function() {
|
158
|
+
var leaf1 = new Leaf(),
|
159
|
+
leaf2 = new Leaf(),
|
160
|
+
leaf3 = new Leaf(),
|
161
|
+
reentered = new Node({ noReenter: true, children: [leaf1, leaf2] }),
|
162
|
+
root = new Node({ children: [reentered, leaf3] }),
|
163
|
+
processor = new j$.TreeProcessor({ tree: root, runnableIds: [leaf1.id, leaf3.id, leaf2.id] }),
|
164
|
+
result = processor.processTree();
|
165
|
+
|
166
|
+
expect(result).toEqual({ valid: false });
|
167
|
+
});
|
168
|
+
|
169
|
+
it("marks the run order valid if a node being re-entered allows re-entry", function() {
|
170
|
+
var leaf1 = new Leaf(),
|
171
|
+
leaf2 = new Leaf(),
|
172
|
+
leaf3 = new Leaf(),
|
173
|
+
reentered = new Node({ children: [leaf1, leaf2] }),
|
174
|
+
root = new Node({ children: [reentered, leaf3] }),
|
175
|
+
processor = new j$.TreeProcessor({ tree: root, runnableIds: [leaf1.id, leaf3.id, leaf2.id] }),
|
176
|
+
result = processor.processTree();
|
177
|
+
|
178
|
+
expect(result.valid).toBe(true);
|
179
|
+
});
|
180
|
+
|
181
|
+
it("marks the run order valid if a node which can't be re-entered is only entered once", function() {
|
182
|
+
var leaf1 = new Leaf(),
|
183
|
+
leaf2 = new Leaf(),
|
184
|
+
leaf3 = new Leaf(),
|
185
|
+
noReentry = new Node({ noReenter: true }),
|
186
|
+
root = new Node({ children: [noReentry] }),
|
187
|
+
processor = new j$.TreeProcessor({ tree: root, runnableIds: [leaf2.id, leaf1.id, leaf3.id] }),
|
188
|
+
result = processor.processTree();
|
189
|
+
|
190
|
+
expect(result.valid).toBe(true);
|
191
|
+
});
|
192
|
+
|
193
|
+
it("marks the run order valid if a node which can't be re-entered is run directly", function() {
|
194
|
+
var leaf1 = new Leaf(),
|
195
|
+
noReentry = new Node({ noReenter: true }),
|
196
|
+
root = new Node({ children: [noReentry] }),
|
197
|
+
processor = new j$.TreeProcessor({ tree: root, runnableIds: [root.id] }),
|
198
|
+
result = processor.processTree();
|
199
|
+
|
200
|
+
expect(result.valid).toBe(true);
|
201
|
+
});
|
202
|
+
|
203
|
+
it("runs a single leaf", function() {
|
204
|
+
var leaf = new Leaf(),
|
205
|
+
node = new Node({ children: [leaf] }),
|
206
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
207
|
+
processor = new j$.TreeProcessor({ tree: node, runnableIds: [leaf.id], queueRunnerFactory: queueRunner }),
|
208
|
+
treeComplete = jasmine.createSpy('treeComplete');
|
209
|
+
|
210
|
+
processor.execute(treeComplete);
|
211
|
+
|
212
|
+
expect(queueRunner).toHaveBeenCalledWith({
|
213
|
+
onComplete: treeComplete,
|
214
|
+
onException: jasmine.any(Function),
|
215
|
+
queueableFns: [{ fn: jasmine.any(Function) }]
|
216
|
+
});
|
217
|
+
|
218
|
+
queueRunner.calls.mostRecent().args[0].queueableFns[0].fn('foo');
|
219
|
+
|
220
|
+
expect(leaf.execute).toHaveBeenCalledWith('foo', true);
|
221
|
+
});
|
222
|
+
|
223
|
+
it("runs a node with no children", function() {
|
224
|
+
var node = new Node({ userContext: { node: 'context' } }),
|
225
|
+
root = new Node({ children: [node] }),
|
226
|
+
nodeStart = jasmine.createSpy('nodeStart'),
|
227
|
+
nodeComplete = jasmine.createSpy('nodeComplete'),
|
228
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
229
|
+
processor = new j$.TreeProcessor({
|
230
|
+
tree: root,
|
231
|
+
runnableIds: [node.id],
|
232
|
+
nodeStart: nodeStart,
|
233
|
+
nodeComplete: nodeComplete,
|
234
|
+
queueRunnerFactory: queueRunner
|
235
|
+
}),
|
236
|
+
treeComplete = jasmine.createSpy('treeComplete'),
|
237
|
+
nodeDone = jasmine.createSpy('nodeDone');
|
238
|
+
|
239
|
+
processor.execute(treeComplete);
|
240
|
+
|
241
|
+
expect(queueRunner).toHaveBeenCalledWith({
|
242
|
+
onComplete: treeComplete,
|
243
|
+
onException: jasmine.any(Function),
|
244
|
+
queueableFns: [{ fn: jasmine.any(Function) }]
|
245
|
+
});
|
246
|
+
|
247
|
+
queueRunner.calls.mostRecent().args[0].queueableFns[0].fn(nodeDone);
|
248
|
+
|
249
|
+
expect(nodeStart).toHaveBeenCalledWith(node);
|
250
|
+
expect(queueRunner).toHaveBeenCalledWith({
|
251
|
+
onComplete: jasmine.any(Function),
|
252
|
+
queueableFns: [],
|
253
|
+
userContext: { node: 'context' },
|
254
|
+
onException: jasmine.any(Function)
|
255
|
+
});
|
256
|
+
|
257
|
+
node.getResult.and.returnValue({ my: 'result' });
|
258
|
+
|
259
|
+
queueRunner.calls.mostRecent().args[0].onComplete();
|
260
|
+
expect(nodeComplete).toHaveBeenCalledWith(node, { my: 'result' });
|
261
|
+
expect(nodeDone).toHaveBeenCalled();
|
262
|
+
});
|
263
|
+
|
264
|
+
it("runs a node with children", function() {
|
265
|
+
var leaf1 = new Leaf(),
|
266
|
+
leaf2 = new Leaf(),
|
267
|
+
node = new Node({ children: [leaf1, leaf2] }),
|
268
|
+
root = new Node({ children: [node] }),
|
269
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
270
|
+
processor = new j$.TreeProcessor({
|
271
|
+
tree: root,
|
272
|
+
runnableIds: [node.id],
|
273
|
+
queueRunnerFactory: queueRunner
|
274
|
+
}),
|
275
|
+
treeComplete = jasmine.createSpy('treeComplete'),
|
276
|
+
nodeDone = jasmine.createSpy('nodeDone');
|
277
|
+
|
278
|
+
processor.execute(treeComplete);
|
279
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
280
|
+
queueableFns[0].fn(nodeDone);
|
281
|
+
|
282
|
+
queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
283
|
+
expect(queueableFns.length).toBe(2);
|
284
|
+
|
285
|
+
queueableFns[0].fn('foo');
|
286
|
+
expect(leaf1.execute).toHaveBeenCalledWith('foo', true);
|
287
|
+
|
288
|
+
queueableFns[1].fn('bar');
|
289
|
+
expect(leaf2.execute).toHaveBeenCalledWith('bar', true);
|
290
|
+
});
|
291
|
+
|
292
|
+
it("runs a disabled node", function() {
|
293
|
+
var leaf1 = new Leaf(),
|
294
|
+
node = new Node({ children: [leaf1], executable: false }),
|
295
|
+
root = new Node({ children: [node] }),
|
296
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
297
|
+
nodeStart = jasmine.createSpy('nodeStart'),
|
298
|
+
nodeComplete = jasmine.createSpy('nodeComplete'),
|
299
|
+
processor = new j$.TreeProcessor({
|
300
|
+
tree: root,
|
301
|
+
runnableIds: [node.id],
|
302
|
+
queueRunnerFactory: queueRunner,
|
303
|
+
nodeStart: nodeStart,
|
304
|
+
nodeComplete: nodeComplete
|
305
|
+
}),
|
306
|
+
treeComplete = jasmine.createSpy('treeComplete'),
|
307
|
+
nodeDone = jasmine.createSpy('nodeDone');
|
308
|
+
|
309
|
+
processor.execute(treeComplete);
|
310
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
311
|
+
queueableFns[0].fn(nodeDone);
|
312
|
+
|
313
|
+
expect(nodeStart).toHaveBeenCalledWith(node);
|
314
|
+
|
315
|
+
queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
316
|
+
expect(queueableFns.length).toBe(1);
|
317
|
+
|
318
|
+
queueableFns[0].fn('foo');
|
319
|
+
expect(leaf1.execute).toHaveBeenCalledWith('foo', false);
|
320
|
+
|
321
|
+
node.getResult.and.returnValue({ im: 'disabled' });
|
322
|
+
|
323
|
+
queueRunner.calls.mostRecent().args[0].onComplete();
|
324
|
+
expect(nodeComplete).toHaveBeenCalledWith(node, { im: 'disabled' });
|
325
|
+
});
|
326
|
+
|
327
|
+
it("runs beforeAlls for a node with children", function() {
|
328
|
+
var leaf = new Leaf(),
|
329
|
+
node = new Node({
|
330
|
+
children: [leaf],
|
331
|
+
beforeAllFns: ['beforeAll1', 'beforeAll2']
|
332
|
+
}),
|
333
|
+
root = new Node({ children: [node] }),
|
334
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
335
|
+
processor = new j$.TreeProcessor({
|
336
|
+
tree: root,
|
337
|
+
runnableIds: [node.id],
|
338
|
+
queueRunnerFactory: queueRunner
|
339
|
+
}),
|
340
|
+
treeComplete = jasmine.createSpy('treeComplete'),
|
341
|
+
nodeDone = jasmine.createSpy('nodeDone');
|
342
|
+
|
343
|
+
processor.execute(treeComplete);
|
344
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
345
|
+
queueableFns[0].fn(nodeDone);
|
346
|
+
|
347
|
+
queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
348
|
+
|
349
|
+
expect(queueableFns).toEqual(['beforeAll1', 'beforeAll2', { fn: jasmine.any(Function) }]);
|
350
|
+
});
|
351
|
+
|
352
|
+
it("runs afterAlls for a node with children", function() {
|
353
|
+
var leaf = new Leaf(),
|
354
|
+
node = new Node({
|
355
|
+
children: [leaf],
|
356
|
+
afterAllFns: ['afterAll1', 'afterAll2']
|
357
|
+
}),
|
358
|
+
root = new Node({ children: [node] }),
|
359
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
360
|
+
processor = new j$.TreeProcessor({
|
361
|
+
tree: root,
|
362
|
+
runnableIds: [node.id],
|
363
|
+
queueRunnerFactory: queueRunner
|
364
|
+
}),
|
365
|
+
treeComplete = jasmine.createSpy('treeComplete'),
|
366
|
+
nodeDone = jasmine.createSpy('nodeDone');
|
367
|
+
|
368
|
+
processor.execute(treeComplete);
|
369
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
370
|
+
queueableFns[0].fn(nodeDone);
|
371
|
+
|
372
|
+
queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
373
|
+
|
374
|
+
expect(queueableFns).toEqual([{ fn: jasmine.any(Function) }, 'afterAll1', 'afterAll2']);
|
375
|
+
});
|
376
|
+
|
377
|
+
it("does not run beforeAlls or afterAlls for a node with no children", function() {
|
378
|
+
var node = new Node({
|
379
|
+
beforeAllFns: ['before'],
|
380
|
+
afterAllFns: ['after']
|
381
|
+
}),
|
382
|
+
root = new Node({ children: [node] }),
|
383
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
384
|
+
processor = new j$.TreeProcessor({
|
385
|
+
tree: root,
|
386
|
+
runnableIds: [node.id],
|
387
|
+
queueRunnerFactory: queueRunner
|
388
|
+
}),
|
389
|
+
treeComplete = jasmine.createSpy('treeComplete'),
|
390
|
+
nodeDone = jasmine.createSpy('nodeDone');
|
391
|
+
|
392
|
+
processor.execute(treeComplete);
|
393
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
394
|
+
queueableFns[0].fn(nodeDone);
|
395
|
+
|
396
|
+
queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
397
|
+
|
398
|
+
expect(queueableFns).toEqual([]);
|
399
|
+
});
|
400
|
+
|
401
|
+
it("does not run beforeAlls or afterAlls for a disabled node", function() {
|
402
|
+
var leaf = new Leaf(),
|
403
|
+
node = new Node({
|
404
|
+
children: [leaf],
|
405
|
+
beforeAllFns: ['before'],
|
406
|
+
afterAllFns: ['after'],
|
407
|
+
executable: false
|
408
|
+
}),
|
409
|
+
root = new Node({ children: [node] }),
|
410
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
411
|
+
processor = new j$.TreeProcessor({
|
412
|
+
tree: root,
|
413
|
+
runnableIds: [node.id],
|
414
|
+
queueRunnerFactory: queueRunner
|
415
|
+
}),
|
416
|
+
treeComplete = jasmine.createSpy('treeComplete'),
|
417
|
+
nodeDone = jasmine.createSpy('nodeDone');
|
418
|
+
|
419
|
+
processor.execute(treeComplete);
|
420
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
421
|
+
queueableFns[0].fn(nodeDone);
|
422
|
+
|
423
|
+
queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
424
|
+
|
425
|
+
expect(queueableFns).toEqual([{ fn: jasmine.any(Function) }]);
|
426
|
+
});
|
427
|
+
|
428
|
+
it("runs leaves in the order specified", function() {
|
429
|
+
var leaf1 = new Leaf(),
|
430
|
+
leaf2 = new Leaf(),
|
431
|
+
root = new Node({ children: [leaf1, leaf2] }),
|
432
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
433
|
+
processor = new j$.TreeProcessor({
|
434
|
+
tree: root,
|
435
|
+
runnableIds: [leaf2.id, leaf1.id],
|
436
|
+
queueRunnerFactory: queueRunner
|
437
|
+
}),
|
438
|
+
treeComplete = jasmine.createSpy('treeComplete');
|
439
|
+
|
440
|
+
processor.execute(treeComplete);
|
441
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
442
|
+
queueableFns[0].fn();
|
443
|
+
|
444
|
+
expect(leaf1.execute).not.toHaveBeenCalled();
|
445
|
+
expect(leaf2.execute).toHaveBeenCalled();
|
446
|
+
|
447
|
+
queueableFns[1].fn();
|
448
|
+
|
449
|
+
expect(leaf1.execute).toHaveBeenCalled();
|
450
|
+
});
|
451
|
+
|
452
|
+
it("runs specified leaves before non-specified leaves", function() {
|
453
|
+
var specified = new Leaf(),
|
454
|
+
nonSpecified = new Leaf(),
|
455
|
+
root = new Node({ children: [nonSpecified, specified] }),
|
456
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
457
|
+
processor = new j$.TreeProcessor({
|
458
|
+
tree: root,
|
459
|
+
runnableIds: [specified.id],
|
460
|
+
queueRunnerFactory: queueRunner
|
461
|
+
}),
|
462
|
+
treeComplete = jasmine.createSpy('treeComplete');
|
463
|
+
|
464
|
+
processor.execute(treeComplete);
|
465
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
466
|
+
queueableFns[0].fn();
|
467
|
+
|
468
|
+
expect(nonSpecified.execute).not.toHaveBeenCalled();
|
469
|
+
expect(specified.execute).toHaveBeenCalledWith(undefined, true);
|
470
|
+
|
471
|
+
queueableFns[1].fn();
|
472
|
+
|
473
|
+
expect(nonSpecified.execute).toHaveBeenCalledWith(undefined, false);
|
474
|
+
});
|
475
|
+
|
476
|
+
it("runs nodes and leaves with a specified order", function() {
|
477
|
+
var specifiedLeaf = new Leaf(),
|
478
|
+
childLeaf = new Leaf(),
|
479
|
+
specifiedNode = new Node({ children: [childLeaf] }),
|
480
|
+
root = new Node({ children: [specifiedLeaf, specifiedNode] }),
|
481
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
482
|
+
processor = new j$.TreeProcessor({
|
483
|
+
tree: root,
|
484
|
+
runnableIds: [specifiedNode.id, specifiedLeaf.id],
|
485
|
+
queueRunnerFactory: queueRunner
|
486
|
+
});
|
487
|
+
|
488
|
+
processor.execute();
|
489
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
490
|
+
queueableFns[0].fn();
|
491
|
+
|
492
|
+
expect(specifiedLeaf.execute).not.toHaveBeenCalled();
|
493
|
+
var nodeQueueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
494
|
+
nodeQueueableFns[0].fn();
|
495
|
+
|
496
|
+
expect(childLeaf.execute).toHaveBeenCalled();
|
497
|
+
|
498
|
+
queueableFns[1].fn();
|
499
|
+
|
500
|
+
expect(specifiedLeaf.execute).toHaveBeenCalled();
|
501
|
+
});
|
502
|
+
|
503
|
+
it("runs a node multiple times if the order specified leaves and re-enters it", function() {
|
504
|
+
var leaf1 = new Leaf(),
|
505
|
+
leaf2 = new Leaf(),
|
506
|
+
leaf3 = new Leaf(),
|
507
|
+
leaf4 = new Leaf(),
|
508
|
+
leaf5 = new Leaf(),
|
509
|
+
reentered = new Node({ children: [leaf1, leaf2, leaf3] }),
|
510
|
+
root = new Node({ children: [reentered, leaf4, leaf5] }),
|
511
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
512
|
+
processor = new j$.TreeProcessor({
|
513
|
+
tree: root,
|
514
|
+
runnableIds: [leaf1.id, leaf4.id, leaf2.id, leaf5.id, leaf3.id],
|
515
|
+
queueRunnerFactory: queueRunner
|
516
|
+
});
|
517
|
+
|
518
|
+
processor.execute();
|
519
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
520
|
+
expect(queueableFns.length).toBe(5);
|
521
|
+
|
522
|
+
queueableFns[0].fn();
|
523
|
+
expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
|
524
|
+
queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
|
525
|
+
expect(leaf1.execute).toHaveBeenCalled();
|
526
|
+
|
527
|
+
queueableFns[1].fn();
|
528
|
+
expect(leaf4.execute).toHaveBeenCalled();
|
529
|
+
|
530
|
+
queueableFns[2].fn();
|
531
|
+
expect(queueRunner.calls.count()).toBe(3);
|
532
|
+
expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
|
533
|
+
queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
|
534
|
+
expect(leaf2.execute).toHaveBeenCalled();
|
535
|
+
|
536
|
+
queueableFns[3].fn();
|
537
|
+
expect(leaf5.execute).toHaveBeenCalled();
|
538
|
+
|
539
|
+
queueableFns[4].fn();
|
540
|
+
expect(queueRunner.calls.count()).toBe(4);
|
541
|
+
expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
|
542
|
+
queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
|
543
|
+
expect(leaf3.execute).toHaveBeenCalled();
|
544
|
+
});
|
545
|
+
|
546
|
+
it("runs a parent of a node with segments correctly", function() {
|
547
|
+
var leaf1 = new Leaf(),
|
548
|
+
leaf2 = new Leaf(),
|
549
|
+
leaf3 = new Leaf(),
|
550
|
+
leaf4 = new Leaf(),
|
551
|
+
leaf5 = new Leaf(),
|
552
|
+
parent = new Node({ children: [leaf1, leaf2, leaf3] }),
|
553
|
+
grandparent = new Node({ children: [parent] }),
|
554
|
+
root = new Node({ children: [grandparent, leaf4, leaf5] }),
|
555
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
556
|
+
processor = new j$.TreeProcessor({
|
557
|
+
tree: root,
|
558
|
+
runnableIds: [leaf1.id, leaf4.id, leaf2.id, leaf5.id, leaf3.id],
|
559
|
+
queueRunnerFactory: queueRunner
|
560
|
+
});
|
561
|
+
|
562
|
+
processor.execute();
|
563
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
564
|
+
expect(queueableFns.length).toBe(5);
|
565
|
+
|
566
|
+
queueableFns[0].fn();
|
567
|
+
expect(queueRunner.calls.count()).toBe(2);
|
568
|
+
expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
|
569
|
+
|
570
|
+
queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
|
571
|
+
expect(queueRunner.calls.count()).toBe(3);
|
572
|
+
|
573
|
+
queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
|
574
|
+
expect(leaf1.execute).toHaveBeenCalled();
|
575
|
+
|
576
|
+
queueableFns[1].fn();
|
577
|
+
expect(leaf4.execute).toHaveBeenCalled();
|
578
|
+
|
579
|
+
queueableFns[2].fn();
|
580
|
+
expect(queueRunner.calls.count()).toBe(4);
|
581
|
+
expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
|
582
|
+
|
583
|
+
queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
|
584
|
+
expect(queueRunner.calls.count()).toBe(5);
|
585
|
+
|
586
|
+
queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
|
587
|
+
expect(leaf2.execute).toHaveBeenCalled();
|
588
|
+
|
589
|
+
queueableFns[3].fn();
|
590
|
+
expect(leaf5.execute).toHaveBeenCalled();
|
591
|
+
|
592
|
+
queueableFns[4].fn();
|
593
|
+
expect(queueRunner.calls.count()).toBe(6);
|
594
|
+
expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
|
595
|
+
|
596
|
+
queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
|
597
|
+
expect(queueRunner.calls.count()).toBe(7);
|
598
|
+
|
599
|
+
queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
|
600
|
+
expect(leaf3.execute).toHaveBeenCalled();
|
601
|
+
});
|
602
|
+
|
603
|
+
it("runs nodes in the order they were declared", function() {
|
604
|
+
var leaf1 = new Leaf(),
|
605
|
+
leaf2 = new Leaf(),
|
606
|
+
leaf3 = new Leaf(),
|
607
|
+
parent = new Node({ children: [leaf2, leaf3] }),
|
608
|
+
root = new Node({ children: [leaf1, parent] }),
|
609
|
+
queueRunner = jasmine.createSpy('queueRunner'),
|
610
|
+
processor = new j$.TreeProcessor({
|
611
|
+
tree: root,
|
612
|
+
runnableIds: [root.id],
|
613
|
+
queueRunnerFactory: queueRunner
|
614
|
+
});
|
615
|
+
|
616
|
+
processor.execute();
|
617
|
+
var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
618
|
+
expect(queueableFns.length).toBe(2);
|
619
|
+
|
620
|
+
queueableFns[0].fn();
|
621
|
+
expect(leaf1.execute).toHaveBeenCalled();
|
622
|
+
|
623
|
+
queueableFns[1].fn();
|
624
|
+
|
625
|
+
var childFns = queueRunner.calls.mostRecent().args[0].queueableFns;
|
626
|
+
expect(childFns.length).toBe(2);
|
627
|
+
childFns[0].fn();
|
628
|
+
expect(leaf2.execute).toHaveBeenCalled();
|
629
|
+
|
630
|
+
childFns[1].fn();
|
631
|
+
expect(leaf3.execute).toHaveBeenCalled();
|
632
|
+
});
|
633
|
+
});
|