OLD | NEW |
| (Empty) |
1 <!-- | |
2 Copyright 2014 The Chromium Authors. All rights reserved. | |
3 Use of this source code is governed by a BSD-style license that can be | |
4 found in the LICENSE file. | |
5 --> | |
6 | |
7 <link rel="import" href="../ct-failures.html"> | |
8 | |
9 <link rel="import" href="../../lib/network-simulator.html"> | |
10 <link rel="import" href="../ct-commit-list.html"> | |
11 <link rel="import" href="../ct-commit-log-mock.html"> | |
12 <link rel="import" href="../ct-failure-group.html"> | |
13 <link rel="import" href="../ct-step-failure.html"> | |
14 | |
15 <script> | |
16 (function () { | |
17 'use strict'; | |
18 | |
19 var assert = chai.assert; | |
20 | |
21 describe('ct-failures', function() { | |
22 describe('failureComparator', function() { | |
23 it('should sort failures', function() { | |
24 var analyzer = new CTFailures(new CTCommitList(undefined, [])); | |
25 | |
26 var resultsByBuilder = {}; | |
27 var failure1 = new CTStepFailure("step1", "reason1", resultsByBuilder, 123
, 123); | |
28 var failure2 = new CTStepFailure("step1", "reason2", resultsByBuilder, 123
, 123); | |
29 var failure3 = new CTStepFailure("step1", "reason3", resultsByBuilder, 123
, 123); | |
30 var failure4 = new CTStepFailure("step2", "reason1", resultsByBuilder, 123
, 123); | |
31 | |
32 var failures = [failure4, failure3, failure2, failure1]; | |
33 var expectedFailures = [failure1, failure2, failure3, failure4]; | |
34 assert.deepEqual(failures.sort(analyzer._failureComparator), expectedFailu
res); | |
35 }); | |
36 }); | |
37 | |
38 describe('failureByTreeListComparator', function() { | |
39 it('should compare failures correctly', function() { | |
40 var analyzer = new CTFailures(new CTCommitList(undefined, [])); | |
41 | |
42 var cl1 = new CTCommitList(undefined, ['chromium:1', 'blink:2']); | |
43 var cl2 = new CTCommitList(undefined, ['chromium:2', 'blink:1']); | |
44 var cl3 = new CTCommitList(undefined, ['chromium:2', 'blink:2']); | |
45 var cl4 = new CTCommitList(undefined, []); | |
46 var group1 = new CTFailureGroup('', new CTStepFailureGroupData([], cl1)); | |
47 var group2 = new CTFailureGroup('', new CTStepFailureGroupData([], cl2)); | |
48 var group3 = new CTFailureGroup('', new CTStepFailureGroupData([], cl3)); | |
49 var group4 = new CTFailureGroup('', new CTStepFailureGroupData([], cl4)); | |
50 | |
51 // Sort by last revision first. | |
52 assert(analyzer._failureByTreeListComparator('chromium', group1, group2) >
0); | |
53 assert(analyzer._failureByTreeListComparator('chromium', group2, group1) <
0); | |
54 assert(analyzer._failureByTreeListComparator('chromium', group1, group1) =
= 0); | |
55 | |
56 // If the tree revisions are equal, take others. | |
57 assert(analyzer._failureByTreeListComparator('chromium', group2, group3) >
0); | |
58 | |
59 // Prioritize the given tree. | |
60 assert(analyzer._failureByTreeListComparator('chromium', group1, group2) >
0); | |
61 assert(analyzer._failureByTreeListComparator('blink', group1, group2) < 0)
; | |
62 | |
63 // Default to 'chromium'. | |
64 assert(analyzer._failureByTreeListComparator(undefined, group1, group2) >
0); | |
65 | |
66 // Failures without a revision go to the end. | |
67 assert(analyzer._failureByTreeListComparator('chromium', group4, group1) >
0); | |
68 }); | |
69 }); | |
70 | |
71 describe('._mungeAlerts', function() { | |
72 it('puts alerts into a standard format', function() { | |
73 var analyzer = new CTFailures(new CTCommitList(undefined, [])); | |
74 var alerts = [ | |
75 { | |
76 reason: 'reason', | |
77 master_url: 'https://build.chromium.org/p/chromium.webkit', | |
78 tree: 'blink', | |
79 }, | |
80 { | |
81 reason: 'reason:type', | |
82 master_url: 'https://build.chromium.org/p/chromium.chrome', | |
83 tree: 'chromium', | |
84 }, | |
85 { | |
86 master_url: 'https://build.chromium.org/p/chromium.gpu', | |
87 tree: 'chromium', | |
88 }, | |
89 { | |
90 reason: 'reason:type', | |
91 failureType: 'actual_type', | |
92 tree: undefined, | |
93 }, | |
94 ]; | |
95 analyzer._mungeAlerts(alerts); | |
96 assert.lengthOf(alerts, 4); | |
97 assert.deepEqual(alerts[0], { | |
98 reason: 'reason', | |
99 failureType: 'FAIL', | |
100 master_url: 'https://build.chromium.org/p/chromium.webkit', | |
101 tree: 'blink', | |
102 }); | |
103 assert.deepEqual(alerts[1], { | |
104 reason: 'reason', | |
105 failureType: 'type', | |
106 master_url: 'https://build.chromium.org/p/chromium.chrome', | |
107 tree: 'chromium', | |
108 }); | |
109 assert.deepEqual(alerts[2], { | |
110 failureType: 'UNKNOWN', | |
111 master_url: 'https://build.chromium.org/p/chromium.gpu', | |
112 tree: 'chromium', | |
113 }); | |
114 assert.deepEqual(alerts[3], { | |
115 reason: 'reason:type', | |
116 failureType: 'actual_type', | |
117 tree: undefined, | |
118 }); | |
119 }); | |
120 }); | |
121 | |
122 describe('.groupFailuresByTreeAndReason', function() { | |
123 it('groups failures', function() { | |
124 var analyzer = new CTFailures(new CTCommitList(undefined, [])); | |
125 var linuxAnnotation = [1]; | |
126 var winAnnotation = [2]; | |
127 var blinkAnnotation = [3]; | |
128 var annotations = { | |
129 'https_//build.chromium.org/p/chromium::Linux::1::unit_tests::MyTest': l
inuxAnnotation, | |
130 'https_//build.chromium.org/p/chromium::Win::3::unit_tests::MyTest': win
Annotation, | |
131 'https_//build.chromium.org/p/chromium.webkit::Linux::1::LayoutTests::My
Test': blinkAnnotation, | |
132 }; | |
133 var failuresByTree = analyzer._groupFailuresByTreeAndReason([{ | |
134 tree: 'chromium', | |
135 step_name: 'unit_tests', | |
136 reason: 'MyTest', | |
137 builder_name: 'Linux', | |
138 failureType: 'a_type', | |
139 failing_build: 1, | |
140 last_failing_build: 2, | |
141 master_url: 'https://build.chromium.org/p/chromium', | |
142 }, { | |
143 tree: 'chromium', | |
144 step_name: 'unit_tests', | |
145 reason: 'MyTest', | |
146 builder_name: 'Win', | |
147 failureType: 'another_type', | |
148 failing_build: 3, | |
149 last_failing_build: 44, | |
150 master_url: 'https://build.chromium.org/p/chromium', | |
151 }, { | |
152 tree: 'blink', | |
153 step_name: 'LayoutTests', | |
154 reason: 'MyTest', | |
155 builder_name: 'Linux', | |
156 failureType: 'a_type', | |
157 failing_build: 1, | |
158 last_failing_build: 2, | |
159 master_url: 'https://build.chromium.org/p/chromium.webkit', | |
160 }], annotations); | |
161 assert.equal(Object.size(failuresByTree), 2); | |
162 assert.equal(Object.size(failuresByTree.chromium), 1); | |
163 assert.property(failuresByTree.chromium, '{"step":"unit_tests","reason":"M
yTest"}'); | |
164 var chromiumBuilders = failuresByTree.chromium['{"step":"unit_tests","reas
on":"MyTest"}']; | |
165 assert.equal(Object.size(chromiumBuilders), 2); | |
166 assert.equal(Object.size(chromiumBuilders.Linux), 7); | |
167 assert.propertyVal(chromiumBuilders.Linux, 'key', 'https_//build.chromium.
org/p/chromium::Linux::1::unit_tests::MyTest'); | |
168 assert.propertyVal(chromiumBuilders.Linux, 'actual', 'a_type'); | |
169 assert.propertyVal(chromiumBuilders.Linux, 'lastFailingBuild', 2); | |
170 assert.propertyVal(chromiumBuilders.Linux, 'masterUrl', 'https://build.chr
omium.org/p/chromium'); | |
171 assert.propertyVal(chromiumBuilders.Linux, 'failingBuildCount', 2); | |
172 assert.propertyVal(chromiumBuilders.Linux, 'annotation', linuxAnnotation); | |
173 | |
174 assert.equal(Object.size(chromiumBuilders.Win), 7); | |
175 assert.propertyVal(chromiumBuilders.Win, 'key', 'https_//build.chromium.or
g/p/chromium::Win::3::unit_tests::MyTest'); | |
176 assert.propertyVal(chromiumBuilders.Win, 'actual', 'another_type'); | |
177 assert.propertyVal(chromiumBuilders.Win, 'lastFailingBuild', 44); | |
178 assert.propertyVal(chromiumBuilders.Win, 'masterUrl', 'https://build.chrom
ium.org/p/chromium'); | |
179 assert.propertyVal(chromiumBuilders.Win, 'failingBuildCount', 42); | |
180 assert.propertyVal(chromiumBuilders.Win, 'annotation', winAnnotation); | |
181 | |
182 assert.equal(Object.size(failuresByTree.blink), 1); | |
183 assert.property(failuresByTree.blink, '{"step":"LayoutTests","reason":"MyT
est"}'); | |
184 var blinkBuilders = failuresByTree.blink['{"step":"LayoutTests","reason":"
MyTest"}']; | |
185 assert.equal(Object.size(blinkBuilders), 1); | |
186 assert.equal(Object.size(blinkBuilders.Linux), 7); | |
187 assert.propertyVal(blinkBuilders.Linux, 'key', 'https_//build.chromium.org
/p/chromium.webkit::Linux::1::LayoutTests::MyTest'); | |
188 assert.propertyVal(blinkBuilders.Linux, 'actual', 'a_type'); | |
189 assert.propertyVal(blinkBuilders.Linux, 'lastFailingBuild', 2); | |
190 assert.propertyVal(blinkBuilders.Linux, 'masterUrl', 'https://build.chromi
um.org/p/chromium.webkit'); | |
191 assert.propertyVal(blinkBuilders.Linux, 'failingBuildCount', 2); | |
192 assert.propertyVal(blinkBuilders.Linux, 'annotation', blinkAnnotation); | |
193 }); | |
194 }); | |
195 | |
196 describe('.update', function() { | |
197 it('should update everything', function(done) { | |
198 var simulator = new NetworkSimulator(assert, done); | |
199 var netData = { | |
200 'sheriff-o-matic.appspot.com/alerts': { | |
201 stale_builder_alerts: [ | |
202 { | |
203 'master_url': 'http://build.chromium.org/p/chromium.webkit', | |
204 'builder_name': 'Linux Tests', | |
205 'state': 'building', | |
206 'last_update_time': 1409697347.089103, | |
207 'pending_builds': 4, | |
208 'tree': 'blink', | |
209 }, | |
210 { | |
211 'master_url': 'http://build.chromium.org/p/chromium.linux', | |
212 'builder_name': 'Linux Tests (dbg)', | |
213 'state': 'offline', | |
214 'last_update_time': 1409697347.089103, | |
215 'pending_builds': 2, | |
216 'tree': 'blink', | |
217 }, | |
218 { | |
219 'master_url': 'http://build.chromium.org/p/chromium.win', | |
220 'builder_name': 'Win Tests (dbg)', | |
221 'state': 'idle', | |
222 'last_update_time': 1409697347.089103, | |
223 'pending_builds': 5, | |
224 'tree': 'blink', | |
225 }, | |
226 { | |
227 'last_update_time': 1409697347.089103, | |
228 'master_url': 'https://build.chromium.org/p/chromium.perf', | |
229 'master_name': 'chromium.perf', | |
230 'tree': 'chromium', | |
231 }, | |
232 ], | |
233 range_groups: [ | |
234 { | |
235 sort_key: 'linux: Linux Tests (dbg)(1)', | |
236 failure_keys: [ 'f1', ], | |
237 likely_revisions: [ | |
238 'chromium: 100', | |
239 'chromium: 101', | |
240 ], | |
241 merged_first_failing: { | |
242 blink: 50, | |
243 nacl: 50, | |
244 v8: 50, | |
245 chromium: 101, | |
246 }, | |
247 merged_last_passing: { | |
248 blink: 50, | |
249 nacl: 50, | |
250 v8: 50, | |
251 chromium: 99, | |
252 }, | |
253 }, | |
254 { | |
255 sort_key: 'linux: Linux Tests (dbg)(1)', | |
256 failure_keys: [ 'f2', ], | |
257 likely_revisions: [ | |
258 'chromium: 200', | |
259 ], | |
260 merged_first_failing: { | |
261 blink: 50, | |
262 nacl: 50, | |
263 v8: 50, | |
264 chromium: 200, | |
265 }, | |
266 merged_last_passing: { | |
267 blink: 50, | |
268 nacl: 50, | |
269 v8: 50, | |
270 chromium: 199, | |
271 }, | |
272 }, | |
273 { | |
274 sort_key: 'mac: Mac Tests', | |
275 failure_keys: [ 'f3', ], | |
276 likely_revisions: [ | |
277 'chromium: 100', | |
278 'chromium: 101', | |
279 ], | |
280 merged_first_failing: { | |
281 blink: 50, | |
282 nacl: 50, | |
283 v8: 50, | |
284 chromium: 200, | |
285 }, | |
286 merged_last_passing: { | |
287 blink: 50, | |
288 nacl: 50, | |
289 v8: 50, | |
290 chromium: 199, | |
291 }, | |
292 }, | |
293 ], | |
294 alerts: [ | |
295 { | |
296 last_result_time: 1409697347.089103, | |
297 passing_build: 2485, | |
298 last_failing_build: 2489, | |
299 failing_build: 2486, | |
300 latest_revisions: { | |
301 v8: 50, | |
302 chromium: 103, | |
303 nacl: 50, | |
304 blink: 51 | |
305 }, | |
306 master_url: "https://build.chromium.org/p/chromium.linux", | |
307 reason: null, | |
308 failing_revisions: { | |
309 v8: 50, | |
310 chromium: 101, | |
311 nacl: 50, | |
312 blink: 50 | |
313 }, | |
314 builder_name: "Linux Tests (dbg)(1)", | |
315 key: "f1", | |
316 step_name: "compile", | |
317 tree: 'chromium', | |
318 passing_revisions: { | |
319 v8: 50, | |
320 chromium: 99, | |
321 nacl: 50, | |
322 blink: 50 | |
323 }, | |
324 would_close_tree: true | |
325 }, | |
326 { | |
327 last_result_time: 1409697347.089103, | |
328 passing_build: 2485, | |
329 last_failing_build: 2489, | |
330 failing_build: 2486, | |
331 latest_revisions: { | |
332 v8: 50, | |
333 chromium: 203, | |
334 nacl: 50, | |
335 blink: 51 | |
336 }, | |
337 master_url: "https://build.chromium.org/p/chromium.linux", | |
338 reason: 'Foo.Test', | |
339 failing_revisions: { | |
340 v8: 50, | |
341 chromium: 200, | |
342 nacl: 50, | |
343 blink: 50 | |
344 }, | |
345 builder_name: "Linux Tests (dbg)(1)", | |
346 key: "f2", | |
347 step_name: "foo_tests", | |
348 tree: 'chromium', | |
349 passing_revisions: { | |
350 v8: 50, | |
351 chromium: 99, | |
352 nacl: 50, | |
353 blink: 50 | |
354 }, | |
355 would_close_tree: true | |
356 }, | |
357 { | |
358 last_result_time: 1409697347.089103, | |
359 passing_build: 2485, | |
360 last_failing_build: 2489, | |
361 failing_build: 2486, | |
362 latest_revisions: { | |
363 v8: 50, | |
364 chromium: 103, | |
365 nacl: 50, | |
366 blink: 51 | |
367 }, | |
368 master_url: "https://build.chromium.org/p/chromium.mac", | |
369 reason: null, | |
370 failing_revisions: { | |
371 v8: 50, | |
372 chromium: 101, | |
373 nacl: 50, | |
374 blink: 50 | |
375 }, | |
376 builder_name: "Mac Tests", | |
377 key: "f3", | |
378 step_name: "compile", | |
379 tree: 'chromium', | |
380 passing_revisions: { | |
381 v8: 50, | |
382 chromium: 99, | |
383 nacl: 50, | |
384 blink: 50 | |
385 }, | |
386 would_close_tree: true | |
387 }, | |
388 ], | |
389 date: 1409697816.726562, | |
390 }, | |
391 'trooper-o-matic.appspot.com/alerts': { | |
392 | |
393 } | |
394 } | |
395 simulator.json = function(url) { | |
396 var matched = Object.find(netData, function(key) { | |
397 return url.indexOf(key) != -1; | |
398 }); | |
399 if (matched) { | |
400 return Promise.resolve(netData[matched]); | |
401 } else { | |
402 return Promise.reject('Unexpected url: ' + url); | |
403 } | |
404 }; | |
405 simulator.runTest(function() { | |
406 var analyzer = new CTFailures(CTCommitLogMock()); | |
407 return analyzer.update().then(function() { | |
408 assert.property(analyzer.failures, 'chromium'); | |
409 assert.lengthOf(analyzer.failures.chromium, 4); | |
410 var masterFailureGroup = analyzer.failures.chromium[0]; | |
411 var testFailureGroup = analyzer.failures.chromium[1]; | |
412 var compileFailureGroup = analyzer.failures.chromium[2]; | |
413 var macCompileFailureGroup = analyzer.failures.chromium[3]; | |
414 assert.equal(compileFailureGroup.constructor, CTFailureGroup); | |
415 assert.equal(compileFailureGroup.key, 'compile::Linux Tests (dbg)(1)')
; | |
416 assert.lengthOf(compileFailureGroup.data.failures, 1); | |
417 var failure = compileFailureGroup.data.failures[0]; | |
418 assert.equal(failure.constructor, CTStepFailure); | |
419 assert.equal(failure.key, 'compile::Linux Tests (dbg)(1)'); | |
420 assert.equal(failure.step, 'compile'); | |
421 assert.equal(failure.testName, null); | |
422 var resultNodesByBuilder = failure.resultNodesByBuilder; | |
423 assert.property(resultNodesByBuilder, 'Linux Tests (dbg)(1)'); | |
424 var dbgBuilder = resultNodesByBuilder['Linux Tests (dbg)(1)']; | |
425 assert.propertyVal(dbgBuilder, 'actual', 'UNKNOWN'); | |
426 assert.propertyVal(dbgBuilder, 'lastFailingBuild', 2489); | |
427 assert.propertyVal(dbgBuilder, 'masterUrl', 'https://build.chromium.or
g/p/chromium.linux'); | |
428 assert.propertyVal(dbgBuilder, 'failingBuildCount', 4); | |
429 assert.property(analyzer.failures, 'blink'); | |
430 assert.lengthOf(analyzer.failures.blink, 3); | |
431 assert.equal(analyzer.failures.blink[0].data.failure.hoursSinceLastUpd
ate, 0.13); | |
432 | |
433 var commitList = compileFailureGroup.data.commitList; | |
434 assert.equal(commitList.constructor, CTCommitList); | |
435 assert.lengthOf(commitList.repositories, 1); | |
436 var repositoryCommitList = commitList.repositories[0]; | |
437 assert.propertyVal(repositoryCommitList, 'range', '100 : 101'); | |
438 assert.propertyVal(repositoryCommitList, 'expanded', false); | |
439 | |
440 // Flip |expanded| to true to check that it's preserved across updates
. | |
441 repositoryCommitList.expanded = true; | |
442 | |
443 // Update |netData| to make sure it's propagated into the updated valu
es. | |
444 netData['sheriff-o-matic.appspot.com/alerts'].alerts[0].last_failing_b
uild = 2490; | |
445 | |
446 return analyzer.update().then(function() { | |
447 assert.strictEqual(analyzer.failures.chromium[0], masterFailureGroup
) | |
448 assert.strictEqual(analyzer.failures.chromium[1], testFailureGroup) | |
449 assert.strictEqual(analyzer.failures.chromium[2], compileFailureGrou
p) | |
450 assert.strictEqual(analyzer.failures.chromium[3], macCompileFailureG
roup) | |
451 assert.strictEqual(compileFailureGroup.data.failures[0], failure) | |
452 assert.strictEqual(failure.resultNodesByBuilder, resultNodesByBuilde
r); | |
453 assert.strictEqual(resultNodesByBuilder['Linux Tests (dbg)(1)'], dbg
Builder); | |
454 assert.propertyVal(dbgBuilder, 'lastFailingBuild', 2490); | |
455 | |
456 assert.strictEqual(compileFailureGroup.data.commitList, commitList); | |
457 assert.strictEqual(commitList.repositories[0], repositoryCommitList)
; | |
458 assert.propertyVal(repositoryCommitList, 'expanded', true); | |
459 }); | |
460 }); | |
461 }); | |
462 }); | |
463 }); | |
464 | |
465 describe('processTrooperFailures', function() { | |
466 it('should filter out updates that are not alerts', function() { | |
467 var analyzer = new CTFailures(new CTCommitList(undefined, [])); | |
468 analyzer.failures = {}; | |
469 analyzer._processTrooperFailures({}, | |
470 {'key_1': {'tree_1': {should_alert: true, should_appear: true}, | |
471 'tree_2': {should_alert: false, should_appear: false}}, | |
472 'key_2': {'tree_3': {should_alert: false, should_appear: false}, | |
473 'tree_4': {should_alert: true, should_appear: true}}}); | |
474 analyzer.failures['trooper'].forEach(function(failure) { | |
475 assert(failure.data.data.should_appear); | |
476 }); | |
477 assert(analyzer.failures['trooper'].length == 2); | |
478 }); | |
479 }); | |
480 | |
481 describe('processTrooperFailures', function() { | |
482 it('should list all failures with category builder and master', function() { | |
483 var emptyCommit = new CTCommitList(undefined, []); | |
484 var emptyGroupData = new CTStepFailureGroupData([], emptyCommit); | |
485 var group1 = new CTFailureGroup('', emptyGroupData, 'builder'); | |
486 var group2 = new CTFailureGroup('', emptyGroupData, 'failedOnce'); | |
487 var group3 = new CTFailureGroup('', emptyGroupData, 'master'); | |
488 | |
489 var analyzer = new CTFailures(new CTCommitList(undefined, [])); | |
490 analyzer.failures = {}; | |
491 analyzer._processTrooperFailures( | |
492 {'tree_1': [group1], 'tree_2': [group2, group3]}, {}); | |
493 analyzer.failures['trooper'].forEach(function(failure) { | |
494 assert(failure.category == 'builder' || failure.category == 'master'); | |
495 }); | |
496 assert(analyzer.failures['trooper'].length == 2); | |
497 }); | |
498 }); | |
499 | |
500 describe('processFailuresForRangeGroup', function() { | |
501 it('should use tree name from json', function() { | |
502 var analyzer = new CTFailures(null); | |
503 | |
504 var annotations = Promise.resolve({ | |
505 'test-key': 'test-annotation', | |
506 }) | |
507 var range_groups = { | |
508 'failure_keys': ['test-key'], | |
509 'likely_revisions': [] | |
510 } | |
511 var alertsByKey = { | |
512 'test-key': { | |
513 'key': 'test-key', | |
514 'step_name': 'bot_update', | |
515 'tree': 'test-tree', | |
516 'builder_name': 'Linux', | |
517 'last_failing_build': 1234, | |
518 'failing_build': 1234, | |
519 'master_url': 'https://build.chromium.org/p/chromium', | |
520 'reason': 'test-reason', | |
521 } | |
522 } | |
523 var newFailures = {} | |
524 | |
525 analyzer._processFailuresForRangeGroup(newFailures, range_groups, alertsBy
Key, annotations) | |
526 assert.ok('test-tree' in newFailures) | |
527 assert.notOk('chromium' in newFailures) | |
528 }); | |
529 }); | |
530 | |
531 }); | |
532 | |
533 })() | |
534 </script> | |
OLD | NEW |