1 | # -*- coding: utf-8 -*-
|
---|
2 | # $Id: testresults.py 70660 2018-01-21 16:18:58Z vboxsync $
|
---|
3 | # pylint: disable=C0302
|
---|
4 |
|
---|
5 | ## @todo Rename this file to testresult.py!
|
---|
6 |
|
---|
7 | """
|
---|
8 | Test Manager - Fetch test results.
|
---|
9 | """
|
---|
10 |
|
---|
11 | __copyright__ = \
|
---|
12 | """
|
---|
13 | Copyright (C) 2012-2017 Oracle Corporation
|
---|
14 |
|
---|
15 | This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
16 | available from http://www.virtualbox.org. This file is free software;
|
---|
17 | you can redistribute it and/or modify it under the terms of the GNU
|
---|
18 | General Public License (GPL) as published by the Free Software
|
---|
19 | Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
20 | VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
21 | hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
22 |
|
---|
23 | The contents of this file may alternatively be used under the terms
|
---|
24 | of the Common Development and Distribution License Version 1.0
|
---|
25 | (CDDL) only, as it comes in the "COPYING.CDDL" file of the
|
---|
26 | VirtualBox OSE distribution, in which case the provisions of the
|
---|
27 | CDDL are applicable instead of those of the GPL.
|
---|
28 |
|
---|
29 | You may elect to license modified versions of this file under the
|
---|
30 | terms and conditions of either the GPL or the CDDL or both.
|
---|
31 | """
|
---|
32 | __version__ = "$Revision: 70660 $"
|
---|
33 |
|
---|
34 |
|
---|
35 | # Standard python imports.
|
---|
36 | import sys;
|
---|
37 | import unittest;
|
---|
38 |
|
---|
39 | # Validation Kit imports.
|
---|
40 | from common import constants;
|
---|
41 | from testmanager import config;
|
---|
42 | from testmanager.core.base import ModelDataBase, ModelLogicBase, ModelDataBaseTestCase, ModelFilterBase, \
|
---|
43 | FilterCriterion, FilterCriterionValueAndDescription, \
|
---|
44 | TMExceptionBase, TMTooManyRows, TMRowNotFound;
|
---|
45 | from testmanager.core.testgroup import TestGroupData;
|
---|
46 | from testmanager.core.build import BuildDataEx, BuildCategoryData;
|
---|
47 | from testmanager.core.failurereason import FailureReasonLogic;
|
---|
48 | from testmanager.core.testbox import TestBoxData, TestBoxLogic;
|
---|
49 | from testmanager.core.testcase import TestCaseData;
|
---|
50 | from testmanager.core.schedgroup import SchedGroupData, SchedGroupLogic;
|
---|
51 | from testmanager.core.systemlog import SystemLogData, SystemLogLogic;
|
---|
52 | from testmanager.core.testresultfailures import TestResultFailureDataEx;
|
---|
53 | from testmanager.core.useraccount import UserAccountLogic;
|
---|
54 |
|
---|
55 | # Python 3 hacks:
|
---|
56 | if sys.version_info[0] >= 3:
|
---|
57 | long = int; # pylint: disable=redefined-builtin,invalid-name
|
---|
58 |
|
---|
59 |
|
---|
60 | class TestResultData(ModelDataBase):
|
---|
61 | """
|
---|
62 | Test case execution result data
|
---|
63 | """
|
---|
64 |
|
---|
65 | ## @name TestStatus_T
|
---|
66 | # @{
|
---|
67 | ksTestStatus_Running = 'running';
|
---|
68 | ksTestStatus_Success = 'success';
|
---|
69 | ksTestStatus_Skipped = 'skipped';
|
---|
70 | ksTestStatus_BadTestBox = 'bad-testbox';
|
---|
71 | ksTestStatus_Aborted = 'aborted';
|
---|
72 | ksTestStatus_Failure = 'failure';
|
---|
73 | ksTestStatus_TimedOut = 'timed-out';
|
---|
74 | ksTestStatus_Rebooted = 'rebooted';
|
---|
75 | ## @}
|
---|
76 |
|
---|
77 | ## List of relatively harmless (to testgroup/case) statuses.
|
---|
78 | kasHarmlessTestStatuses = [ ksTestStatus_Skipped, ksTestStatus_BadTestBox, ksTestStatus_Aborted, ];
|
---|
79 | ## List of bad statuses.
|
---|
80 | kasBadTestStatuses = [ ksTestStatus_Failure, ksTestStatus_TimedOut, ksTestStatus_Rebooted, ];
|
---|
81 |
|
---|
82 |
|
---|
83 | ksIdAttr = 'idTestResult';
|
---|
84 |
|
---|
85 | ksParam_idTestResult = 'TestResultData_idTestResult';
|
---|
86 | ksParam_idTestResultParent = 'TestResultData_idTestResultParent';
|
---|
87 | ksParam_idTestSet = 'TestResultData_idTestSet';
|
---|
88 | ksParam_tsCreated = 'TestResultData_tsCreated';
|
---|
89 | ksParam_tsElapsed = 'TestResultData_tsElapsed';
|
---|
90 | ksParam_idStrName = 'TestResultData_idStrName';
|
---|
91 | ksParam_cErrors = 'TestResultData_cErrors';
|
---|
92 | ksParam_enmStatus = 'TestResultData_enmStatus';
|
---|
93 | ksParam_iNestingDepth = 'TestResultData_iNestingDepth';
|
---|
94 | kasValidValues_enmStatus = [
|
---|
95 | ksTestStatus_Running,
|
---|
96 | ksTestStatus_Success,
|
---|
97 | ksTestStatus_Skipped,
|
---|
98 | ksTestStatus_BadTestBox,
|
---|
99 | ksTestStatus_Aborted,
|
---|
100 | ksTestStatus_Failure,
|
---|
101 | ksTestStatus_TimedOut,
|
---|
102 | ksTestStatus_Rebooted
|
---|
103 | ];
|
---|
104 |
|
---|
105 |
|
---|
106 | def __init__(self):
|
---|
107 | ModelDataBase.__init__(self)
|
---|
108 | self.idTestResult = None
|
---|
109 | self.idTestResultParent = None
|
---|
110 | self.idTestSet = None
|
---|
111 | self.tsCreated = None
|
---|
112 | self.tsElapsed = None
|
---|
113 | self.idStrName = None
|
---|
114 | self.cErrors = 0;
|
---|
115 | self.enmStatus = None
|
---|
116 | self.iNestingDepth = None
|
---|
117 |
|
---|
118 | def initFromDbRow(self, aoRow):
|
---|
119 | """
|
---|
120 | Reinitialize from a SELECT * FROM TestResults.
|
---|
121 | Return self. Raises exception if no row.
|
---|
122 | """
|
---|
123 | if aoRow is None:
|
---|
124 | raise TMRowNotFound('Test result record not found.')
|
---|
125 |
|
---|
126 | self.idTestResult = aoRow[0]
|
---|
127 | self.idTestResultParent = aoRow[1]
|
---|
128 | self.idTestSet = aoRow[2]
|
---|
129 | self.tsCreated = aoRow[3]
|
---|
130 | self.tsElapsed = aoRow[4]
|
---|
131 | self.idStrName = aoRow[5]
|
---|
132 | self.cErrors = aoRow[6]
|
---|
133 | self.enmStatus = aoRow[7]
|
---|
134 | self.iNestingDepth = aoRow[8]
|
---|
135 | return self;
|
---|
136 |
|
---|
137 | def initFromDbWithId(self, oDb, idTestResult, tsNow = None, sPeriodBack = None):
|
---|
138 | """
|
---|
139 | Initialize from the database, given the ID of a row.
|
---|
140 | """
|
---|
141 | _ = tsNow;
|
---|
142 | _ = sPeriodBack;
|
---|
143 | oDb.execute('SELECT *\n'
|
---|
144 | 'FROM TestResults\n'
|
---|
145 | 'WHERE idTestResult = %s\n'
|
---|
146 | , ( idTestResult,));
|
---|
147 | aoRow = oDb.fetchOne()
|
---|
148 | if aoRow is None:
|
---|
149 | raise TMRowNotFound('idTestResult=%s not found' % (idTestResult,));
|
---|
150 | return self.initFromDbRow(aoRow);
|
---|
151 |
|
---|
152 | def isFailure(self):
|
---|
153 | """ Check if it's a real failure. """
|
---|
154 | return self.enmStatus in self.kasBadTestStatuses;
|
---|
155 |
|
---|
156 |
|
---|
157 | class TestResultDataEx(TestResultData):
|
---|
158 | """
|
---|
159 | Extended test result data class.
|
---|
160 |
|
---|
161 | This is intended for use as a node in a result tree. This is not intended
|
---|
162 | for serialization to parameters or vice versa. Use TestResultLogic to
|
---|
163 | construct the tree.
|
---|
164 | """
|
---|
165 |
|
---|
166 | def __init__(self):
|
---|
167 | TestResultData.__init__(self)
|
---|
168 | self.sName = None; # idStrName resolved.
|
---|
169 | self.oParent = None; # idTestResultParent within the tree.
|
---|
170 |
|
---|
171 | self.aoChildren = []; # TestResultDataEx;
|
---|
172 | self.aoValues = []; # TestResultValueDataEx;
|
---|
173 | self.aoMsgs = []; # TestResultMsgDataEx;
|
---|
174 | self.aoFiles = []; # TestResultFileDataEx;
|
---|
175 | self.oReason = None; # TestResultReasonDataEx;
|
---|
176 |
|
---|
177 | def initFromDbRow(self, aoRow):
|
---|
178 | """
|
---|
179 | Initialize from a query like this:
|
---|
180 | SELECT TestResults.*, TestResultStrTab.sValue
|
---|
181 | FROM TestResults, TestResultStrTab
|
---|
182 | WHERE TestResultStrTab.idStr = TestResults.idStrName
|
---|
183 |
|
---|
184 | Note! The caller is expected to fetch children, values, failure
|
---|
185 | details, and files.
|
---|
186 | """
|
---|
187 | self.sName = None;
|
---|
188 | self.oParent = None;
|
---|
189 | self.aoChildren = [];
|
---|
190 | self.aoValues = [];
|
---|
191 | self.aoMsgs = [];
|
---|
192 | self.aoFiles = [];
|
---|
193 | self.oReason = None;
|
---|
194 |
|
---|
195 | TestResultData.initFromDbRow(self, aoRow);
|
---|
196 |
|
---|
197 | self.sName = aoRow[9];
|
---|
198 | return self;
|
---|
199 |
|
---|
200 | def deepCountErrorContributers(self):
|
---|
201 | """
|
---|
202 | Counts how many test result instances actually contributed to cErrors.
|
---|
203 | """
|
---|
204 |
|
---|
205 | # Check each child (if any).
|
---|
206 | cChanges = 0;
|
---|
207 | cChildErrors = 0;
|
---|
208 | for oChild in self.aoChildren:
|
---|
209 | if oChild.cErrors > 0:
|
---|
210 | cChildErrors += oChild.cErrors;
|
---|
211 | cChanges += oChild.deepCountErrorContributers();
|
---|
212 |
|
---|
213 | # Did we contribute as well?
|
---|
214 | if self.cErrors > cChildErrors:
|
---|
215 | cChanges += 1;
|
---|
216 | return cChanges;
|
---|
217 |
|
---|
218 | def getListOfFailures(self):
|
---|
219 | """
|
---|
220 | Get a list of test results instances actually contributing to cErrors.
|
---|
221 |
|
---|
222 | Returns a list of TestResultDataEx instance from this tree. (shared!)
|
---|
223 | """
|
---|
224 | # Check each child (if any).
|
---|
225 | aoRet = [];
|
---|
226 | cChildErrors = 0;
|
---|
227 | for oChild in self.aoChildren:
|
---|
228 | if oChild.cErrors > 0:
|
---|
229 | cChildErrors += oChild.cErrors;
|
---|
230 | aoRet.extend(oChild.getListOfFailures());
|
---|
231 |
|
---|
232 | # Did we contribute as well?
|
---|
233 | if self.cErrors > cChildErrors:
|
---|
234 | aoRet.append(self);
|
---|
235 |
|
---|
236 | return aoRet;
|
---|
237 |
|
---|
238 | def getFullName(self):
|
---|
239 | """ Constructs the full name of this test result. """
|
---|
240 | if self.oParent is None:
|
---|
241 | return self.sName;
|
---|
242 | return self.oParent.getFullName() + ' / ' + self.sName;
|
---|
243 |
|
---|
244 |
|
---|
245 |
|
---|
246 | class TestResultValueData(ModelDataBase):
|
---|
247 | """
|
---|
248 | Test result value data.
|
---|
249 | """
|
---|
250 |
|
---|
251 | ksIdAttr = 'idTestResultValue';
|
---|
252 |
|
---|
253 | ksParam_idTestResultValue = 'TestResultValue_idTestResultValue';
|
---|
254 | ksParam_idTestResult = 'TestResultValue_idTestResult';
|
---|
255 | ksParam_idTestSet = 'TestResultValue_idTestSet';
|
---|
256 | ksParam_tsCreated = 'TestResultValue_tsCreated';
|
---|
257 | ksParam_idStrName = 'TestResultValue_idStrName';
|
---|
258 | ksParam_lValue = 'TestResultValue_lValue';
|
---|
259 | ksParam_iUnit = 'TestResultValue_iUnit';
|
---|
260 |
|
---|
261 | kasAllowNullAttributes = [ 'idTestSet', ];
|
---|
262 |
|
---|
263 | def __init__(self):
|
---|
264 | ModelDataBase.__init__(self)
|
---|
265 | self.idTestResultValue = None;
|
---|
266 | self.idTestResult = None;
|
---|
267 | self.idTestSet = None;
|
---|
268 | self.tsCreated = None;
|
---|
269 | self.idStrName = None;
|
---|
270 | self.lValue = None;
|
---|
271 | self.iUnit = 0;
|
---|
272 |
|
---|
273 | def initFromDbRow(self, aoRow):
|
---|
274 | """
|
---|
275 | Reinitialize from a SELECT * FROM TestResultValues.
|
---|
276 | Return self. Raises exception if no row.
|
---|
277 | """
|
---|
278 | if aoRow is None:
|
---|
279 | raise TMRowNotFound('Test result value record not found.')
|
---|
280 |
|
---|
281 | self.idTestResultValue = aoRow[0];
|
---|
282 | self.idTestResult = aoRow[1];
|
---|
283 | self.idTestSet = aoRow[2];
|
---|
284 | self.tsCreated = aoRow[3];
|
---|
285 | self.idStrName = aoRow[4];
|
---|
286 | self.lValue = aoRow[5];
|
---|
287 | self.iUnit = aoRow[6];
|
---|
288 | return self;
|
---|
289 |
|
---|
290 |
|
---|
291 | class TestResultValueDataEx(TestResultValueData):
|
---|
292 | """
|
---|
293 | Extends TestResultValue by resolving the value name and unit string.
|
---|
294 | """
|
---|
295 |
|
---|
296 | def __init__(self):
|
---|
297 | TestResultValueData.__init__(self)
|
---|
298 | self.sName = None;
|
---|
299 | self.sUnit = '';
|
---|
300 |
|
---|
301 | def initFromDbRow(self, aoRow):
|
---|
302 | """
|
---|
303 | Reinitialize from a query like this:
|
---|
304 | SELECT TestResultValues.*, TestResultStrTab.sValue
|
---|
305 | FROM TestResultValues, TestResultStrTab
|
---|
306 | WHERE TestResultStrTab.idStr = TestResultValues.idStrName
|
---|
307 |
|
---|
308 | Return self. Raises exception if no row.
|
---|
309 | """
|
---|
310 | TestResultValueData.initFromDbRow(self, aoRow);
|
---|
311 | self.sName = aoRow[7];
|
---|
312 | if self.iUnit < len(constants.valueunit.g_asNames):
|
---|
313 | self.sUnit = constants.valueunit.g_asNames[self.iUnit];
|
---|
314 | else:
|
---|
315 | self.sUnit = '<%d>' % (self.iUnit,);
|
---|
316 | return self;
|
---|
317 |
|
---|
318 | class TestResultMsgData(ModelDataBase):
|
---|
319 | """
|
---|
320 | Test result message data.
|
---|
321 | """
|
---|
322 |
|
---|
323 | ksIdAttr = 'idTestResultMsg';
|
---|
324 |
|
---|
325 | ksParam_idTestResultMsg = 'TestResultValue_idTestResultMsg';
|
---|
326 | ksParam_idTestResult = 'TestResultValue_idTestResult';
|
---|
327 | ksParam_idTestSet = 'TestResultValue_idTestSet';
|
---|
328 | ksParam_tsCreated = 'TestResultValue_tsCreated';
|
---|
329 | ksParam_idStrMsg = 'TestResultValue_idStrMsg';
|
---|
330 | ksParam_enmLevel = 'TestResultValue_enmLevel';
|
---|
331 |
|
---|
332 | kasAllowNullAttributes = [ 'idTestSet', ];
|
---|
333 |
|
---|
334 | kcDbColumns = 6
|
---|
335 |
|
---|
336 | def __init__(self):
|
---|
337 | ModelDataBase.__init__(self)
|
---|
338 | self.idTestResultMsg = None;
|
---|
339 | self.idTestResult = None;
|
---|
340 | self.idTestSet = None;
|
---|
341 | self.tsCreated = None;
|
---|
342 | self.idStrMsg = None;
|
---|
343 | self.enmLevel = None;
|
---|
344 |
|
---|
345 | def initFromDbRow(self, aoRow):
|
---|
346 | """
|
---|
347 | Reinitialize from a SELECT * FROM TestResultMsgs.
|
---|
348 | Return self. Raises exception if no row.
|
---|
349 | """
|
---|
350 | if aoRow is None:
|
---|
351 | raise TMRowNotFound('Test result value record not found.')
|
---|
352 |
|
---|
353 | self.idTestResultMsg = aoRow[0];
|
---|
354 | self.idTestResult = aoRow[1];
|
---|
355 | self.idTestSet = aoRow[2];
|
---|
356 | self.tsCreated = aoRow[3];
|
---|
357 | self.idStrMsg = aoRow[4];
|
---|
358 | self.enmLevel = aoRow[5];
|
---|
359 | return self;
|
---|
360 |
|
---|
361 | class TestResultMsgDataEx(TestResultMsgData):
|
---|
362 | """
|
---|
363 | Extends TestResultMsg by resolving the message string.
|
---|
364 | """
|
---|
365 |
|
---|
366 | def __init__(self):
|
---|
367 | TestResultMsgData.__init__(self)
|
---|
368 | self.sMsg = None;
|
---|
369 |
|
---|
370 | def initFromDbRow(self, aoRow):
|
---|
371 | """
|
---|
372 | Reinitialize from a query like this:
|
---|
373 | SELECT TestResultMsg.*, TestResultStrTab.sValue
|
---|
374 | FROM TestResultMsg, TestResultStrTab
|
---|
375 | WHERE TestResultStrTab.idStr = TestResultMsgs.idStrName
|
---|
376 |
|
---|
377 | Return self. Raises exception if no row.
|
---|
378 | """
|
---|
379 | TestResultMsgData.initFromDbRow(self, aoRow);
|
---|
380 | self.sMsg = aoRow[self.kcDbColumns];
|
---|
381 | return self;
|
---|
382 |
|
---|
383 |
|
---|
384 | class TestResultFileData(ModelDataBase):
|
---|
385 | """
|
---|
386 | Test result message data.
|
---|
387 | """
|
---|
388 |
|
---|
389 | ksIdAttr = 'idTestResultFile';
|
---|
390 |
|
---|
391 | ksParam_idTestResultFile = 'TestResultFile_idTestResultFile';
|
---|
392 | ksParam_idTestResult = 'TestResultFile_idTestResult';
|
---|
393 | ksParam_tsCreated = 'TestResultFile_tsCreated';
|
---|
394 | ksParam_idStrFile = 'TestResultFile_idStrFile';
|
---|
395 | ksParam_idStrDescription = 'TestResultFile_idStrDescription';
|
---|
396 | ksParam_idStrKind = 'TestResultFile_idStrKind';
|
---|
397 | ksParam_idStrMime = 'TestResultFile_idStrMime';
|
---|
398 |
|
---|
399 | ## @name Kind of files.
|
---|
400 | ## @{
|
---|
401 | ksKind_LogReleaseVm = 'log/release/vm';
|
---|
402 | ksKind_LogDebugVm = 'log/debug/vm';
|
---|
403 | ksKind_LogReleaseSvc = 'log/release/svc';
|
---|
404 | ksKind_LogRebugSvc = 'log/debug/svc';
|
---|
405 | ksKind_LogReleaseClient = 'log/release/client';
|
---|
406 | ksKind_LogDebugClient = 'log/debug/client';
|
---|
407 | ksKind_LogInstaller = 'log/installer';
|
---|
408 | ksKind_LogUninstaller = 'log/uninstaller';
|
---|
409 | ksKind_LogGuestKernel = 'log/guest/kernel';
|
---|
410 | ksKind_ProcessReportVm = 'process/report/vm';
|
---|
411 | ksKind_CrashReportVm = 'crash/report/vm';
|
---|
412 | ksKind_CrashDumpVm = 'crash/dump/vm';
|
---|
413 | ksKind_CrashReportSvc = 'crash/report/svc';
|
---|
414 | ksKind_CrashDumpSvc = 'crash/dump/svc';
|
---|
415 | ksKind_CrashReportClient = 'crash/report/client';
|
---|
416 | ksKind_CrashDumpClient = 'crash/dump/client';
|
---|
417 | ksKind_InfoCollection = 'info/collection';
|
---|
418 | ksKind_InfoVgaText = 'info/vgatext';
|
---|
419 | ksKind_MiscOther = 'misc/other';
|
---|
420 | ksKind_ScreenshotFailure = 'screenshot/failure';
|
---|
421 | ksKind_ScreenshotSuccesss = 'screenshot/success';
|
---|
422 | #kskind_ScreenCaptureFailure = 'screencapture/failure';
|
---|
423 | ## @}
|
---|
424 |
|
---|
425 | kasKinds = [
|
---|
426 | ksKind_LogReleaseVm,
|
---|
427 | ksKind_LogDebugVm,
|
---|
428 | ksKind_LogReleaseSvc,
|
---|
429 | ksKind_LogRebugSvc,
|
---|
430 | ksKind_LogReleaseClient,
|
---|
431 | ksKind_LogDebugClient,
|
---|
432 | ksKind_LogInstaller,
|
---|
433 | ksKind_LogUninstaller,
|
---|
434 | ksKind_LogGuestKernel,
|
---|
435 | ksKind_ProcessReportVm,
|
---|
436 | ksKind_CrashReportVm,
|
---|
437 | ksKind_CrashDumpVm,
|
---|
438 | ksKind_CrashReportSvc,
|
---|
439 | ksKind_CrashDumpSvc,
|
---|
440 | ksKind_CrashReportClient,
|
---|
441 | ksKind_CrashDumpClient,
|
---|
442 | ksKind_InfoCollection,
|
---|
443 | ksKind_InfoVgaText,
|
---|
444 | ksKind_MiscOther,
|
---|
445 | ksKind_ScreenshotFailure,
|
---|
446 | ksKind_ScreenshotSuccesss,
|
---|
447 | #kskind_ScreenCaptureFailure,
|
---|
448 | ];
|
---|
449 |
|
---|
450 | kasAllowNullAttributes = [ 'idTestSet', ];
|
---|
451 |
|
---|
452 | kcDbColumns = 8
|
---|
453 |
|
---|
454 | def __init__(self):
|
---|
455 | ModelDataBase.__init__(self)
|
---|
456 | self.idTestResultFile = None;
|
---|
457 | self.idTestResult = None;
|
---|
458 | self.idTestSet = None;
|
---|
459 | self.tsCreated = None;
|
---|
460 | self.idStrFile = None;
|
---|
461 | self.idStrDescription = None;
|
---|
462 | self.idStrKind = None;
|
---|
463 | self.idStrMime = None;
|
---|
464 |
|
---|
465 | def initFromDbRow(self, aoRow):
|
---|
466 | """
|
---|
467 | Reinitialize from a SELECT * FROM TestResultFiles.
|
---|
468 | Return self. Raises exception if no row.
|
---|
469 | """
|
---|
470 | if aoRow is None:
|
---|
471 | raise TMRowNotFound('Test result file record not found.')
|
---|
472 |
|
---|
473 | self.idTestResultFile = aoRow[0];
|
---|
474 | self.idTestResult = aoRow[1];
|
---|
475 | self.idTestSet = aoRow[2];
|
---|
476 | self.tsCreated = aoRow[3];
|
---|
477 | self.idStrFile = aoRow[4];
|
---|
478 | self.idStrDescription = aoRow[5];
|
---|
479 | self.idStrKind = aoRow[6];
|
---|
480 | self.idStrMime = aoRow[7];
|
---|
481 | return self;
|
---|
482 |
|
---|
483 | class TestResultFileDataEx(TestResultFileData):
|
---|
484 | """
|
---|
485 | Extends TestResultFile by resolving the strings.
|
---|
486 | """
|
---|
487 |
|
---|
488 | def __init__(self):
|
---|
489 | TestResultFileData.__init__(self)
|
---|
490 | self.sFile = None;
|
---|
491 | self.sDescription = None;
|
---|
492 | self.sKind = None;
|
---|
493 | self.sMime = None;
|
---|
494 |
|
---|
495 | def initFromDbRow(self, aoRow):
|
---|
496 | """
|
---|
497 | Reinitialize from a query like this:
|
---|
498 | SELECT TestResultFiles.*,
|
---|
499 | StrTabFile.sValue AS sFile,
|
---|
500 | StrTabDesc.sValue AS sDescription
|
---|
501 | StrTabKind.sValue AS sKind,
|
---|
502 | StrTabMime.sValue AS sMime,
|
---|
503 | FROM ...
|
---|
504 |
|
---|
505 | Return self. Raises exception if no row.
|
---|
506 | """
|
---|
507 | TestResultFileData.initFromDbRow(self, aoRow);
|
---|
508 | self.sFile = aoRow[self.kcDbColumns];
|
---|
509 | self.sDescription = aoRow[self.kcDbColumns + 1];
|
---|
510 | self.sKind = aoRow[self.kcDbColumns + 2];
|
---|
511 | self.sMime = aoRow[self.kcDbColumns + 3];
|
---|
512 | return self;
|
---|
513 |
|
---|
514 | def initFakeMainLog(self, oTestSet):
|
---|
515 | """
|
---|
516 | Reinitializes to represent the main.log object (not in DB).
|
---|
517 |
|
---|
518 | Returns self.
|
---|
519 | """
|
---|
520 | self.idTestResultFile = 0;
|
---|
521 | self.idTestResult = oTestSet.idTestResult;
|
---|
522 | self.tsCreated = oTestSet.tsCreated;
|
---|
523 | self.idStrFile = None;
|
---|
524 | self.idStrDescription = None;
|
---|
525 | self.idStrKind = None;
|
---|
526 | self.idStrMime = None;
|
---|
527 |
|
---|
528 | self.sFile = 'main.log';
|
---|
529 | self.sDescription = '';
|
---|
530 | self.sKind = 'log/main';
|
---|
531 | self.sMime = 'text/plain';
|
---|
532 | return self;
|
---|
533 |
|
---|
534 | def isProbablyUtf8Encoded(self):
|
---|
535 | """
|
---|
536 | Checks if the file is likely to be UTF-8 encoded.
|
---|
537 | """
|
---|
538 | if self.sMime in [ 'text/plain', 'text/html' ]:
|
---|
539 | return True;
|
---|
540 | return False;
|
---|
541 |
|
---|
542 | def getMimeWithEncoding(self):
|
---|
543 | """
|
---|
544 | Gets the MIME type with encoding if likely to be UTF-8.
|
---|
545 | """
|
---|
546 | if self.isProbablyUtf8Encoded():
|
---|
547 | return '%s; charset=utf-8' % (self.sMime,);
|
---|
548 | return self.sMime;
|
---|
549 |
|
---|
550 |
|
---|
551 |
|
---|
552 | class TestResultListingData(ModelDataBase): # pylint: disable=R0902
|
---|
553 | """
|
---|
554 | Test case result data representation for table listing
|
---|
555 | """
|
---|
556 |
|
---|
557 | class FailureReasonListingData(object):
|
---|
558 | """ Failure reason listing data """
|
---|
559 | def __init__(self):
|
---|
560 | self.oFailureReason = None;
|
---|
561 | self.oFailureReasonAssigner = None;
|
---|
562 | self.tsFailureReasonAssigned = None;
|
---|
563 | self.sFailureReasonComment = None;
|
---|
564 |
|
---|
565 | def __init__(self):
|
---|
566 | """Initialize"""
|
---|
567 | ModelDataBase.__init__(self)
|
---|
568 |
|
---|
569 | self.idTestSet = None
|
---|
570 |
|
---|
571 | self.idBuildCategory = None;
|
---|
572 | self.sProduct = None
|
---|
573 | self.sRepository = None;
|
---|
574 | self.sBranch = None
|
---|
575 | self.sType = None
|
---|
576 | self.idBuild = None;
|
---|
577 | self.sVersion = None;
|
---|
578 | self.iRevision = None
|
---|
579 |
|
---|
580 | self.sOs = None;
|
---|
581 | self.sOsVersion = None;
|
---|
582 | self.sArch = None;
|
---|
583 | self.sCpuVendor = None;
|
---|
584 | self.sCpuName = None;
|
---|
585 | self.cCpus = None;
|
---|
586 | self.fCpuHwVirt = None;
|
---|
587 | self.fCpuNestedPaging = None;
|
---|
588 | self.fCpu64BitGuest = None;
|
---|
589 | self.idTestBox = None
|
---|
590 | self.sTestBoxName = None
|
---|
591 |
|
---|
592 | self.tsCreated = None
|
---|
593 | self.tsElapsed = None
|
---|
594 | self.enmStatus = None
|
---|
595 | self.cErrors = None;
|
---|
596 |
|
---|
597 | self.idTestCase = None
|
---|
598 | self.sTestCaseName = None
|
---|
599 | self.sBaseCmd = None
|
---|
600 | self.sArgs = None
|
---|
601 | self.sSubName = None;
|
---|
602 |
|
---|
603 | self.idBuildTestSuite = None;
|
---|
604 | self.iRevisionTestSuite = None;
|
---|
605 |
|
---|
606 | self.aoFailureReasons = [];
|
---|
607 |
|
---|
608 | def initFromDbRowEx(self, aoRow, oFailureReasonLogic, oUserAccountLogic):
|
---|
609 | """
|
---|
610 | Reinitialize from a database query.
|
---|
611 | Return self. Raises exception if no row.
|
---|
612 | """
|
---|
613 | if aoRow is None:
|
---|
614 | raise TMRowNotFound('Test result record not found.')
|
---|
615 |
|
---|
616 | self.idTestSet = aoRow[0];
|
---|
617 |
|
---|
618 | self.idBuildCategory = aoRow[1];
|
---|
619 | self.sProduct = aoRow[2];
|
---|
620 | self.sRepository = aoRow[3];
|
---|
621 | self.sBranch = aoRow[4];
|
---|
622 | self.sType = aoRow[5];
|
---|
623 | self.idBuild = aoRow[6];
|
---|
624 | self.sVersion = aoRow[7];
|
---|
625 | self.iRevision = aoRow[8];
|
---|
626 |
|
---|
627 | self.sOs = aoRow[9];
|
---|
628 | self.sOsVersion = aoRow[10];
|
---|
629 | self.sArch = aoRow[11];
|
---|
630 | self.sCpuVendor = aoRow[12];
|
---|
631 | self.sCpuName = aoRow[13];
|
---|
632 | self.cCpus = aoRow[14];
|
---|
633 | self.fCpuHwVirt = aoRow[15];
|
---|
634 | self.fCpuNestedPaging = aoRow[16];
|
---|
635 | self.fCpu64BitGuest = aoRow[17];
|
---|
636 | self.idTestBox = aoRow[18];
|
---|
637 | self.sTestBoxName = aoRow[19];
|
---|
638 |
|
---|
639 | self.tsCreated = aoRow[20];
|
---|
640 | self.tsElapsed = aoRow[21];
|
---|
641 | self.enmStatus = aoRow[22];
|
---|
642 | self.cErrors = aoRow[23];
|
---|
643 |
|
---|
644 | self.idTestCase = aoRow[24];
|
---|
645 | self.sTestCaseName = aoRow[25];
|
---|
646 | self.sBaseCmd = aoRow[26];
|
---|
647 | self.sArgs = aoRow[27];
|
---|
648 | self.sSubName = aoRow[28];
|
---|
649 |
|
---|
650 | self.idBuildTestSuite = aoRow[29];
|
---|
651 | self.iRevisionTestSuite = aoRow[30];
|
---|
652 |
|
---|
653 | self.aoFailureReasons = [];
|
---|
654 | for i, _ in enumerate(aoRow[31]):
|
---|
655 | if aoRow[31][i] is not None \
|
---|
656 | or aoRow[32][i] is not None \
|
---|
657 | or aoRow[33][i] is not None \
|
---|
658 | or aoRow[34][i] is not None:
|
---|
659 | oReason = self.FailureReasonListingData();
|
---|
660 | if aoRow[31][i] is not None:
|
---|
661 | oReason.oFailureReason = oFailureReasonLogic.cachedLookup(aoRow[31][i]);
|
---|
662 | if aoRow[32][i] is not None:
|
---|
663 | oReason.oFailureReasonAssigner = oUserAccountLogic.cachedLookup(aoRow[32][i]);
|
---|
664 | oReason.tsFailureReasonAssigned = aoRow[33][i];
|
---|
665 | oReason.sFailureReasonComment = aoRow[34][i];
|
---|
666 | self.aoFailureReasons.append(oReason);
|
---|
667 |
|
---|
668 | return self
|
---|
669 |
|
---|
670 |
|
---|
671 | class TestResultHangingOffence(TMExceptionBase):
|
---|
672 | """Hanging offence committed by test case."""
|
---|
673 | pass;
|
---|
674 |
|
---|
675 |
|
---|
676 | class TestResultFilter(ModelFilterBase):
|
---|
677 | """
|
---|
678 | Test result filter.
|
---|
679 | """
|
---|
680 |
|
---|
681 | kiTestStatus = 0;
|
---|
682 | kiErrorCounts = 1;
|
---|
683 | kiBranches = 2;
|
---|
684 | kiBuildTypes = 3;
|
---|
685 | kiRevisions = 4;
|
---|
686 | kiFailReasons = 5;
|
---|
687 | kiTestCases = 6;
|
---|
688 | kiTestCaseMisc = 7;
|
---|
689 | kiTestBoxes = 8
|
---|
690 | kiOses = 9;
|
---|
691 | kiCpuArches = 10;
|
---|
692 | kiCpuVendors = 11;
|
---|
693 | kiCpuCounts = 12;
|
---|
694 | kiMemory = 13;
|
---|
695 | kiTestboxMisc = 14;
|
---|
696 | kiPythonVersions = 15;
|
---|
697 | kiSchedGroups = 16;
|
---|
698 |
|
---|
699 | ## Misc test case / variation name filters.
|
---|
700 | ## Presented in table order. The first sub element is the presistent ID.
|
---|
701 | kaTcMisc = (
|
---|
702 | ( 1, 'x86', ),
|
---|
703 | ( 2, 'amd64', ),
|
---|
704 | ( 3, 'uni', ),
|
---|
705 | ( 4, 'smp', ),
|
---|
706 | ( 5, 'raw', ),
|
---|
707 | ( 6, 'hw', ),
|
---|
708 | ( 7, 'np', ),
|
---|
709 | ( 8, 'Install', ),
|
---|
710 | ( 9, 'Benchmark', ),
|
---|
711 | ( 18, 'smoke', ), # NB. out of order.
|
---|
712 | ( 19, 'unit', ), # NB. out of order.
|
---|
713 | ( 10, 'USB', ),
|
---|
714 | ( 11, 'Debian', ),
|
---|
715 | ( 12, 'Fedora', ),
|
---|
716 | ( 13, 'Oracle', ),
|
---|
717 | ( 14, 'RHEL', ),
|
---|
718 | ( 15, 'SUSE', ),
|
---|
719 | ( 16, 'Ubuntu', ),
|
---|
720 | ( 17, 'Win', ),
|
---|
721 | );
|
---|
722 |
|
---|
723 | kiTbMisc_NestedPaging = 0;
|
---|
724 | kiTbMisc_NoNestedPaging = 1;
|
---|
725 | kiTbMisc_RawMode = 2;
|
---|
726 | kiTbMisc_NoRawMode = 3;
|
---|
727 | kiTbMisc_64BitGuest = 4;
|
---|
728 | kiTbMisc_No64BitGuest = 5;
|
---|
729 | kiTbMisc_HwVirt = 6;
|
---|
730 | kiTbMisc_NoHwVirt = 7;
|
---|
731 | kiTbMisc_IoMmu = 8;
|
---|
732 | kiTbMisc_NoIoMmu = 9;
|
---|
733 |
|
---|
734 | def __init__(self):
|
---|
735 | ModelFilterBase.__init__(self);
|
---|
736 |
|
---|
737 | # Test statuses
|
---|
738 | oCrit = FilterCriterion('Test statuses', sVarNm = 'ts', sType = FilterCriterion.ksType_String,
|
---|
739 | sTable = 'TestSets', sColumn = 'enmStatus');
|
---|
740 | self.aCriteria.append(oCrit);
|
---|
741 | assert self.aCriteria[self.kiTestStatus] is oCrit;
|
---|
742 |
|
---|
743 | # Error counts
|
---|
744 | oCrit = FilterCriterion('Error counts', sVarNm = 'ec', sTable = 'TestResults', sColumn = 'cErrors');
|
---|
745 | self.aCriteria.append(oCrit);
|
---|
746 | assert self.aCriteria[self.kiErrorCounts] is oCrit;
|
---|
747 |
|
---|
748 | # Branches
|
---|
749 | oCrit = FilterCriterion('Branches', sVarNm = 'br', sType = FilterCriterion.ksType_String,
|
---|
750 | sTable = 'BuildCategories', sColumn = 'sBranch');
|
---|
751 | self.aCriteria.append(oCrit);
|
---|
752 | assert self.aCriteria[self.kiBranches] is oCrit;
|
---|
753 |
|
---|
754 | # Build types
|
---|
755 | oCrit = FilterCriterion('Build types', sVarNm = 'bt', sType = FilterCriterion.ksType_String,
|
---|
756 | sTable = 'BuildCategories', sColumn = 'sType');
|
---|
757 | self.aCriteria.append(oCrit);
|
---|
758 | assert self.aCriteria[self.kiBuildTypes] is oCrit;
|
---|
759 |
|
---|
760 | # Revisions
|
---|
761 | oCrit = FilterCriterion('Revisions', sVarNm = 'rv', sTable = 'Builds', sColumn = 'iRevision');
|
---|
762 | self.aCriteria.append(oCrit);
|
---|
763 | assert self.aCriteria[self.kiRevisions] is oCrit;
|
---|
764 |
|
---|
765 | # Failure reasons
|
---|
766 | oCrit = FilterCriterion('Failure reasons', sVarNm = 'fr', sType = FilterCriterion.ksType_UIntNil,
|
---|
767 | sTable = 'TestResultFailures', sColumn = 'idFailureReason');
|
---|
768 | self.aCriteria.append(oCrit);
|
---|
769 | assert self.aCriteria[self.kiFailReasons] is oCrit;
|
---|
770 |
|
---|
771 | # Test cases and variations.
|
---|
772 | oCrit = FilterCriterion('Test case / var', sVarNm = 'tc', sTable = 'TestSets', sColumn = 'idTestCase',
|
---|
773 | oSub = FilterCriterion('Test variations', sVarNm = 'tv',
|
---|
774 | sTable = 'TestSets', sColumn = 'idTestCaseArgs'));
|
---|
775 | self.aCriteria.append(oCrit);
|
---|
776 | assert self.aCriteria[self.kiTestCases] is oCrit;
|
---|
777 |
|
---|
778 | # Special test case and varation name sub string matching.
|
---|
779 | oCrit = FilterCriterion('Test case name', sVarNm = 'cm', sKind = FilterCriterion.ksKind_Special,
|
---|
780 | asTables = ('TestCases', 'TestCaseArgs'));
|
---|
781 | oCrit.aoPossible = [
|
---|
782 | FilterCriterionValueAndDescription(aoCur[0], 'Include %s' % (aoCur[1],)) for aoCur in self.kaTcMisc
|
---|
783 | ];
|
---|
784 | oCrit.aoPossible.extend([
|
---|
785 | FilterCriterionValueAndDescription(aoCur[0] + 32, 'Exclude %s' % (aoCur[1],)) for aoCur in self.kaTcMisc
|
---|
786 | ]);
|
---|
787 | self.aCriteria.append(oCrit);
|
---|
788 | assert self.aCriteria[self.kiTestCaseMisc] is oCrit;
|
---|
789 |
|
---|
790 | # Testboxes
|
---|
791 | oCrit = FilterCriterion('Testboxes', sVarNm = 'tb', sTable = 'TestSets', sColumn = 'idTestBox');
|
---|
792 | self.aCriteria.append(oCrit);
|
---|
793 | assert self.aCriteria[self.kiTestBoxes] is oCrit;
|
---|
794 |
|
---|
795 | # Testbox OS and OS version.
|
---|
796 | oCrit = FilterCriterion('OS / version', sVarNm = 'os', sTable = 'TestBoxesWithStrings', sColumn = 'idStrOs',
|
---|
797 | oSub = FilterCriterion('OS Versions', sVarNm = 'ov',
|
---|
798 | sTable = 'TestBoxesWithStrings', sColumn = 'idStrOsVersion'));
|
---|
799 | self.aCriteria.append(oCrit);
|
---|
800 | assert self.aCriteria[self.kiOses] is oCrit;
|
---|
801 |
|
---|
802 | # Testbox CPU architectures.
|
---|
803 | oCrit = FilterCriterion('CPU arches', sVarNm = 'ca', sTable = 'TestBoxesWithStrings', sColumn = 'idStrCpuArch');
|
---|
804 | self.aCriteria.append(oCrit);
|
---|
805 | assert self.aCriteria[self.kiCpuArches] is oCrit;
|
---|
806 |
|
---|
807 | # Testbox CPU vendors and revisions.
|
---|
808 | oCrit = FilterCriterion('CPU vendor / rev', sVarNm = 'cv', sTable = 'TestBoxesWithStrings', sColumn = 'idStrCpuVendor',
|
---|
809 | oSub = FilterCriterion('CPU revisions', sVarNm = 'cr',
|
---|
810 | sTable = 'TestBoxesWithStrings', sColumn = 'lCpuRevision'));
|
---|
811 | self.aCriteria.append(oCrit);
|
---|
812 | assert self.aCriteria[self.kiCpuVendors] is oCrit;
|
---|
813 |
|
---|
814 | # Testbox CPU (thread) count
|
---|
815 | oCrit = FilterCriterion('CPU counts', sVarNm = 'cc', sTable = 'TestBoxesWithStrings', sColumn = 'cCpus');
|
---|
816 | self.aCriteria.append(oCrit);
|
---|
817 | assert self.aCriteria[self.kiCpuCounts] is oCrit;
|
---|
818 |
|
---|
819 | # Testbox memory sizes.
|
---|
820 | oCrit = FilterCriterion('Memory', sVarNm = 'mb', sTable = 'TestBoxesWithStrings', sColumn = 'cMbMemory');
|
---|
821 | self.aCriteria.append(oCrit);
|
---|
822 | assert self.aCriteria[self.kiMemory] is oCrit;
|
---|
823 |
|
---|
824 | # Testbox features.
|
---|
825 | oCrit = FilterCriterion('Testbox features', sVarNm = 'tm', sKind = FilterCriterion.ksKind_Special,
|
---|
826 | sTable = 'TestBoxesWithStrings');
|
---|
827 | oCrit.aoPossible = [
|
---|
828 | FilterCriterionValueAndDescription(self.kiTbMisc_NestedPaging, "req nested paging"),
|
---|
829 | FilterCriterionValueAndDescription(self.kiTbMisc_NoNestedPaging, "w/o nested paging"),
|
---|
830 | #FilterCriterionValueAndDescription(self.kiTbMisc_RawMode, "req raw-mode"), - not implemented yet.
|
---|
831 | #FilterCriterionValueAndDescription(self.kiTbMisc_NoRawMode, "w/o raw-mode"), - not implemented yet.
|
---|
832 | FilterCriterionValueAndDescription(self.kiTbMisc_64BitGuest, "req 64-bit guests"),
|
---|
833 | FilterCriterionValueAndDescription(self.kiTbMisc_No64BitGuest, "w/o 64-bit guests"),
|
---|
834 | FilterCriterionValueAndDescription(self.kiTbMisc_HwVirt, "req VT-x / AMD-V"),
|
---|
835 | FilterCriterionValueAndDescription(self.kiTbMisc_NoHwVirt, "w/o VT-x / AMD-V"),
|
---|
836 | #FilterCriterionValueAndDescription(self.kiTbMisc_IoMmu, "req I/O MMU"), - not implemented yet.
|
---|
837 | #FilterCriterionValueAndDescription(self.kiTbMisc_NoIoMmu, "w/o I/O MMU"), - not implemented yet.
|
---|
838 | ];
|
---|
839 | self.aCriteria.append(oCrit);
|
---|
840 | assert self.aCriteria[self.kiTestboxMisc] is oCrit;
|
---|
841 |
|
---|
842 | # Testbox python versions.
|
---|
843 | oCrit = FilterCriterion('Python', sVarNm = 'py', sTable = 'TestBoxesWithStrings', sColumn = 'iPythonHexVersion');
|
---|
844 | self.aCriteria.append(oCrit);
|
---|
845 | assert self.aCriteria[self.kiPythonVersions] is oCrit;
|
---|
846 |
|
---|
847 | # Scheduling groups.
|
---|
848 | oCrit = FilterCriterion('Sched groups', sVarNm = 'sg', sTable = 'TestSets', sColumn = 'idSchedGroup');
|
---|
849 | self.aCriteria.append(oCrit);
|
---|
850 | assert self.aCriteria[self.kiSchedGroups] is oCrit;
|
---|
851 |
|
---|
852 |
|
---|
853 | kdTbMiscConditions = {
|
---|
854 | kiTbMisc_NestedPaging: 'TestBoxesWithStrings.fCpuNestedPaging IS TRUE',
|
---|
855 | kiTbMisc_NoNestedPaging: 'TestBoxesWithStrings.fCpuNestedPaging IS FALSE',
|
---|
856 | kiTbMisc_RawMode: 'TestBoxesWithStrings.fRawMode IS TRUE',
|
---|
857 | kiTbMisc_NoRawMode: 'TestBoxesWithStrings.fRawMode IS NOT TRUE',
|
---|
858 | kiTbMisc_64BitGuest: 'TestBoxesWithStrings.fCpu64BitGuest IS TRUE',
|
---|
859 | kiTbMisc_No64BitGuest: 'TestBoxesWithStrings.fCpu64BitGuest IS FALSE',
|
---|
860 | kiTbMisc_HwVirt: 'TestBoxesWithStrings.fCpuHwVirt IS TRUE',
|
---|
861 | kiTbMisc_NoHwVirt: 'TestBoxesWithStrings.fCpuHwVirt IS FALSE',
|
---|
862 | kiTbMisc_IoMmu: 'TestBoxesWithStrings.fChipsetIoMmu IS TRUE',
|
---|
863 | kiTbMisc_NoIoMmu: 'TestBoxesWithStrings.fChipsetIoMmu IS FALSE',
|
---|
864 | };
|
---|
865 |
|
---|
866 | def _getWhereWorker(self, iCrit, oCrit, sExtraIndent, iOmit):
|
---|
867 | """ Formats one - main or sub. """
|
---|
868 | sQuery = '';
|
---|
869 | if oCrit.sState == FilterCriterion.ksState_Selected and iCrit != iOmit:
|
---|
870 | if iCrit == self.kiTestCaseMisc:
|
---|
871 | for iValue, sLike in self.kaTcMisc:
|
---|
872 | if iValue in oCrit.aoSelected: sNot = '';
|
---|
873 | elif iValue + 32 in oCrit.aoSelected: sNot = 'NOT ';
|
---|
874 | else: continue;
|
---|
875 | sQuery += '%s AND %s (' % (sExtraIndent, sNot,);
|
---|
876 | if len(sLike) <= 3: # do word matching for small substrings (hw, np, smp, uni, ++).
|
---|
877 | sQuery += 'TestCases.sName ~ \'.*\\y%s\\y.*\' ' \
|
---|
878 | 'OR COALESCE(TestCaseArgs.sSubName, \'\') ~ \'.*\\y%s\\y.*\')\n' \
|
---|
879 | % ( sLike, sLike,);
|
---|
880 | else:
|
---|
881 | sQuery += 'TestCases.sName LIKE \'%%%s%%\' ' \
|
---|
882 | 'OR COALESCE(TestCaseArgs.sSubName, \'\') LIKE \'%%%s%%\')\n' \
|
---|
883 | % ( sLike, sLike,);
|
---|
884 | elif iCrit == self.kiTestboxMisc:
|
---|
885 | dConditions = self.kdTbMiscConditions;
|
---|
886 | for iValue in oCrit.aoSelected:
|
---|
887 | if iValue in dConditions:
|
---|
888 | sQuery += '%s AND %s\n' % (sExtraIndent, dConditions[iValue],);
|
---|
889 | else:
|
---|
890 | assert len(oCrit.asTables) == 1;
|
---|
891 | sQuery += '%s AND (' % (sExtraIndent,);
|
---|
892 |
|
---|
893 | if oCrit.sType != FilterCriterion.ksType_UIntNil or max(oCrit.aoSelected) != -1:
|
---|
894 | if iCrit == self.kiMemory:
|
---|
895 | sQuery += '(%s.%s / 1024)' % (oCrit.asTables[0], oCrit.sColumn,);
|
---|
896 | else:
|
---|
897 | sQuery += '%s.%s' % (oCrit.asTables[0], oCrit.sColumn,);
|
---|
898 | if not oCrit.fInverted:
|
---|
899 | sQuery += ' IN (';
|
---|
900 | else:
|
---|
901 | sQuery += ' NOT IN (';
|
---|
902 | if oCrit.sType == FilterCriterion.ksType_String:
|
---|
903 | sQuery += ', '.join('\'%s\'' % (sValue,) for sValue in oCrit.aoSelected) + ')';
|
---|
904 | else:
|
---|
905 | sQuery += ', '.join(str(iValue) for iValue in oCrit.aoSelected if iValue != -1) + ')';
|
---|
906 |
|
---|
907 | if oCrit.sType == FilterCriterion.ksType_UIntNil \
|
---|
908 | and -1 in oCrit.aoSelected:
|
---|
909 | if sQuery[-1] != '(': sQuery += ' OR ';
|
---|
910 | sQuery += '%s.%s IS NULL' % (oCrit.asTables[0], oCrit.sColumn,);
|
---|
911 |
|
---|
912 | if iCrit == self.kiFailReasons:
|
---|
913 | if oCrit.fInverted:
|
---|
914 | sQuery += '%s OR TestResultFailures.idFailureReason IS NULL\n' % (sExtraIndent,);
|
---|
915 | else:
|
---|
916 | sQuery += '%s AND TestSets.enmStatus >= \'failure\'::TestStatus_T\n' % (sExtraIndent,);
|
---|
917 | sQuery += ')\n';
|
---|
918 | if oCrit.oSub is not None:
|
---|
919 | sQuery += self._getWhereWorker(iCrit | (((iCrit >> 8) + 1) << 8), oCrit.oSub, sExtraIndent, iOmit);
|
---|
920 | return sQuery;
|
---|
921 |
|
---|
922 | def getWhereConditions(self, sExtraIndent = '', iOmit = -1):
|
---|
923 | """
|
---|
924 | Construct the WHERE conditions for the filter, optionally omitting one
|
---|
925 | criterion.
|
---|
926 | """
|
---|
927 | sQuery = '';
|
---|
928 | for iCrit, oCrit in enumerate(self.aCriteria):
|
---|
929 | sQuery += self._getWhereWorker(iCrit, oCrit, sExtraIndent, iOmit);
|
---|
930 | return sQuery;
|
---|
931 |
|
---|
932 | def getTableJoins(self, sExtraIndent = '', iOmit = -1, dOmitTables = None):
|
---|
933 | """
|
---|
934 | Construct the WHERE conditions for the filter, optionally omitting one
|
---|
935 | criterion.
|
---|
936 | """
|
---|
937 | afDone = { 'TestSets': True, };
|
---|
938 | if dOmitTables is not None:
|
---|
939 | afDone.update(dOmitTables);
|
---|
940 |
|
---|
941 | sQuery = '';
|
---|
942 | for iCrit, oCrit in enumerate(self.aCriteria):
|
---|
943 | if oCrit.sState == FilterCriterion.ksState_Selected \
|
---|
944 | and iCrit != iOmit:
|
---|
945 | for sTable in oCrit.asTables:
|
---|
946 | if sTable not in afDone:
|
---|
947 | afDone[sTable] = True;
|
---|
948 | if sTable == 'Builds':
|
---|
949 | sQuery += '%sINNER JOIN Builds\n' \
|
---|
950 | '%s ON Builds.idBuild = TestSets.idBuild\n' \
|
---|
951 | '%s AND Builds.tsExpire > TestSets.tsCreated\n' \
|
---|
952 | '%s AND Builds.tsEffective <= TestSets.tsCreated\n' \
|
---|
953 | % ( sExtraIndent, sExtraIndent, sExtraIndent, sExtraIndent, );
|
---|
954 | elif sTable == 'BuildCategories':
|
---|
955 | sQuery += '%sINNER JOIN BuildCategories\n' \
|
---|
956 | '%s ON BuildCategories.idBuildCategory = TestSets.idBuildCategory\n' \
|
---|
957 | % ( sExtraIndent, sExtraIndent, );
|
---|
958 | elif sTable == 'TestBoxesWithStrings':
|
---|
959 | sQuery += '%sLEFT OUTER JOIN TestBoxesWithStrings\n' \
|
---|
960 | '%s ON TestBoxesWithStrings.idGenTestBox = TestSets.idGenTestBox\n' \
|
---|
961 | % ( sExtraIndent, sExtraIndent, );
|
---|
962 | elif sTable == 'TestCases':
|
---|
963 | sQuery += '%sINNER JOIN TestCases\n' \
|
---|
964 | '%s ON TestCases.idGenTestCase = TestSets.idGenTestCase\n' \
|
---|
965 | % ( sExtraIndent, sExtraIndent, );
|
---|
966 | elif sTable == 'TestCaseArgs':
|
---|
967 | sQuery += '%sINNER JOIN TestCaseArgs\n' \
|
---|
968 | '%s ON TestCaseArgs.idGenTestCaseArgs = TestSets.idGenTestCaseArgs\n' \
|
---|
969 | % ( sExtraIndent, sExtraIndent, );
|
---|
970 | elif sTable == 'TestResults':
|
---|
971 | sQuery += '%sINNER JOIN TestResults\n' \
|
---|
972 | '%s ON TestResults.idTestResult = TestSets.idTestResult\n' \
|
---|
973 | % ( sExtraIndent, sExtraIndent, );
|
---|
974 | elif sTable == 'TestResultFailures':
|
---|
975 | sQuery += '%sLEFT OUTER JOIN TestResultFailures\n' \
|
---|
976 | '%s ON TestResultFailures.idTestSet = TestSets.idTestSet\n' \
|
---|
977 | '%s AND TestResultFailures.tsExpire = \'infinity\'::TIMESTAMP\n' \
|
---|
978 | % ( sExtraIndent, sExtraIndent, sExtraIndent, );
|
---|
979 | else:
|
---|
980 | assert False, sTable;
|
---|
981 | return sQuery;
|
---|
982 |
|
---|
983 | def isJoiningWithTable(self, sTable):
|
---|
984 | """ Checks whether getTableJoins already joins with TestResultFailures. """
|
---|
985 | for oCrit in self.aCriteria:
|
---|
986 | if oCrit.sState == FilterCriterion.ksState_Selected and sTable in oCrit.asTables:
|
---|
987 | return True;
|
---|
988 | return False
|
---|
989 |
|
---|
990 |
|
---|
991 |
|
---|
992 | class TestResultLogic(ModelLogicBase): # pylint: disable=R0903
|
---|
993 | """
|
---|
994 | Results grouped by scheduling group.
|
---|
995 | """
|
---|
996 |
|
---|
997 | #
|
---|
998 | # Result grinding for displaying in the WUI.
|
---|
999 | #
|
---|
1000 |
|
---|
1001 | ksResultsGroupingTypeNone = 'ResultsGroupingTypeNone';
|
---|
1002 | ksResultsGroupingTypeTestGroup = 'ResultsGroupingTypeTestGroup';
|
---|
1003 | ksResultsGroupingTypeBuildCat = 'ResultsGroupingTypeBuildCat';
|
---|
1004 | ksResultsGroupingTypeBuildRev = 'ResultsGroupingTypeBuildRev';
|
---|
1005 | ksResultsGroupingTypeTestBox = 'ResultsGroupingTypeTestBox';
|
---|
1006 | ksResultsGroupingTypeTestCase = 'ResultsGroupingTypeTestCase';
|
---|
1007 | ksResultsGroupingTypeOS = 'ResultsGroupingTypeOS';
|
---|
1008 | ksResultsGroupingTypeArch = 'ResultsGroupingTypeArch';
|
---|
1009 | ksResultsGroupingTypeSchedGroup = 'ResultsGroupingTypeSchedGroup';
|
---|
1010 |
|
---|
1011 | ## @name Result sorting options.
|
---|
1012 | ## @{
|
---|
1013 | ksResultsSortByRunningAndStart = 'ResultsSortByRunningAndStart'; ##< Default
|
---|
1014 | ksResultsSortByBuildRevision = 'ResultsSortByBuildRevision';
|
---|
1015 | ksResultsSortByTestBoxName = 'ResultsSortByTestBoxName';
|
---|
1016 | ksResultsSortByTestBoxOs = 'ResultsSortByTestBoxOs';
|
---|
1017 | ksResultsSortByTestBoxOsVersion = 'ResultsSortByTestBoxOsVersion';
|
---|
1018 | ksResultsSortByTestBoxOsArch = 'ResultsSortByTestBoxOsArch';
|
---|
1019 | ksResultsSortByTestBoxArch = 'ResultsSortByTestBoxArch';
|
---|
1020 | ksResultsSortByTestBoxCpuVendor = 'ResultsSortByTestBoxCpuVendor';
|
---|
1021 | ksResultsSortByTestBoxCpuName = 'ResultsSortByTestBoxCpuName';
|
---|
1022 | ksResultsSortByTestBoxCpuRev = 'ResultsSortByTestBoxCpuRev';
|
---|
1023 | ksResultsSortByTestBoxCpuFeatures = 'ResultsSortByTestBoxCpuFeatures';
|
---|
1024 | ksResultsSortByTestCaseName = 'ResultsSortByTestCaseName';
|
---|
1025 | ksResultsSortByFailureReason = 'ResultsSortByFailureReason';
|
---|
1026 | kasResultsSortBy = {
|
---|
1027 | ksResultsSortByRunningAndStart,
|
---|
1028 | ksResultsSortByBuildRevision,
|
---|
1029 | ksResultsSortByTestBoxName,
|
---|
1030 | ksResultsSortByTestBoxOs,
|
---|
1031 | ksResultsSortByTestBoxOsVersion,
|
---|
1032 | ksResultsSortByTestBoxOsArch,
|
---|
1033 | ksResultsSortByTestBoxArch,
|
---|
1034 | ksResultsSortByTestBoxCpuVendor,
|
---|
1035 | ksResultsSortByTestBoxCpuName,
|
---|
1036 | ksResultsSortByTestBoxCpuRev,
|
---|
1037 | ksResultsSortByTestBoxCpuFeatures,
|
---|
1038 | ksResultsSortByTestCaseName,
|
---|
1039 | ksResultsSortByFailureReason,
|
---|
1040 | };
|
---|
1041 | ## Used by the WUI for generating the drop down.
|
---|
1042 | kaasResultsSortByTitles = (
|
---|
1043 | ( ksResultsSortByRunningAndStart, 'Running & Start TS' ),
|
---|
1044 | ( ksResultsSortByBuildRevision, 'Build Revision' ),
|
---|
1045 | ( ksResultsSortByTestBoxName, 'TestBox Name' ),
|
---|
1046 | ( ksResultsSortByTestBoxOs, 'O/S' ),
|
---|
1047 | ( ksResultsSortByTestBoxOsVersion, 'O/S Version' ),
|
---|
1048 | ( ksResultsSortByTestBoxOsArch, 'O/S & Architecture' ),
|
---|
1049 | ( ksResultsSortByTestBoxArch, 'Architecture' ),
|
---|
1050 | ( ksResultsSortByTestBoxCpuVendor, 'CPU Vendor' ),
|
---|
1051 | ( ksResultsSortByTestBoxCpuName, 'CPU Vendor & Name' ),
|
---|
1052 | ( ksResultsSortByTestBoxCpuRev, 'CPU Vendor & Revision' ),
|
---|
1053 | ( ksResultsSortByTestBoxCpuFeatures, 'CPU Features' ),
|
---|
1054 | ( ksResultsSortByTestCaseName, 'Test Case Name' ),
|
---|
1055 | ( ksResultsSortByFailureReason, 'Failure Reason' ),
|
---|
1056 | );
|
---|
1057 | ## @}
|
---|
1058 |
|
---|
1059 | ## Default sort by map.
|
---|
1060 | kdResultSortByMap = {
|
---|
1061 | ksResultsSortByRunningAndStart: ( (), None, None, '', '' ),
|
---|
1062 | ksResultsSortByBuildRevision: (
|
---|
1063 | # Sorting tables.
|
---|
1064 | ('Builds',),
|
---|
1065 | # Sorting table join(s).
|
---|
1066 | ' AND TestSets.idBuild = Builds.idBuild'
|
---|
1067 | ' AND Builds.tsExpire >= TestSets.tsCreated'
|
---|
1068 | ' AND Builds.tsEffective <= TestSets.tsCreated',
|
---|
1069 | # Start of ORDER BY statement.
|
---|
1070 | ' Builds.iRevision DESC',
|
---|
1071 | # Extra columns to fetch for the above ORDER BY to work in a SELECT DISTINCT statement.
|
---|
1072 | '',
|
---|
1073 | # Columns for the GROUP BY
|
---|
1074 | ''),
|
---|
1075 | ksResultsSortByTestBoxName: (
|
---|
1076 | ('TestBoxes',),
|
---|
1077 | ' AND TestSets.idGenTestBox = TestBoxes.idGenTestBox',
|
---|
1078 | ' TestBoxes.sName DESC',
|
---|
1079 | '', '' ),
|
---|
1080 | ksResultsSortByTestBoxOsArch: (
|
---|
1081 | ('TestBoxesWithStrings',),
|
---|
1082 | ' AND TestSets.idGenTestBox = TestBoxesWithStrings.idGenTestBox',
|
---|
1083 | ' TestBoxesWithStrings.sOs, TestBoxesWithStrings.sCpuArch',
|
---|
1084 | '', '' ),
|
---|
1085 | ksResultsSortByTestBoxOs: (
|
---|
1086 | ('TestBoxesWithStrings',),
|
---|
1087 | ' AND TestSets.idGenTestBox = TestBoxesWithStrings.idGenTestBox',
|
---|
1088 | ' TestBoxesWithStrings.sOs',
|
---|
1089 | '', '' ),
|
---|
1090 | ksResultsSortByTestBoxOsVersion: (
|
---|
1091 | ('TestBoxesWithStrings',),
|
---|
1092 | ' AND TestSets.idGenTestBox = TestBoxesWithStrings.idGenTestBox',
|
---|
1093 | ' TestBoxesWithStrings.sOs, TestBoxesWithStrings.sOsVersion DESC',
|
---|
1094 | '', '' ),
|
---|
1095 | ksResultsSortByTestBoxArch: (
|
---|
1096 | ('TestBoxesWithStrings',),
|
---|
1097 | ' AND TestSets.idGenTestBox = TestBoxesWithStrings.idGenTestBox',
|
---|
1098 | ' TestBoxesWithStrings.sCpuArch',
|
---|
1099 | '', '' ),
|
---|
1100 | ksResultsSortByTestBoxCpuVendor: (
|
---|
1101 | ('TestBoxesWithStrings',),
|
---|
1102 | ' AND TestSets.idGenTestBox = TestBoxesWithStrings.idGenTestBox',
|
---|
1103 | ' TestBoxesWithStrings.sCpuVendor',
|
---|
1104 | '', '' ),
|
---|
1105 | ksResultsSortByTestBoxCpuName: (
|
---|
1106 | ('TestBoxesWithStrings',),
|
---|
1107 | ' AND TestSets.idGenTestBox = TestBoxesWithStrings.idGenTestBox',
|
---|
1108 | ' TestBoxesWithStrings.sCpuVendor, TestBoxesWithStrings.sCpuName',
|
---|
1109 | '', '' ),
|
---|
1110 | ksResultsSortByTestBoxCpuRev: (
|
---|
1111 | ('TestBoxesWithStrings',),
|
---|
1112 | ' AND TestSets.idGenTestBox = TestBoxesWithStrings.idGenTestBox',
|
---|
1113 | ' TestBoxesWithStrings.sCpuVendor, TestBoxesWithStrings.lCpuRevision DESC',
|
---|
1114 | ', TestBoxesWithStrings.lCpuRevision',
|
---|
1115 | ', TestBoxesWithStrings.lCpuRevision' ),
|
---|
1116 | ksResultsSortByTestBoxCpuFeatures: (
|
---|
1117 | ('TestBoxes',),
|
---|
1118 | ' AND TestSets.idGenTestBox = TestBoxes.idGenTestBox',
|
---|
1119 | ' TestBoxes.fCpuHwVirt DESC, TestBoxes.fCpuNestedPaging DESC, TestBoxes.fCpu64BitGuest DESC, TestBoxes.cCpus DESC',
|
---|
1120 | '',
|
---|
1121 | '' ),
|
---|
1122 | ksResultsSortByTestCaseName: (
|
---|
1123 | ('TestCases',),
|
---|
1124 | ' AND TestSets.idGenTestCase = TestCases.idGenTestCase',
|
---|
1125 | ' TestCases.sName',
|
---|
1126 | '', '' ),
|
---|
1127 | ksResultsSortByFailureReason: (
|
---|
1128 | (), '',
|
---|
1129 | 'asSortByFailureReason ASC',
|
---|
1130 | ', array_agg(FailureReasons.sShort ORDER BY TestResultFailures.idTestResult) AS asSortByFailureReason',
|
---|
1131 | '' ),
|
---|
1132 | };
|
---|
1133 |
|
---|
1134 | kdResultGroupingMap = {
|
---|
1135 | ksResultsGroupingTypeNone: (
|
---|
1136 | # Grouping tables;
|
---|
1137 | (),
|
---|
1138 | # Grouping field;
|
---|
1139 | None,
|
---|
1140 | # Grouping where addition.
|
---|
1141 | None,
|
---|
1142 | # Sort by overrides.
|
---|
1143 | {},
|
---|
1144 | ),
|
---|
1145 | ksResultsGroupingTypeTestGroup: ('', 'TestSets.idTestGroup', None, {},),
|
---|
1146 | ksResultsGroupingTypeTestBox: ('', 'TestSets.idTestBox', None, {},),
|
---|
1147 | ksResultsGroupingTypeTestCase: ('', 'TestSets.idTestCase', None, {},),
|
---|
1148 | ksResultsGroupingTypeOS: (
|
---|
1149 | ('TestBoxes',),
|
---|
1150 | 'TestBoxes.idStrOs',
|
---|
1151 | ' AND TestBoxes.idGenTestBox = TestSets.idGenTestBox',
|
---|
1152 | {},
|
---|
1153 | ),
|
---|
1154 | ksResultsGroupingTypeArch: (
|
---|
1155 | ('TestBoxes',),
|
---|
1156 | 'TestBoxes.idStrCpuArch',
|
---|
1157 | ' AND TestBoxes.idGenTestBox = TestSets.idGenTestBox',
|
---|
1158 | {},
|
---|
1159 | ),
|
---|
1160 | ksResultsGroupingTypeBuildCat: ('', 'TestSets.idBuildCategory', None, {},),
|
---|
1161 | ksResultsGroupingTypeBuildRev: (
|
---|
1162 | ('Builds',),
|
---|
1163 | 'Builds.iRevision',
|
---|
1164 | ' AND Builds.idBuild = TestSets.idBuild'
|
---|
1165 | ' AND Builds.tsExpire > TestSets.tsCreated'
|
---|
1166 | ' AND Builds.tsEffective <= TestSets.tsCreated',
|
---|
1167 | { ksResultsSortByBuildRevision: ( (), None, ' Builds.iRevision DESC' ), }
|
---|
1168 | ),
|
---|
1169 | ksResultsGroupingTypeSchedGroup: ( '', 'TestSets.idSchedGroup', None, {},),
|
---|
1170 | };
|
---|
1171 |
|
---|
1172 |
|
---|
1173 | def __init__(self, oDb):
|
---|
1174 | ModelLogicBase.__init__(self, oDb)
|
---|
1175 | self.oFailureReasonLogic = None;
|
---|
1176 | self.oUserAccountLogic = None;
|
---|
1177 |
|
---|
1178 | def _getTimePeriodQueryPart(self, tsNow, sInterval, sExtraIndent = ''):
|
---|
1179 | """
|
---|
1180 | Get part of SQL query responsible for SELECT data within
|
---|
1181 | specified period of time.
|
---|
1182 | """
|
---|
1183 | assert sInterval is not None; # too many rows.
|
---|
1184 |
|
---|
1185 | cMonthsMourningPeriod = 2; # Stop reminding everyone about testboxes after 2 months. (May also speed up the query.)
|
---|
1186 | if tsNow is None:
|
---|
1187 | sRet = '(TestSets.tsDone IS NULL OR TestSets.tsDone >= (CURRENT_TIMESTAMP - \'%s\'::interval))\n' \
|
---|
1188 | '%s AND TestSets.tsCreated >= (CURRENT_TIMESTAMP - \'%s\'::interval - \'%u months\'::interval)\n' \
|
---|
1189 | % ( sInterval,
|
---|
1190 | sExtraIndent, sInterval, cMonthsMourningPeriod);
|
---|
1191 | else:
|
---|
1192 | sTsNow = '\'%s\'::TIMESTAMP' % (tsNow,); # It's actually a string already. duh.
|
---|
1193 | sRet = 'TestSets.tsCreated <= %s\n' \
|
---|
1194 | '%s AND TestSets.tsCreated >= (%s - \'%s\'::interval - \'%u months\'::interval)\n' \
|
---|
1195 | '%s AND (TestSets.tsDone IS NULL OR TestSets.tsDone >= (%s - \'%s\'::interval))\n' \
|
---|
1196 | % ( sTsNow,
|
---|
1197 | sExtraIndent, sTsNow, sInterval, cMonthsMourningPeriod,
|
---|
1198 | sExtraIndent, sTsNow, sInterval );
|
---|
1199 | return sRet
|
---|
1200 |
|
---|
1201 | def fetchResultsForListing(self, iStart, cMaxRows, tsNow, sInterval, oFilter, enmResultSortBy, # pylint: disable=R0913
|
---|
1202 | enmResultsGroupingType, iResultsGroupingValue, fOnlyFailures, fOnlyNeedingReason):
|
---|
1203 | """
|
---|
1204 | Fetches TestResults table content.
|
---|
1205 |
|
---|
1206 | If @param enmResultsGroupingType and @param iResultsGroupingValue
|
---|
1207 | are not None, then resulting (returned) list contains only records
|
---|
1208 | that match specified @param enmResultsGroupingType.
|
---|
1209 |
|
---|
1210 | If @param enmResultsGroupingType is None, then
|
---|
1211 | @param iResultsGroupingValue is ignored.
|
---|
1212 |
|
---|
1213 | Returns an array (list) of TestResultData items, empty list if none.
|
---|
1214 | Raises exception on error.
|
---|
1215 | """
|
---|
1216 |
|
---|
1217 | _ = oFilter;
|
---|
1218 |
|
---|
1219 | #
|
---|
1220 | # Get SQL query parameters
|
---|
1221 | #
|
---|
1222 | if enmResultsGroupingType is None or enmResultsGroupingType not in self.kdResultGroupingMap:
|
---|
1223 | raise TMExceptionBase('Unknown grouping type');
|
---|
1224 | if enmResultSortBy is None or enmResultSortBy not in self.kasResultsSortBy:
|
---|
1225 | raise TMExceptionBase('Unknown sorting');
|
---|
1226 | asGroupingTables, sGroupingField, sGroupingCondition, dSortOverrides = self.kdResultGroupingMap[enmResultsGroupingType];
|
---|
1227 | if enmResultSortBy in dSortOverrides:
|
---|
1228 | asSortTables, sSortWhere, sSortOrderBy, sSortColumns, sSortGroupBy = dSortOverrides[enmResultSortBy];
|
---|
1229 | else:
|
---|
1230 | asSortTables, sSortWhere, sSortOrderBy, sSortColumns, sSortGroupBy = self.kdResultSortByMap[enmResultSortBy];
|
---|
1231 |
|
---|
1232 | #
|
---|
1233 | # Construct the query.
|
---|
1234 | #
|
---|
1235 | sQuery = 'SELECT DISTINCT TestSets.idTestSet,\n' \
|
---|
1236 | ' BuildCategories.idBuildCategory,\n' \
|
---|
1237 | ' BuildCategories.sProduct,\n' \
|
---|
1238 | ' BuildCategories.sRepository,\n' \
|
---|
1239 | ' BuildCategories.sBranch,\n' \
|
---|
1240 | ' BuildCategories.sType,\n' \
|
---|
1241 | ' Builds.idBuild,\n' \
|
---|
1242 | ' Builds.sVersion,\n' \
|
---|
1243 | ' Builds.iRevision,\n' \
|
---|
1244 | ' TestBoxesWithStrings.sOs,\n' \
|
---|
1245 | ' TestBoxesWithStrings.sOsVersion,\n' \
|
---|
1246 | ' TestBoxesWithStrings.sCpuArch,\n' \
|
---|
1247 | ' TestBoxesWithStrings.sCpuVendor,\n' \
|
---|
1248 | ' TestBoxesWithStrings.sCpuName,\n' \
|
---|
1249 | ' TestBoxesWithStrings.cCpus,\n' \
|
---|
1250 | ' TestBoxesWithStrings.fCpuHwVirt,\n' \
|
---|
1251 | ' TestBoxesWithStrings.fCpuNestedPaging,\n' \
|
---|
1252 | ' TestBoxesWithStrings.fCpu64BitGuest,\n' \
|
---|
1253 | ' TestBoxesWithStrings.idTestBox,\n' \
|
---|
1254 | ' TestBoxesWithStrings.sName,\n' \
|
---|
1255 | ' TestResults.tsCreated,\n' \
|
---|
1256 | ' COALESCE(TestResults.tsElapsed, CURRENT_TIMESTAMP - TestResults.tsCreated) AS tsElapsedTestResult,\n' \
|
---|
1257 | ' TestSets.enmStatus,\n' \
|
---|
1258 | ' TestResults.cErrors,\n' \
|
---|
1259 | ' TestCases.idTestCase,\n' \
|
---|
1260 | ' TestCases.sName,\n' \
|
---|
1261 | ' TestCases.sBaseCmd,\n' \
|
---|
1262 | ' TestCaseArgs.sArgs,\n' \
|
---|
1263 | ' TestCaseArgs.sSubName,\n' \
|
---|
1264 | ' TestSuiteBits.idBuild AS idBuildTestSuite,\n' \
|
---|
1265 | ' TestSuiteBits.iRevision AS iRevisionTestSuite,\n' \
|
---|
1266 | ' array_agg(TestResultFailures.idFailureReason ORDER BY TestResultFailures.idTestResult),\n' \
|
---|
1267 | ' array_agg(TestResultFailures.uidAuthor ORDER BY TestResultFailures.idTestResult),\n' \
|
---|
1268 | ' array_agg(TestResultFailures.tsEffective ORDER BY TestResultFailures.idTestResult),\n' \
|
---|
1269 | ' array_agg(TestResultFailures.sComment ORDER BY TestResultFailures.idTestResult),\n' \
|
---|
1270 | ' (TestSets.tsDone IS NULL) SortRunningFirst' + sSortColumns + '\n' \
|
---|
1271 | 'FROM ( SELECT TestSets.idTestSet AS idTestSet,\n' \
|
---|
1272 | ' TestSets.tsDone AS tsDone,\n' \
|
---|
1273 | ' TestSets.tsCreated AS tsCreated,\n' \
|
---|
1274 | ' TestSets.enmStatus AS enmStatus,\n' \
|
---|
1275 | ' TestSets.idBuild AS idBuild,\n' \
|
---|
1276 | ' TestSets.idBuildTestSuite AS idBuildTestSuite,\n' \
|
---|
1277 | ' TestSets.idGenTestBox AS idGenTestBox,\n' \
|
---|
1278 | ' TestSets.idGenTestCase AS idGenTestCase,\n' \
|
---|
1279 | ' TestSets.idGenTestCaseArgs AS idGenTestCaseArgs\n' \
|
---|
1280 | ' FROM TestSets\n';
|
---|
1281 | sQuery += oFilter.getTableJoins(' ');
|
---|
1282 | if fOnlyNeedingReason and not oFilter.isJoiningWithTable('TestResultFailures'):
|
---|
1283 | sQuery += '\n' \
|
---|
1284 | ' LEFT OUTER JOIN TestResultFailures\n' \
|
---|
1285 | ' ON TestSets.idTestSet = TestResultFailures.idTestSet\n' \
|
---|
1286 | ' AND TestResultFailures.tsExpire = \'infinity\'::TIMESTAMP';
|
---|
1287 | for asTables in [asGroupingTables, asSortTables]:
|
---|
1288 | for sTable in asTables:
|
---|
1289 | if not oFilter.isJoiningWithTable(sTable):
|
---|
1290 | sQuery = sQuery[:-1] + ',\n ' + sTable + '\n';
|
---|
1291 |
|
---|
1292 | sQuery += ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sInterval, ' ') + \
|
---|
1293 | oFilter.getWhereConditions(' ');
|
---|
1294 | if fOnlyFailures or fOnlyNeedingReason:
|
---|
1295 | sQuery += ' AND TestSets.enmStatus != \'success\'::TestStatus_T\n' \
|
---|
1296 | ' AND TestSets.enmStatus != \'running\'::TestStatus_T\n';
|
---|
1297 | if fOnlyNeedingReason:
|
---|
1298 | sQuery += ' AND TestResultFailures.idTestSet IS NULL\n';
|
---|
1299 | if sGroupingField is not None:
|
---|
1300 | sQuery += ' AND %s = %d\n' % (sGroupingField, iResultsGroupingValue,);
|
---|
1301 | if sGroupingCondition is not None:
|
---|
1302 | sQuery += sGroupingCondition.replace(' AND ', ' AND ');
|
---|
1303 | if sSortWhere is not None:
|
---|
1304 | sQuery += sSortWhere.replace(' AND ', ' AND ');
|
---|
1305 | sQuery += ' ORDER BY ';
|
---|
1306 | if sSortOrderBy is not None and sSortOrderBy.find('FailureReason') < 0:
|
---|
1307 | sQuery += sSortOrderBy + ',\n ';
|
---|
1308 | sQuery += '(TestSets.tsDone IS NULL) DESC, TestSets.idTestSet DESC\n' \
|
---|
1309 | ' LIMIT %s OFFSET %s\n' % (cMaxRows, iStart,);
|
---|
1310 |
|
---|
1311 | # Note! INNER JOIN TestBoxesWithStrings performs miserable compared to LEFT OUTER JOIN. Doesn't matter for the result
|
---|
1312 | # because TestSets.idGenTestBox is a foreign key and unique in TestBoxes. So, let's do what ever is faster.
|
---|
1313 | sQuery += ' ) AS TestSets\n' \
|
---|
1314 | ' LEFT OUTER JOIN TestBoxesWithStrings\n' \
|
---|
1315 | ' ON TestSets.idGenTestBox = TestBoxesWithStrings.idGenTestBox' \
|
---|
1316 | ' LEFT OUTER JOIN Builds AS TestSuiteBits\n' \
|
---|
1317 | ' ON TestSets.idBuildTestSuite = TestSuiteBits.idBuild\n' \
|
---|
1318 | ' LEFT OUTER JOIN TestResultFailures\n' \
|
---|
1319 | ' ON TestSets.idTestSet = TestResultFailures.idTestSet\n' \
|
---|
1320 | ' AND TestResultFailures.tsExpire = \'infinity\'::TIMESTAMP';
|
---|
1321 | if sSortOrderBy is not None and sSortOrderBy.find('FailureReason') >= 0:
|
---|
1322 | sQuery += '\n' \
|
---|
1323 | ' LEFT OUTER JOIN FailureReasons\n' \
|
---|
1324 | ' ON TestResultFailures.idFailureReason = FailureReasons.idFailureReason\n' \
|
---|
1325 | ' AND FailureReasons.tsExpire = \'infinity\'::TIMESTAMP';
|
---|
1326 | sQuery += ',\n' \
|
---|
1327 | ' BuildCategories,\n' \
|
---|
1328 | ' Builds,\n' \
|
---|
1329 | ' TestResults,\n' \
|
---|
1330 | ' TestCases,\n' \
|
---|
1331 | ' TestCaseArgs\n';
|
---|
1332 | sQuery += 'WHERE TestSets.idTestSet = TestResults.idTestSet\n' \
|
---|
1333 | ' AND TestResults.idTestResultParent is NULL\n' \
|
---|
1334 | ' AND TestSets.idBuild = Builds.idBuild\n' \
|
---|
1335 | ' AND Builds.tsExpire > TestSets.tsCreated\n' \
|
---|
1336 | ' AND Builds.tsEffective <= TestSets.tsCreated\n' \
|
---|
1337 | ' AND Builds.idBuildCategory = BuildCategories.idBuildCategory\n' \
|
---|
1338 | ' AND TestSets.idGenTestCase = TestCases.idGenTestCase\n' \
|
---|
1339 | ' AND TestSets.idGenTestCaseArgs = TestCaseArgs.idGenTestCaseArgs\n';
|
---|
1340 | sQuery += 'GROUP BY TestSets.idTestSet,\n' \
|
---|
1341 | ' BuildCategories.idBuildCategory,\n' \
|
---|
1342 | ' BuildCategories.sProduct,\n' \
|
---|
1343 | ' BuildCategories.sRepository,\n' \
|
---|
1344 | ' BuildCategories.sBranch,\n' \
|
---|
1345 | ' BuildCategories.sType,\n' \
|
---|
1346 | ' Builds.idBuild,\n' \
|
---|
1347 | ' Builds.sVersion,\n' \
|
---|
1348 | ' Builds.iRevision,\n' \
|
---|
1349 | ' TestBoxesWithStrings.sOs,\n' \
|
---|
1350 | ' TestBoxesWithStrings.sOsVersion,\n' \
|
---|
1351 | ' TestBoxesWithStrings.sCpuArch,\n' \
|
---|
1352 | ' TestBoxesWithStrings.sCpuVendor,\n' \
|
---|
1353 | ' TestBoxesWithStrings.sCpuName,\n' \
|
---|
1354 | ' TestBoxesWithStrings.cCpus,\n' \
|
---|
1355 | ' TestBoxesWithStrings.fCpuHwVirt,\n' \
|
---|
1356 | ' TestBoxesWithStrings.fCpuNestedPaging,\n' \
|
---|
1357 | ' TestBoxesWithStrings.fCpu64BitGuest,\n' \
|
---|
1358 | ' TestBoxesWithStrings.idTestBox,\n' \
|
---|
1359 | ' TestBoxesWithStrings.sName,\n' \
|
---|
1360 | ' TestResults.tsCreated,\n' \
|
---|
1361 | ' tsElapsedTestResult,\n' \
|
---|
1362 | ' TestSets.enmStatus,\n' \
|
---|
1363 | ' TestResults.cErrors,\n' \
|
---|
1364 | ' TestCases.idTestCase,\n' \
|
---|
1365 | ' TestCases.sName,\n' \
|
---|
1366 | ' TestCases.sBaseCmd,\n' \
|
---|
1367 | ' TestCaseArgs.sArgs,\n' \
|
---|
1368 | ' TestCaseArgs.sSubName,\n' \
|
---|
1369 | ' TestSuiteBits.idBuild,\n' \
|
---|
1370 | ' TestSuiteBits.iRevision,\n' \
|
---|
1371 | ' SortRunningFirst' + sSortGroupBy + '\n';
|
---|
1372 | sQuery += 'ORDER BY ';
|
---|
1373 | if sSortOrderBy is not None:
|
---|
1374 | sQuery += sSortOrderBy.replace('TestBoxes.', 'TestBoxesWithStrings.') + ',\n ';
|
---|
1375 | sQuery += '(TestSets.tsDone IS NULL) DESC, TestSets.idTestSet DESC\n';
|
---|
1376 |
|
---|
1377 | #
|
---|
1378 | # Execute the query and return the wrapped results.
|
---|
1379 | #
|
---|
1380 | self._oDb.execute(sQuery);
|
---|
1381 |
|
---|
1382 | if self.oFailureReasonLogic is None:
|
---|
1383 | self.oFailureReasonLogic = FailureReasonLogic(self._oDb);
|
---|
1384 | if self.oUserAccountLogic is None:
|
---|
1385 | self.oUserAccountLogic = UserAccountLogic(self._oDb);
|
---|
1386 |
|
---|
1387 | aoRows = [];
|
---|
1388 | for aoRow in self._oDb.fetchAll():
|
---|
1389 | aoRows.append(TestResultListingData().initFromDbRowEx(aoRow, self.oFailureReasonLogic, self.oUserAccountLogic));
|
---|
1390 |
|
---|
1391 | return aoRows
|
---|
1392 |
|
---|
1393 |
|
---|
1394 | def fetchTimestampsForLogViewer(self, idTestSet):
|
---|
1395 | """
|
---|
1396 | Returns an ordered list with all the test result timestamps, both start
|
---|
1397 | and end.
|
---|
1398 |
|
---|
1399 | The log viewer create anchors in the log text so we can jump directly to
|
---|
1400 | the log lines relevant for a test event.
|
---|
1401 | """
|
---|
1402 | self._oDb.execute('(\n'
|
---|
1403 | 'SELECT tsCreated\n'
|
---|
1404 | 'FROM TestResults\n'
|
---|
1405 | 'WHERE idTestSet = %s\n'
|
---|
1406 | ') UNION (\n'
|
---|
1407 | 'SELECT tsCreated + tsElapsed\n'
|
---|
1408 | 'FROM TestResults\n'
|
---|
1409 | 'WHERE idTestSet = %s\n'
|
---|
1410 | ' AND tsElapsed IS NOT NULL\n'
|
---|
1411 | ') UNION (\n'
|
---|
1412 | 'SELECT TestResultFiles.tsCreated\n'
|
---|
1413 | 'FROM TestResultFiles\n'
|
---|
1414 | 'WHERE idTestSet = %s\n'
|
---|
1415 | ') UNION (\n'
|
---|
1416 | 'SELECT tsCreated\n'
|
---|
1417 | 'FROM TestResultValues\n'
|
---|
1418 | 'WHERE idTestSet = %s\n'
|
---|
1419 | ') UNION (\n'
|
---|
1420 | 'SELECT TestResultMsgs.tsCreated\n'
|
---|
1421 | 'FROM TestResultMsgs\n'
|
---|
1422 | 'WHERE idTestSet = %s\n'
|
---|
1423 | ') ORDER by 1'
|
---|
1424 | , ( idTestSet, idTestSet, idTestSet, idTestSet, idTestSet, ));
|
---|
1425 | return [aoRow[0] for aoRow in self._oDb.fetchAll()];
|
---|
1426 |
|
---|
1427 |
|
---|
1428 | def getEntriesCount(self, tsNow, sInterval, oFilter, enmResultsGroupingType, iResultsGroupingValue,
|
---|
1429 | fOnlyFailures, fOnlyNeedingReason):
|
---|
1430 | """
|
---|
1431 | Get number of table records.
|
---|
1432 |
|
---|
1433 | If @param enmResultsGroupingType and @param iResultsGroupingValue
|
---|
1434 | are not None, then we count only only those records
|
---|
1435 | that match specified @param enmResultsGroupingType.
|
---|
1436 |
|
---|
1437 | If @param enmResultsGroupingType is None, then
|
---|
1438 | @param iResultsGroupingValue is ignored.
|
---|
1439 | """
|
---|
1440 | _ = oFilter;
|
---|
1441 |
|
---|
1442 | #
|
---|
1443 | # Get SQL query parameters
|
---|
1444 | #
|
---|
1445 | if enmResultsGroupingType is None:
|
---|
1446 | raise TMExceptionBase('Unknown grouping type')
|
---|
1447 |
|
---|
1448 | if enmResultsGroupingType not in self.kdResultGroupingMap:
|
---|
1449 | raise TMExceptionBase('Unknown grouping type')
|
---|
1450 | asGroupingTables, sGroupingField, sGroupingCondition, _ = self.kdResultGroupingMap[enmResultsGroupingType];
|
---|
1451 |
|
---|
1452 | #
|
---|
1453 | # Construct the query.
|
---|
1454 | #
|
---|
1455 | sQuery = 'SELECT COUNT(TestSets.idTestSet)\n' \
|
---|
1456 | 'FROM TestSets\n';
|
---|
1457 | sQuery += oFilter.getTableJoins();
|
---|
1458 | if fOnlyNeedingReason and not oFilter.isJoiningWithTable('TestResultFailures'):
|
---|
1459 | sQuery += ' LEFT OUTER JOIN TestResultFailures\n' \
|
---|
1460 | ' ON TestSets.idTestSet = TestResultFailures.idTestSet\n' \
|
---|
1461 | ' AND TestResultFailures.tsExpire = \'infinity\'::TIMESTAMP\n';
|
---|
1462 | for sTable in asGroupingTables:
|
---|
1463 | if not oFilter.isJoiningWithTable(sTable):
|
---|
1464 | sQuery = sQuery[:-1] + ',\n ' + sTable + '\n';
|
---|
1465 | sQuery += 'WHERE ' + self._getTimePeriodQueryPart(tsNow, sInterval) + \
|
---|
1466 | oFilter.getWhereConditions();
|
---|
1467 | if fOnlyFailures or fOnlyNeedingReason:
|
---|
1468 | sQuery += ' AND TestSets.enmStatus != \'success\'::TestStatus_T\n' \
|
---|
1469 | ' AND TestSets.enmStatus != \'running\'::TestStatus_T\n';
|
---|
1470 | if fOnlyNeedingReason:
|
---|
1471 | sQuery += ' AND TestResultFailures.idTestSet IS NULL\n';
|
---|
1472 | if sGroupingField is not None:
|
---|
1473 | sQuery += ' AND %s = %d\n' % (sGroupingField, iResultsGroupingValue,);
|
---|
1474 | if sGroupingCondition is not None:
|
---|
1475 | sQuery += sGroupingCondition.replace(' AND ', ' AND ');
|
---|
1476 |
|
---|
1477 | #
|
---|
1478 | # Execute the query and return the result.
|
---|
1479 | #
|
---|
1480 | self._oDb.execute(sQuery)
|
---|
1481 | return self._oDb.fetchOne()[0]
|
---|
1482 |
|
---|
1483 | def getTestGroups(self, tsNow, sPeriod):
|
---|
1484 | """
|
---|
1485 | Get list of uniq TestGroupData objects which
|
---|
1486 | found in all test results.
|
---|
1487 | """
|
---|
1488 |
|
---|
1489 | self._oDb.execute('SELECT DISTINCT TestGroups.*\n'
|
---|
1490 | 'FROM TestGroups, TestSets\n'
|
---|
1491 | 'WHERE TestSets.idTestGroup = TestGroups.idTestGroup\n'
|
---|
1492 | ' AND TestGroups.tsExpire > TestSets.tsCreated\n'
|
---|
1493 | ' AND TestGroups.tsEffective <= TestSets.tsCreated'
|
---|
1494 | ' AND ' + self._getTimePeriodQueryPart(tsNow, sPeriod))
|
---|
1495 | aaoRows = self._oDb.fetchAll()
|
---|
1496 | aoRet = []
|
---|
1497 | for aoRow in aaoRows:
|
---|
1498 | aoRet.append(TestGroupData().initFromDbRow(aoRow))
|
---|
1499 | return aoRet
|
---|
1500 |
|
---|
1501 | def getBuilds(self, tsNow, sPeriod):
|
---|
1502 | """
|
---|
1503 | Get list of uniq BuildDataEx objects which
|
---|
1504 | found in all test results.
|
---|
1505 | """
|
---|
1506 |
|
---|
1507 | self._oDb.execute('SELECT DISTINCT Builds.*, BuildCategories.*\n'
|
---|
1508 | 'FROM Builds, BuildCategories, TestSets\n'
|
---|
1509 | 'WHERE TestSets.idBuild = Builds.idBuild\n'
|
---|
1510 | ' AND Builds.idBuildCategory = BuildCategories.idBuildCategory\n'
|
---|
1511 | ' AND Builds.tsExpire > TestSets.tsCreated\n'
|
---|
1512 | ' AND Builds.tsEffective <= TestSets.tsCreated'
|
---|
1513 | ' AND ' + self._getTimePeriodQueryPart(tsNow, sPeriod))
|
---|
1514 | aaoRows = self._oDb.fetchAll()
|
---|
1515 | aoRet = []
|
---|
1516 | for aoRow in aaoRows:
|
---|
1517 | aoRet.append(BuildDataEx().initFromDbRow(aoRow))
|
---|
1518 | return aoRet
|
---|
1519 |
|
---|
1520 | def getTestBoxes(self, tsNow, sPeriod):
|
---|
1521 | """
|
---|
1522 | Get list of uniq TestBoxData objects which
|
---|
1523 | found in all test results.
|
---|
1524 | """
|
---|
1525 | # Note! INNER JOIN TestBoxesWithStrings performs miserable compared to LEFT OUTER JOIN. Doesn't matter for the result
|
---|
1526 | # because TestSets.idGenTestBox is a foreign key and unique in TestBoxes. So, let's do what ever is faster.
|
---|
1527 | self._oDb.execute('SELECT TestBoxesWithStrings.*\n'
|
---|
1528 | 'FROM ( SELECT idTestBox AS idTestBox,\n'
|
---|
1529 | ' MAX(idGenTestBox) AS idGenTestBox\n'
|
---|
1530 | ' FROM TestSets\n'
|
---|
1531 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1532 | ' GROUP BY idTestBox\n'
|
---|
1533 | ' ) AS TestBoxIDs\n'
|
---|
1534 | ' LEFT OUTER JOIN TestBoxesWithStrings\n'
|
---|
1535 | ' ON TestBoxesWithStrings.idGenTestBox = TestBoxIDs.idGenTestBox\n'
|
---|
1536 | 'ORDER BY TestBoxesWithStrings.sName\n' );
|
---|
1537 | aoRet = []
|
---|
1538 | for aoRow in self._oDb.fetchAll():
|
---|
1539 | aoRet.append(TestBoxData().initFromDbRow(aoRow));
|
---|
1540 | return aoRet
|
---|
1541 |
|
---|
1542 | def getTestCases(self, tsNow, sPeriod):
|
---|
1543 | """
|
---|
1544 | Get a list of unique TestCaseData objects which is appears in the test
|
---|
1545 | specified result period.
|
---|
1546 | """
|
---|
1547 |
|
---|
1548 | # Using LEFT OUTER JOIN instead of INNER JOIN in case it performs better, doesn't matter for the result.
|
---|
1549 | self._oDb.execute('SELECT TestCases.*\n'
|
---|
1550 | 'FROM ( SELECT idTestCase AS idTestCase,\n'
|
---|
1551 | ' MAX(idGenTestCase) AS idGenTestCase\n'
|
---|
1552 | ' FROM TestSets\n'
|
---|
1553 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1554 | ' GROUP BY idTestCase\n'
|
---|
1555 | ' ) AS TestCasesIDs\n'
|
---|
1556 | ' LEFT OUTER JOIN TestCases ON TestCases.idGenTestCase = TestCasesIDs.idGenTestCase\n'
|
---|
1557 | 'ORDER BY TestCases.sName\n' );
|
---|
1558 |
|
---|
1559 | aoRet = [];
|
---|
1560 | for aoRow in self._oDb.fetchAll():
|
---|
1561 | aoRet.append(TestCaseData().initFromDbRow(aoRow));
|
---|
1562 | return aoRet
|
---|
1563 |
|
---|
1564 | def getOSes(self, tsNow, sPeriod):
|
---|
1565 | """
|
---|
1566 | Get a list of [idStrOs, sOs] tuples of the OSes that appears in the specified result period.
|
---|
1567 | """
|
---|
1568 |
|
---|
1569 | # Note! INNER JOIN TestBoxesWithStrings performs miserable compared to LEFT OUTER JOIN. Doesn't matter for the result
|
---|
1570 | # because TestSets.idGenTestBox is a foreign key and unique in TestBoxes. So, let's do what ever is faster.
|
---|
1571 | self._oDb.execute('SELECT DISTINCT TestBoxesWithStrings.idStrOs, TestBoxesWithStrings.sOs\n'
|
---|
1572 | 'FROM ( SELECT idTestBox AS idTestBox,\n'
|
---|
1573 | ' MAX(idGenTestBox) AS idGenTestBox\n'
|
---|
1574 | ' FROM TestSets\n'
|
---|
1575 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1576 | ' GROUP BY idTestBox\n'
|
---|
1577 | ' ) AS TestBoxIDs\n'
|
---|
1578 | ' LEFT OUTER JOIN TestBoxesWithStrings\n'
|
---|
1579 | ' ON TestBoxesWithStrings.idGenTestBox = TestBoxIDs.idGenTestBox\n'
|
---|
1580 | 'ORDER BY TestBoxesWithStrings.sOs\n' );
|
---|
1581 | return self._oDb.fetchAll();
|
---|
1582 |
|
---|
1583 | def getArchitectures(self, tsNow, sPeriod):
|
---|
1584 | """
|
---|
1585 | Get a list of [idStrCpuArch, sCpuArch] tuples of the architecutres
|
---|
1586 | that appears in the specified result period.
|
---|
1587 | """
|
---|
1588 |
|
---|
1589 | # Note! INNER JOIN TestBoxesWithStrings performs miserable compared to LEFT OUTER JOIN. Doesn't matter for the result
|
---|
1590 | # because TestSets.idGenTestBox is a foreign key and unique in TestBoxes. So, let's do what ever is faster.
|
---|
1591 | self._oDb.execute('SELECT DISTINCT TestBoxesWithStrings.idStrCpuArch, TestBoxesWithStrings.sCpuArch\n'
|
---|
1592 | 'FROM ( SELECT idTestBox AS idTestBox,\n'
|
---|
1593 | ' MAX(idGenTestBox) AS idGenTestBox\n'
|
---|
1594 | ' FROM TestSets\n'
|
---|
1595 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1596 | ' GROUP BY idTestBox\n'
|
---|
1597 | ' ) AS TestBoxIDs\n'
|
---|
1598 | ' LEFT OUTER JOIN TestBoxesWithStrings\n'
|
---|
1599 | ' ON TestBoxesWithStrings.idGenTestBox = TestBoxIDs.idGenTestBox\n'
|
---|
1600 | 'ORDER BY TestBoxesWithStrings.sCpuArch\n' );
|
---|
1601 | return self._oDb.fetchAll();
|
---|
1602 |
|
---|
1603 | def getBuildCategories(self, tsNow, sPeriod):
|
---|
1604 | """
|
---|
1605 | Get a list of BuildCategoryData that appears in the specified result period.
|
---|
1606 | """
|
---|
1607 |
|
---|
1608 | self._oDb.execute('SELECT DISTINCT BuildCategories.*\n'
|
---|
1609 | 'FROM ( SELECT DISTINCT idBuildCategory AS idBuildCategory\n'
|
---|
1610 | ' FROM TestSets\n'
|
---|
1611 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1612 | ' ) AS BuildCategoryIDs\n'
|
---|
1613 | ' LEFT OUTER JOIN BuildCategories\n'
|
---|
1614 | ' ON BuildCategories.idBuildCategory = BuildCategoryIDs.idBuildCategory\n'
|
---|
1615 | 'ORDER BY BuildCategories.sProduct, BuildCategories.sBranch, BuildCategories.sType\n');
|
---|
1616 | aoRet = [];
|
---|
1617 | for aoRow in self._oDb.fetchAll():
|
---|
1618 | aoRet.append(BuildCategoryData().initFromDbRow(aoRow));
|
---|
1619 | return aoRet;
|
---|
1620 |
|
---|
1621 | def getSchedGroups(self, tsNow, sPeriod):
|
---|
1622 | """
|
---|
1623 | Get list of uniq SchedGroupData objects which
|
---|
1624 | found in all test results.
|
---|
1625 | """
|
---|
1626 |
|
---|
1627 | self._oDb.execute('SELECT SchedGroups.*\n'
|
---|
1628 | 'FROM ( SELECT idSchedGroup,\n'
|
---|
1629 | ' MAX(TestSets.tsCreated) AS tsNow\n'
|
---|
1630 | ' FROM TestSets\n'
|
---|
1631 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1632 | ' GROUP BY idSchedGroup\n'
|
---|
1633 | ' ) AS SchedGroupIDs\n'
|
---|
1634 | ' INNER JOIN SchedGroups\n'
|
---|
1635 | ' ON SchedGroups.idSchedGroup = SchedGroupIDs.idSchedGroup\n'
|
---|
1636 | ' AND SchedGroups.tsExpire > SchedGroupIDs.tsNow\n'
|
---|
1637 | ' AND SchedGroups.tsEffective <= SchedGroupIDs.tsNow\n'
|
---|
1638 | 'ORDER BY SchedGroups.sName\n' );
|
---|
1639 | aoRet = []
|
---|
1640 | for aoRow in self._oDb.fetchAll():
|
---|
1641 | aoRet.append(SchedGroupData().initFromDbRow(aoRow));
|
---|
1642 | return aoRet
|
---|
1643 |
|
---|
1644 | def getById(self, idTestResult):
|
---|
1645 | """
|
---|
1646 | Get build record by its id
|
---|
1647 | """
|
---|
1648 | self._oDb.execute('SELECT *\n'
|
---|
1649 | 'FROM TestResults\n'
|
---|
1650 | 'WHERE idTestResult = %s\n',
|
---|
1651 | (idTestResult,))
|
---|
1652 |
|
---|
1653 | aRows = self._oDb.fetchAll()
|
---|
1654 | if len(aRows) not in (0, 1):
|
---|
1655 | raise TMTooManyRows('Found more than one test result with the same credentials. Database structure is corrupted.')
|
---|
1656 | try:
|
---|
1657 | return TestResultData().initFromDbRow(aRows[0])
|
---|
1658 | except IndexError:
|
---|
1659 | return None
|
---|
1660 |
|
---|
1661 | def fetchPossibleFilterOptions(self, oFilter, tsNow, sPeriod, oReportModel = None):
|
---|
1662 | """
|
---|
1663 | Fetches the available filter criteria, given the current filtering.
|
---|
1664 |
|
---|
1665 | Returns oFilter.
|
---|
1666 | """
|
---|
1667 | assert isinstance(oFilter, TestResultFilter);
|
---|
1668 |
|
---|
1669 | # Hack to avoid lot's of conditionals or duplicate this code.
|
---|
1670 | if oReportModel is None:
|
---|
1671 | class DummyReportModel(object):
|
---|
1672 | """ Dummy """
|
---|
1673 | def getExtraSubjectTables(self):
|
---|
1674 | """ Dummy """
|
---|
1675 | return [];
|
---|
1676 | def getExtraSubjectWhereExpr(self):
|
---|
1677 | """ Dummy """
|
---|
1678 | return '';
|
---|
1679 | oReportModel = DummyReportModel();
|
---|
1680 |
|
---|
1681 | def workerDoFetch(oMissingLogicType, sNameAttr = 'sName', fIdIsName = False, idxHover = -1,
|
---|
1682 | idNull = -1, sNullDesc = '<NULL>'):
|
---|
1683 | """ Does the tedious result fetching and handling of missing bits. """
|
---|
1684 | dLeft = { oValue: 1 for oValue in oCrit.aoSelected };
|
---|
1685 | oCrit.aoPossible = [];
|
---|
1686 | for aoRow in self._oDb.fetchAll():
|
---|
1687 | oCrit.aoPossible.append(FilterCriterionValueAndDescription(aoRow[0] if aoRow[0] is not None else idNull,
|
---|
1688 | aoRow[1] if aoRow[1] is not None else sNullDesc,
|
---|
1689 | aoRow[2],
|
---|
1690 | aoRow[idxHover] if idxHover >= 0 else None));
|
---|
1691 | if aoRow[0] in dLeft:
|
---|
1692 | del dLeft[aoRow[0]];
|
---|
1693 | if dLeft:
|
---|
1694 | if fIdIsName:
|
---|
1695 | for idMissing in dLeft:
|
---|
1696 | oCrit.aoPossible.append(FilterCriterionValueAndDescription(idMissing, str(idMissing),
|
---|
1697 | fIrrelevant = True));
|
---|
1698 | else:
|
---|
1699 | oMissingLogic = oMissingLogicType(self._oDb);
|
---|
1700 | for idMissing in dLeft:
|
---|
1701 | oMissing = oMissingLogic.cachedLookup(idMissing);
|
---|
1702 | if oMissing is not None:
|
---|
1703 | oCrit.aoPossible.append(FilterCriterionValueAndDescription(idMissing,
|
---|
1704 | getattr(oMissing, sNameAttr),
|
---|
1705 | fIrrelevant = True));
|
---|
1706 |
|
---|
1707 | def workerDoFetchNested():
|
---|
1708 | """ Does the tedious result fetching and handling of missing bits. """
|
---|
1709 | oCrit.aoPossible = [];
|
---|
1710 | oCrit.oSub.aoPossible = [];
|
---|
1711 | dLeft = { oValue: 1 for oValue in oCrit.aoSelected };
|
---|
1712 | dSubLeft = { oValue: 1 for oValue in oCrit.oSub.aoSelected };
|
---|
1713 | oMain = None;
|
---|
1714 | for aoRow in self._oDb.fetchAll():
|
---|
1715 | if oMain is None or oMain.oValue != aoRow[0]:
|
---|
1716 | oMain = FilterCriterionValueAndDescription(aoRow[0], aoRow[1], 0);
|
---|
1717 | oCrit.aoPossible.append(oMain);
|
---|
1718 | if aoRow[0] in dLeft:
|
---|
1719 | del dLeft[aoRow[0]];
|
---|
1720 | oCurSub = FilterCriterionValueAndDescription(aoRow[2], aoRow[3], aoRow[4]);
|
---|
1721 | oCrit.oSub.aoPossible.append(oCurSub);
|
---|
1722 | if aoRow[2] in dSubLeft:
|
---|
1723 | del dSubLeft[aoRow[2]];
|
---|
1724 |
|
---|
1725 | oMain.aoSubs.append(oCurSub);
|
---|
1726 | oMain.cTimes += aoRow[4];
|
---|
1727 |
|
---|
1728 | if dLeft:
|
---|
1729 | pass; ## @todo
|
---|
1730 |
|
---|
1731 | # Statuses.
|
---|
1732 | oCrit = oFilter.aCriteria[TestResultFilter.kiTestStatus];
|
---|
1733 | self._oDb.execute('SELECT TestSets.enmStatus, TestSets.enmStatus, COUNT(TestSets.idTestSet)\n'
|
---|
1734 | 'FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiTestStatus) +
|
---|
1735 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1736 | 'WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod) +
|
---|
1737 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiTestStatus) +
|
---|
1738 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1739 | 'GROUP BY TestSets.enmStatus\n'
|
---|
1740 | 'ORDER BY TestSets.enmStatus\n');
|
---|
1741 | workerDoFetch(None, fIdIsName = True);
|
---|
1742 |
|
---|
1743 | # Scheduling groups (see getSchedGroups).
|
---|
1744 | oCrit = oFilter.aCriteria[TestResultFilter.kiSchedGroups];
|
---|
1745 | self._oDb.execute('SELECT SchedGroups.idSchedGroup, SchedGroups.sName, SchedGroupIDs.cTimes\n'
|
---|
1746 | 'FROM ( SELECT TestSets.idSchedGroup,\n'
|
---|
1747 | ' MAX(TestSets.tsCreated) AS tsNow,\n'
|
---|
1748 | ' COUNT(TestSets.idTestSet) AS cTimes\n'
|
---|
1749 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiSchedGroups) +
|
---|
1750 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1751 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1752 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiSchedGroups) +
|
---|
1753 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1754 | ' GROUP BY TestSets.idSchedGroup\n'
|
---|
1755 | ' ) AS SchedGroupIDs\n'
|
---|
1756 | ' INNER JOIN SchedGroups\n'
|
---|
1757 | ' ON SchedGroups.idSchedGroup = SchedGroupIDs.idSchedGroup\n'
|
---|
1758 | ' AND SchedGroups.tsExpire > SchedGroupIDs.tsNow\n'
|
---|
1759 | ' AND SchedGroups.tsEffective <= SchedGroupIDs.tsNow\n'
|
---|
1760 | 'ORDER BY SchedGroups.sName\n' );
|
---|
1761 | workerDoFetch(SchedGroupLogic);
|
---|
1762 |
|
---|
1763 | # Testboxes (see getTestBoxes).
|
---|
1764 | oCrit = oFilter.aCriteria[TestResultFilter.kiTestBoxes];
|
---|
1765 | self._oDb.execute('SELECT TestBoxesWithStrings.idTestBox,\n'
|
---|
1766 | ' TestBoxesWithStrings.sName,\n'
|
---|
1767 | ' TestBoxIDs.cTimes\n'
|
---|
1768 | 'FROM ( SELECT TestSets.idTestBox AS idTestBox,\n'
|
---|
1769 | ' MAX(TestSets.idGenTestBox) AS idGenTestBox,\n'
|
---|
1770 | ' COUNT(TestSets.idTestSet) AS cTimes\n'
|
---|
1771 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiTestBoxes) +
|
---|
1772 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1773 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1774 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiTestBoxes) +
|
---|
1775 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1776 | ' GROUP BY TestSets.idTestBox\n'
|
---|
1777 | ' ) AS TestBoxIDs\n'
|
---|
1778 | ' LEFT OUTER JOIN TestBoxesWithStrings\n'
|
---|
1779 | ' ON TestBoxesWithStrings.idGenTestBox = TestBoxIDs.idGenTestBox\n'
|
---|
1780 | 'ORDER BY TestBoxesWithStrings.sName\n' );
|
---|
1781 | workerDoFetch(TestBoxLogic);
|
---|
1782 |
|
---|
1783 | # Testbox OSes and versions.
|
---|
1784 | oCrit = oFilter.aCriteria[TestResultFilter.kiOses];
|
---|
1785 | self._oDb.execute('SELECT TestBoxesWithStrings.idStrOs,\n'
|
---|
1786 | ' TestBoxesWithStrings.sOs,\n'
|
---|
1787 | ' TestBoxesWithStrings.idStrOsVersion,\n'
|
---|
1788 | ' TestBoxesWithStrings.sOsVersion,\n'
|
---|
1789 | ' SUM(TestBoxGenIDs.cTimes)\n'
|
---|
1790 | 'FROM ( SELECT TestSets.idGenTestBox,\n'
|
---|
1791 | ' COUNT(TestSets.idTestSet) AS cTimes\n'
|
---|
1792 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiOses) +
|
---|
1793 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1794 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1795 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiOses) +
|
---|
1796 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1797 | ' GROUP BY TestSets.idGenTestBox\n'
|
---|
1798 | ' ) AS TestBoxGenIDs\n'
|
---|
1799 | ' LEFT OUTER JOIN TestBoxesWithStrings\n'
|
---|
1800 | ' ON TestBoxesWithStrings.idGenTestBox = TestBoxGenIDs.idGenTestBox\n'
|
---|
1801 | 'GROUP BY TestBoxesWithStrings.idStrOs,\n'
|
---|
1802 | ' TestBoxesWithStrings.sOs,\n'
|
---|
1803 | ' TestBoxesWithStrings.idStrOsVersion,\n'
|
---|
1804 | ' TestBoxesWithStrings.sOsVersion\n'
|
---|
1805 | 'ORDER BY TestBoxesWithStrings.sOs,\n'
|
---|
1806 | ' TestBoxesWithStrings.sOs = \'win\' AND TestBoxesWithStrings.sOsVersion = \'10\' DESC,\n'
|
---|
1807 | ' TestBoxesWithStrings.sOsVersion DESC\n'
|
---|
1808 | );
|
---|
1809 | workerDoFetchNested();
|
---|
1810 |
|
---|
1811 | # Testbox CPU(/OS) architectures.
|
---|
1812 | oCrit = oFilter.aCriteria[TestResultFilter.kiCpuArches];
|
---|
1813 | self._oDb.execute('SELECT TestBoxesWithStrings.idStrCpuArch,\n'
|
---|
1814 | ' TestBoxesWithStrings.sCpuArch,\n'
|
---|
1815 | ' SUM(TestBoxGenIDs.cTimes)\n'
|
---|
1816 | 'FROM ( SELECT TestSets.idGenTestBox,\n'
|
---|
1817 | ' COUNT(TestSets.idTestSet) AS cTimes\n'
|
---|
1818 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiCpuArches) +
|
---|
1819 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1820 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1821 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiCpuArches) +
|
---|
1822 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1823 | ' GROUP BY TestSets.idGenTestBox\n'
|
---|
1824 | ' ) AS TestBoxGenIDs\n'
|
---|
1825 | ' LEFT OUTER JOIN TestBoxesWithStrings\n'
|
---|
1826 | ' ON TestBoxesWithStrings.idGenTestBox = TestBoxGenIDs.idGenTestBox\n'
|
---|
1827 | 'GROUP BY TestBoxesWithStrings.idStrCpuArch, TestBoxesWithStrings.sCpuArch\n'
|
---|
1828 | 'ORDER BY TestBoxesWithStrings.sCpuArch\n' );
|
---|
1829 | workerDoFetch(None, fIdIsName = True);
|
---|
1830 |
|
---|
1831 | # Testbox CPU revisions.
|
---|
1832 | oCrit = oFilter.aCriteria[TestResultFilter.kiCpuVendors];
|
---|
1833 | self._oDb.execute('SELECT TestBoxesWithStrings.idStrCpuVendor,\n'
|
---|
1834 | ' TestBoxesWithStrings.sCpuVendor,\n'
|
---|
1835 | ' TestBoxesWithStrings.lCpuRevision,\n'
|
---|
1836 | ' TestBoxesWithStrings.sCpuVendor,\n'
|
---|
1837 | ' SUM(TestBoxGenIDs.cTimes)\n'
|
---|
1838 | 'FROM ( SELECT TestSets.idGenTestBox,\n'
|
---|
1839 | ' COUNT(TestSets.idTestSet) AS cTimes\n'
|
---|
1840 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiCpuVendors) +
|
---|
1841 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1842 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1843 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiCpuVendors) +
|
---|
1844 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1845 | ' GROUP BY TestSets.idGenTestBox'
|
---|
1846 | ' ) AS TestBoxGenIDs\n'
|
---|
1847 | ' LEFT OUTER JOIN TestBoxesWithStrings\n'
|
---|
1848 | ' ON TestBoxesWithStrings.idGenTestBox = TestBoxGenIDs.idGenTestBox\n'
|
---|
1849 | 'GROUP BY TestBoxesWithStrings.idStrCpuVendor,\n'
|
---|
1850 | ' TestBoxesWithStrings.sCpuVendor,\n'
|
---|
1851 | ' TestBoxesWithStrings.lCpuRevision,\n'
|
---|
1852 | ' TestBoxesWithStrings.sCpuVendor\n'
|
---|
1853 | 'ORDER BY TestBoxesWithStrings.sCpuVendor DESC,\n'
|
---|
1854 | ' TestBoxesWithStrings.sCpuVendor = \'GenuineIntel\'\n'
|
---|
1855 | ' AND (TestBoxesWithStrings.lCpuRevision >> 24) = 15,\n' # P4 at the bottom is a start...
|
---|
1856 | ' TestBoxesWithStrings.lCpuRevision DESC\n'
|
---|
1857 | );
|
---|
1858 | workerDoFetchNested();
|
---|
1859 | for oCur in oCrit.oSub.aoPossible:
|
---|
1860 | oCur.sDesc = TestBoxData.getPrettyCpuVersionEx(oCur.oValue, oCur.sDesc).replace('_', ' ');
|
---|
1861 |
|
---|
1862 | # Testbox CPU core/thread counts.
|
---|
1863 | oCrit = oFilter.aCriteria[TestResultFilter.kiCpuCounts];
|
---|
1864 | self._oDb.execute('SELECT TestBoxesWithStrings.cCpus,\n'
|
---|
1865 | ' CAST(TestBoxesWithStrings.cCpus AS TEXT),\n'
|
---|
1866 | ' SUM(TestBoxGenIDs.cTimes)\n'
|
---|
1867 | 'FROM ( SELECT TestSets.idGenTestBox,\n'
|
---|
1868 | ' COUNT(TestSets.idTestSet) AS cTimes\n'
|
---|
1869 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiCpuCounts) +
|
---|
1870 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1871 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1872 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiCpuCounts) +
|
---|
1873 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1874 | ' GROUP BY TestSets.idGenTestBox'
|
---|
1875 | ' ) AS TestBoxGenIDs\n'
|
---|
1876 | ' LEFT OUTER JOIN TestBoxesWithStrings\n'
|
---|
1877 | ' ON TestBoxesWithStrings.idGenTestBox = TestBoxGenIDs.idGenTestBox\n'
|
---|
1878 | 'GROUP BY TestBoxesWithStrings.cCpus\n'
|
---|
1879 | 'ORDER BY TestBoxesWithStrings.cCpus\n' );
|
---|
1880 | workerDoFetch(None, fIdIsName = True);
|
---|
1881 |
|
---|
1882 | # Testbox memory.
|
---|
1883 | oCrit = oFilter.aCriteria[TestResultFilter.kiMemory];
|
---|
1884 | self._oDb.execute('SELECT TestBoxesWithStrings.cMbMemory / 1024,\n'
|
---|
1885 | ' NULL,\n'
|
---|
1886 | ' SUM(TestBoxGenIDs.cTimes)\n'
|
---|
1887 | 'FROM ( SELECT TestSets.idGenTestBox,\n'
|
---|
1888 | ' COUNT(TestSets.idTestSet) AS cTimes\n'
|
---|
1889 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiMemory) +
|
---|
1890 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1891 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1892 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiMemory) +
|
---|
1893 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1894 | ' GROUP BY TestSets.idGenTestBox'
|
---|
1895 | ' ) AS TestBoxGenIDs\n'
|
---|
1896 | ' LEFT OUTER JOIN TestBoxesWithStrings\n'
|
---|
1897 | ' ON TestBoxesWithStrings.idGenTestBox = TestBoxGenIDs.idGenTestBox\n'
|
---|
1898 | 'GROUP BY TestBoxesWithStrings.cMbMemory / 1024\n'
|
---|
1899 | 'ORDER BY 1\n' );
|
---|
1900 | workerDoFetch(None, fIdIsName = True);
|
---|
1901 | for oCur in oCrit.aoPossible:
|
---|
1902 | oCur.sDesc = '%u GB' % (oCur.oValue,);
|
---|
1903 |
|
---|
1904 | # Testbox python versions .
|
---|
1905 | oCrit = oFilter.aCriteria[TestResultFilter.kiPythonVersions];
|
---|
1906 | self._oDb.execute('SELECT TestBoxesWithStrings.iPythonHexVersion,\n'
|
---|
1907 | ' NULL,\n'
|
---|
1908 | ' SUM(TestBoxGenIDs.cTimes)\n'
|
---|
1909 | 'FROM ( SELECT TestSets.idGenTestBox AS idGenTestBox,\n'
|
---|
1910 | ' COUNT(TestSets.idTestSet) AS cTimes\n'
|
---|
1911 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiPythonVersions) +
|
---|
1912 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1913 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1914 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiPythonVersions) +
|
---|
1915 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1916 | ' GROUP BY TestSets.idGenTestBox\n'
|
---|
1917 | ' ) AS TestBoxGenIDs\n'
|
---|
1918 | ' LEFT OUTER JOIN TestBoxesWithStrings\n'
|
---|
1919 | ' ON TestBoxesWithStrings.idGenTestBox = TestBoxGenIDs.idGenTestBox\n'
|
---|
1920 | 'GROUP BY TestBoxesWithStrings.iPythonHexVersion\n'
|
---|
1921 | 'ORDER BY TestBoxesWithStrings.iPythonHexVersion\n' );
|
---|
1922 | workerDoFetch(None, fIdIsName = True);
|
---|
1923 | for oCur in oCrit.aoPossible:
|
---|
1924 | oCur.sDesc = TestBoxData.formatPythonVersionEx(oCur.oValue); # pylint: disable=redefined-variable-type
|
---|
1925 |
|
---|
1926 | # Testcase with variation.
|
---|
1927 | oCrit = oFilter.aCriteria[TestResultFilter.kiTestCases];
|
---|
1928 | self._oDb.execute('SELECT TestCaseArgsIDs.idTestCase,\n'
|
---|
1929 | ' TestCases.sName,\n'
|
---|
1930 | ' TestCaseArgsIDs.idTestCaseArgs,\n'
|
---|
1931 | ' CASE WHEN TestCaseArgs.sSubName IS NULL OR TestCaseArgs.sSubName = \'\' THEN\n'
|
---|
1932 | ' CONCAT(\'/ #\', TestCaseArgs.idTestCaseArgs)\n'
|
---|
1933 | ' ELSE\n'
|
---|
1934 | ' TestCaseArgs.sSubName\n'
|
---|
1935 | ' END,'
|
---|
1936 | ' TestCaseArgsIDs.cTimes\n'
|
---|
1937 | 'FROM ( SELECT TestSets.idTestCase AS idTestCase,\n'
|
---|
1938 | ' TestSets.idTestCaseArgs AS idTestCaseArgs,\n'
|
---|
1939 | ' MAX(TestSets.idGenTestCase) AS idGenTestCase,\n'
|
---|
1940 | ' MAX(TestSets.idGenTestCaseArgs) AS idGenTestCaseArgs,\n'
|
---|
1941 | ' COUNT(TestSets.idTestSet) AS cTimes\n'
|
---|
1942 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiTestCases) +
|
---|
1943 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1944 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1945 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiTestCases) +
|
---|
1946 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1947 | ' GROUP BY TestSets.idTestCase, TestSets.idTestCaseArgs\n'
|
---|
1948 | ' ) AS TestCaseArgsIDs\n'
|
---|
1949 | ' LEFT OUTER JOIN TestCases ON TestCases.idGenTestCase = TestCaseArgsIDs.idGenTestCase\n'
|
---|
1950 | ' LEFT OUTER JOIN TestCaseArgs\n'
|
---|
1951 | ' ON TestCaseArgs.idGenTestCaseArgs = TestCaseArgsIDs.idGenTestCaseArgs\n'
|
---|
1952 | 'ORDER BY TestCases.sName, 4\n' );
|
---|
1953 | workerDoFetchNested();
|
---|
1954 |
|
---|
1955 | # Build revisions.
|
---|
1956 | oCrit = oFilter.aCriteria[TestResultFilter.kiRevisions];
|
---|
1957 | self._oDb.execute('SELECT Builds.iRevision, CONCAT(\'r\', Builds.iRevision), SUM(BuildIDs.cTimes)\n'
|
---|
1958 | 'FROM ( SELECT TestSets.idBuild AS idBuild,\n'
|
---|
1959 | ' MAX(TestSets.tsCreated) AS tsNow,\n'
|
---|
1960 | ' COUNT(TestSets.idBuild) AS cTimes\n'
|
---|
1961 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiRevisions) +
|
---|
1962 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1963 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1964 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiRevisions) +
|
---|
1965 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1966 | ' GROUP BY TestSets.idBuild\n'
|
---|
1967 | ' ) AS BuildIDs\n'
|
---|
1968 | ' INNER JOIN Builds\n'
|
---|
1969 | ' ON Builds.idBuild = BuildIDs.idBuild\n'
|
---|
1970 | ' AND Builds.tsExpire > BuildIDs.tsNow\n'
|
---|
1971 | ' AND Builds.tsEffective <= BuildIDs.tsNow\n'
|
---|
1972 | 'GROUP BY Builds.iRevision\n'
|
---|
1973 | 'ORDER BY Builds.iRevision DESC\n' );
|
---|
1974 | workerDoFetch(None, fIdIsName = True);
|
---|
1975 |
|
---|
1976 | # Build branches.
|
---|
1977 | oCrit = oFilter.aCriteria[TestResultFilter.kiBranches];
|
---|
1978 | self._oDb.execute('SELECT BuildCategories.sBranch, BuildCategories.sBranch, SUM(BuildCategoryIDs.cTimes)\n'
|
---|
1979 | 'FROM ( SELECT TestSets.idBuildCategory,\n'
|
---|
1980 | ' COUNT(TestSets.idTestSet) AS cTimes\n'
|
---|
1981 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiBranches) +
|
---|
1982 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
1983 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
1984 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiBranches) +
|
---|
1985 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
1986 | ' GROUP BY TestSets.idBuildCategory\n'
|
---|
1987 | ' ) AS BuildCategoryIDs\n'
|
---|
1988 | ' INNER JOIN BuildCategories\n'
|
---|
1989 | ' ON BuildCategories.idBuildCategory = BuildCategoryIDs.idBuildCategory\n'
|
---|
1990 | 'GROUP BY BuildCategories.sBranch\n'
|
---|
1991 | 'ORDER BY BuildCategories.sBranch DESC\n' );
|
---|
1992 | workerDoFetch(None, fIdIsName = True);
|
---|
1993 |
|
---|
1994 | # Build types.
|
---|
1995 | oCrit = oFilter.aCriteria[TestResultFilter.kiBuildTypes];
|
---|
1996 | self._oDb.execute('SELECT BuildCategories.sType, BuildCategories.sType, SUM(BuildCategoryIDs.cTimes)\n'
|
---|
1997 | 'FROM ( SELECT TestSets.idBuildCategory,\n'
|
---|
1998 | ' COUNT(TestSets.idTestSet) AS cTimes\n'
|
---|
1999 | ' FROM TestSets\n' + oFilter.getTableJoins(iOmit = TestResultFilter.kiBuildTypes) +
|
---|
2000 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
2001 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
2002 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiBuildTypes) +
|
---|
2003 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
2004 | ' GROUP BY TestSets.idBuildCategory\n'
|
---|
2005 | ' ) AS BuildCategoryIDs\n'
|
---|
2006 | ' INNER JOIN BuildCategories\n'
|
---|
2007 | ' ON BuildCategories.idBuildCategory = BuildCategoryIDs.idBuildCategory\n'
|
---|
2008 | 'GROUP BY BuildCategories.sType\n'
|
---|
2009 | 'ORDER BY BuildCategories.sType DESC\n' );
|
---|
2010 | workerDoFetch(None, fIdIsName = True);
|
---|
2011 |
|
---|
2012 | # Failure reasons.
|
---|
2013 | oCrit = oFilter.aCriteria[TestResultFilter.kiFailReasons];
|
---|
2014 | self._oDb.execute('SELECT FailureReasons.idFailureReason, FailureReasons.sShort, FailureReasonIDs.cTimes\n'
|
---|
2015 | 'FROM ( SELECT TestResultFailures.idFailureReason,\n'
|
---|
2016 | ' COUNT(TestSets.idTestSet) as cTimes\n'
|
---|
2017 | ' FROM TestSets\n'
|
---|
2018 | ' LEFT OUTER JOIN TestResultFailures\n'
|
---|
2019 | ' ON TestResultFailures.idTestSet = TestSets.idTestSet\n'
|
---|
2020 | ' AND TestResultFailures.tsExpire = \'infinity\'::TIMESTAMP\n' +
|
---|
2021 | oFilter.getTableJoins(iOmit = TestResultFilter.kiFailReasons) +
|
---|
2022 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
2023 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
2024 | ' AND TestSets.enmStatus >= \'failure\'::TestStatus_T\n' +
|
---|
2025 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiFailReasons) +
|
---|
2026 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
2027 | ' GROUP BY TestResultFailures.idFailureReason\n'
|
---|
2028 | ' ) AS FailureReasonIDs\n'
|
---|
2029 | ' LEFT OUTER JOIN FailureReasons\n'
|
---|
2030 | ' ON FailureReasons.idFailureReason = FailureReasonIDs.idFailureReason\n'
|
---|
2031 | ' AND FailureReasons.tsExpire = \'infinity\'::TIMESTAMP\n'
|
---|
2032 | 'ORDER BY FailureReasons.idFailureReason IS NULL DESC,\n'
|
---|
2033 | ' FailureReasons.sShort\n' );
|
---|
2034 | workerDoFetch(FailureReasonLogic, 'sShort', sNullDesc = 'Not given');
|
---|
2035 |
|
---|
2036 | # Error counts.
|
---|
2037 | oCrit = oFilter.aCriteria[TestResultFilter.kiErrorCounts];
|
---|
2038 | self._oDb.execute('SELECT TestResults.cErrors, CAST(TestResults.cErrors AS TEXT), COUNT(TestResults.idTestResult)\n'
|
---|
2039 | 'FROM ( SELECT TestSets.idTestResult AS idTestResult\n'
|
---|
2040 | ' FROM TestSets\n' +
|
---|
2041 | oFilter.getTableJoins(iOmit = TestResultFilter.kiFailReasons) +
|
---|
2042 | ''.join(' , %s\n' % (sTable,) for sTable in oReportModel.getExtraSubjectTables()) +
|
---|
2043 | ' WHERE ' + self._getTimePeriodQueryPart(tsNow, sPeriod, ' ') +
|
---|
2044 | oFilter.getWhereConditions(iOmit = TestResultFilter.kiFailReasons) +
|
---|
2045 | oReportModel.getExtraSubjectWhereExpr() +
|
---|
2046 | ' ) AS TestSetIDs\n'
|
---|
2047 | ' INNER JOIN TestResults\n'
|
---|
2048 | ' ON TestResults.idTestResult = TestSetIDs.idTestResult\n'
|
---|
2049 | 'GROUP BY TestResults.cErrors\n'
|
---|
2050 | 'ORDER BY TestResults.cErrors\n');
|
---|
2051 |
|
---|
2052 | workerDoFetch(None, fIdIsName = True);
|
---|
2053 |
|
---|
2054 | return oFilter;
|
---|
2055 |
|
---|
2056 |
|
---|
2057 | #
|
---|
2058 | # Details view and interface.
|
---|
2059 | #
|
---|
2060 |
|
---|
2061 | def fetchResultTree(self, idTestSet, cMaxDepth = None):
|
---|
2062 | """
|
---|
2063 | Fetches the result tree for the given test set.
|
---|
2064 |
|
---|
2065 | Returns a tree of TestResultDataEx nodes.
|
---|
2066 | Raises exception on invalid input and database issues.
|
---|
2067 | """
|
---|
2068 | # Depth first, i.e. just like the XML added them.
|
---|
2069 | ## @todo this still isn't performing extremely well, consider optimizations.
|
---|
2070 | sQuery = self._oDb.formatBindArgs(
|
---|
2071 | 'SELECT TestResults.*,\n'
|
---|
2072 | ' TestResultStrTab.sValue,\n'
|
---|
2073 | ' EXISTS ( SELECT idTestResultValue\n'
|
---|
2074 | ' FROM TestResultValues\n'
|
---|
2075 | ' WHERE TestResultValues.idTestResult = TestResults.idTestResult ) AS fHasValues,\n'
|
---|
2076 | ' EXISTS ( SELECT idTestResultMsg\n'
|
---|
2077 | ' FROM TestResultMsgs\n'
|
---|
2078 | ' WHERE TestResultMsgs.idTestResult = TestResults.idTestResult ) AS fHasMsgs,\n'
|
---|
2079 | ' EXISTS ( SELECT idTestResultFile\n'
|
---|
2080 | ' FROM TestResultFiles\n'
|
---|
2081 | ' WHERE TestResultFiles.idTestResult = TestResults.idTestResult ) AS fHasFiles,\n'
|
---|
2082 | ' EXISTS ( SELECT idTestResult\n'
|
---|
2083 | ' FROM TestResultFailures\n'
|
---|
2084 | ' WHERE TestResultFailures.idTestResult = TestResults.idTestResult ) AS fHasReasons\n'
|
---|
2085 | 'FROM TestResults, TestResultStrTab\n'
|
---|
2086 | 'WHERE TestResults.idTestSet = %s\n'
|
---|
2087 | ' AND TestResults.idStrName = TestResultStrTab.idStr\n'
|
---|
2088 | , ( idTestSet, ));
|
---|
2089 | if cMaxDepth is not None:
|
---|
2090 | sQuery += self._oDb.formatBindArgs(' AND TestResults.iNestingDepth <= %s\n', (cMaxDepth,));
|
---|
2091 | sQuery += 'ORDER BY idTestResult ASC\n'
|
---|
2092 |
|
---|
2093 | self._oDb.execute(sQuery);
|
---|
2094 | cRows = self._oDb.getRowCount();
|
---|
2095 | if cRows > 65536:
|
---|
2096 | raise TMTooManyRows('Too many rows returned for idTestSet=%d: %d' % (idTestSet, cRows,));
|
---|
2097 |
|
---|
2098 | aaoRows = self._oDb.fetchAll();
|
---|
2099 | if not aaoRows:
|
---|
2100 | raise TMRowNotFound('No test results for idTestSet=%d.' % (idTestSet,));
|
---|
2101 |
|
---|
2102 | # Set up the root node first.
|
---|
2103 | aoRow = aaoRows[0];
|
---|
2104 | oRoot = TestResultDataEx().initFromDbRow(aoRow);
|
---|
2105 | if oRoot.idTestResultParent is not None:
|
---|
2106 | raise self._oDb.integrityException('The root TestResult (#%s) has a parent (#%s)!'
|
---|
2107 | % (oRoot.idTestResult, oRoot.idTestResultParent));
|
---|
2108 | self._fetchResultTreeNodeExtras(oRoot, aoRow[-4], aoRow[-3], aoRow[-2], aoRow[-1]);
|
---|
2109 |
|
---|
2110 | # The chilren (if any).
|
---|
2111 | dLookup = { oRoot.idTestResult: oRoot };
|
---|
2112 | oParent = oRoot;
|
---|
2113 | for iRow in range(1, len(aaoRows)):
|
---|
2114 | aoRow = aaoRows[iRow];
|
---|
2115 | oCur = TestResultDataEx().initFromDbRow(aoRow);
|
---|
2116 | self._fetchResultTreeNodeExtras(oCur, aoRow[-4], aoRow[-3], aoRow[-2], aoRow[-1]);
|
---|
2117 |
|
---|
2118 | # Figure out and vet the parent.
|
---|
2119 | if oParent.idTestResult != oCur.idTestResultParent:
|
---|
2120 | oParent = dLookup.get(oCur.idTestResultParent, None);
|
---|
2121 | if oParent is None:
|
---|
2122 | raise self._oDb.integrityException('TestResult #%d is orphaned from its parent #%s.'
|
---|
2123 | % (oCur.idTestResult, oCur.idTestResultParent,));
|
---|
2124 | if oParent.iNestingDepth + 1 != oCur.iNestingDepth:
|
---|
2125 | raise self._oDb.integrityException('TestResult #%d has incorrect nesting depth (%d instead of %d)'
|
---|
2126 | % (oCur.idTestResult, oCur.iNestingDepth, oParent.iNestingDepth + 1,));
|
---|
2127 |
|
---|
2128 | # Link it up.
|
---|
2129 | oCur.oParent = oParent;
|
---|
2130 | oParent.aoChildren.append(oCur);
|
---|
2131 | dLookup[oCur.idTestResult] = oCur;
|
---|
2132 |
|
---|
2133 | return (oRoot, dLookup);
|
---|
2134 |
|
---|
2135 | def _fetchResultTreeNodeExtras(self, oCurNode, fHasValues, fHasMsgs, fHasFiles, fHasReasons):
|
---|
2136 | """
|
---|
2137 | fetchResultTree worker that fetches values, message and files for the
|
---|
2138 | specified node.
|
---|
2139 | """
|
---|
2140 | assert(oCurNode.aoValues == []);
|
---|
2141 | assert(oCurNode.aoMsgs == []);
|
---|
2142 | assert(oCurNode.aoFiles == []);
|
---|
2143 | assert(oCurNode.oReason is None);
|
---|
2144 |
|
---|
2145 | if fHasValues:
|
---|
2146 | self._oDb.execute('SELECT TestResultValues.*,\n'
|
---|
2147 | ' TestResultStrTab.sValue\n'
|
---|
2148 | 'FROM TestResultValues, TestResultStrTab\n'
|
---|
2149 | 'WHERE TestResultValues.idTestResult = %s\n'
|
---|
2150 | ' AND TestResultValues.idStrName = TestResultStrTab.idStr\n'
|
---|
2151 | 'ORDER BY idTestResultValue ASC\n'
|
---|
2152 | , ( oCurNode.idTestResult, ));
|
---|
2153 | for aoRow in self._oDb.fetchAll():
|
---|
2154 | oCurNode.aoValues.append(TestResultValueDataEx().initFromDbRow(aoRow));
|
---|
2155 |
|
---|
2156 | if fHasMsgs:
|
---|
2157 | self._oDb.execute('SELECT TestResultMsgs.*,\n'
|
---|
2158 | ' TestResultStrTab.sValue\n'
|
---|
2159 | 'FROM TestResultMsgs, TestResultStrTab\n'
|
---|
2160 | 'WHERE TestResultMsgs.idTestResult = %s\n'
|
---|
2161 | ' AND TestResultMsgs.idStrMsg = TestResultStrTab.idStr\n'
|
---|
2162 | 'ORDER BY idTestResultMsg ASC\n'
|
---|
2163 | , ( oCurNode.idTestResult, ));
|
---|
2164 | for aoRow in self._oDb.fetchAll():
|
---|
2165 | oCurNode.aoMsgs.append(TestResultMsgDataEx().initFromDbRow(aoRow));
|
---|
2166 |
|
---|
2167 | if fHasFiles:
|
---|
2168 | self._oDb.execute('SELECT TestResultFiles.*,\n'
|
---|
2169 | ' StrTabFile.sValue AS sFile,\n'
|
---|
2170 | ' StrTabDesc.sValue AS sDescription,\n'
|
---|
2171 | ' StrTabKind.sValue AS sKind,\n'
|
---|
2172 | ' StrTabMime.sValue AS sMime\n'
|
---|
2173 | 'FROM TestResultFiles,\n'
|
---|
2174 | ' TestResultStrTab AS StrTabFile,\n'
|
---|
2175 | ' TestResultStrTab AS StrTabDesc,\n'
|
---|
2176 | ' TestResultStrTab AS StrTabKind,\n'
|
---|
2177 | ' TestResultStrTab AS StrTabMime\n'
|
---|
2178 | 'WHERE TestResultFiles.idTestResult = %s\n'
|
---|
2179 | ' AND TestResultFiles.idStrFile = StrTabFile.idStr\n'
|
---|
2180 | ' AND TestResultFiles.idStrDescription = StrTabDesc.idStr\n'
|
---|
2181 | ' AND TestResultFiles.idStrKind = StrTabKind.idStr\n'
|
---|
2182 | ' AND TestResultFiles.idStrMime = StrTabMime.idStr\n'
|
---|
2183 | 'ORDER BY idTestResultFile ASC\n'
|
---|
2184 | , ( oCurNode.idTestResult, ));
|
---|
2185 | for aoRow in self._oDb.fetchAll():
|
---|
2186 | oCurNode.aoFiles.append(TestResultFileDataEx().initFromDbRow(aoRow));
|
---|
2187 |
|
---|
2188 | if fHasReasons or True:
|
---|
2189 | if self.oFailureReasonLogic is None:
|
---|
2190 | self.oFailureReasonLogic = FailureReasonLogic(self._oDb);
|
---|
2191 | if self.oUserAccountLogic is None:
|
---|
2192 | self.oUserAccountLogic = UserAccountLogic(self._oDb);
|
---|
2193 | self._oDb.execute('SELECT *\n'
|
---|
2194 | 'FROM TestResultFailures\n'
|
---|
2195 | 'WHERE idTestResult = %s\n'
|
---|
2196 | ' AND tsExpire = \'infinity\'::TIMESTAMP\n'
|
---|
2197 | , ( oCurNode.idTestResult, ));
|
---|
2198 | if self._oDb.getRowCount() > 0:
|
---|
2199 | oCurNode.oReason = TestResultFailureDataEx().initFromDbRowEx(self._oDb.fetchOne(), self.oFailureReasonLogic,
|
---|
2200 | self.oUserAccountLogic);
|
---|
2201 |
|
---|
2202 | return True;
|
---|
2203 |
|
---|
2204 |
|
---|
2205 |
|
---|
2206 | #
|
---|
2207 | # TestBoxController interface(s).
|
---|
2208 | #
|
---|
2209 |
|
---|
2210 | def _inhumeTestResults(self, aoStack, idTestSet, sError):
|
---|
2211 | """
|
---|
2212 | The test produces too much output, kill and bury it.
|
---|
2213 |
|
---|
2214 | Note! We leave the test set open, only the test result records are
|
---|
2215 | completed. Thus, _getResultStack will return an empty stack and
|
---|
2216 | cause XML processing to fail immediately, while we can still
|
---|
2217 | record when it actually completed in the test set the normal way.
|
---|
2218 | """
|
---|
2219 | self._oDb.dprint('** _inhumeTestResults: idTestSet=%d\n%s' % (idTestSet, self._stringifyStack(aoStack),));
|
---|
2220 |
|
---|
2221 | #
|
---|
2222 | # First add a message.
|
---|
2223 | #
|
---|
2224 | self._newFailureDetails(aoStack[0].idTestResult, idTestSet, sError, None);
|
---|
2225 |
|
---|
2226 | #
|
---|
2227 | # The complete all open test results.
|
---|
2228 | #
|
---|
2229 | for oTestResult in aoStack:
|
---|
2230 | oTestResult.cErrors += 1;
|
---|
2231 | self._completeTestResults(oTestResult, None, TestResultData.ksTestStatus_Failure, oTestResult.cErrors);
|
---|
2232 |
|
---|
2233 | # A bit of paranoia.
|
---|
2234 | self._oDb.execute('UPDATE TestResults\n'
|
---|
2235 | 'SET cErrors = cErrors + 1,\n'
|
---|
2236 | ' enmStatus = \'failure\'::TestStatus_T,\n'
|
---|
2237 | ' tsElapsed = CURRENT_TIMESTAMP - tsCreated\n'
|
---|
2238 | 'WHERE idTestSet = %s\n'
|
---|
2239 | ' AND enmStatus = \'running\'::TestStatus_T\n'
|
---|
2240 | , ( idTestSet, ));
|
---|
2241 | self._oDb.commit();
|
---|
2242 |
|
---|
2243 | return None;
|
---|
2244 |
|
---|
2245 | def strTabString(self, sString, fCommit = False):
|
---|
2246 | """
|
---|
2247 | Gets the string table id for the given string, adding it if new.
|
---|
2248 |
|
---|
2249 | Note! A copy of this code is also in TestSetLogic.
|
---|
2250 | """
|
---|
2251 | ## @todo move this and make a stored procedure for it.
|
---|
2252 | self._oDb.execute('SELECT idStr\n'
|
---|
2253 | 'FROM TestResultStrTab\n'
|
---|
2254 | 'WHERE sValue = %s'
|
---|
2255 | , (sString,));
|
---|
2256 | if self._oDb.getRowCount() == 0:
|
---|
2257 | self._oDb.execute('INSERT INTO TestResultStrTab (sValue)\n'
|
---|
2258 | 'VALUES (%s)\n'
|
---|
2259 | 'RETURNING idStr\n'
|
---|
2260 | , (sString,));
|
---|
2261 | if fCommit:
|
---|
2262 | self._oDb.commit();
|
---|
2263 | return self._oDb.fetchOne()[0];
|
---|
2264 |
|
---|
2265 | @staticmethod
|
---|
2266 | def _stringifyStack(aoStack):
|
---|
2267 | """Returns a string rep of the stack."""
|
---|
2268 | sRet = '';
|
---|
2269 | for i, _ in enumerate(aoStack):
|
---|
2270 | sRet += 'aoStack[%d]=%s\n' % (i, aoStack[i]);
|
---|
2271 | return sRet;
|
---|
2272 |
|
---|
2273 | def _getResultStack(self, idTestSet):
|
---|
2274 | """
|
---|
2275 | Gets the current stack of result sets.
|
---|
2276 | """
|
---|
2277 | self._oDb.execute('SELECT *\n'
|
---|
2278 | 'FROM TestResults\n'
|
---|
2279 | 'WHERE idTestSet = %s\n'
|
---|
2280 | ' AND enmStatus = \'running\'::TestStatus_T\n'
|
---|
2281 | 'ORDER BY idTestResult DESC'
|
---|
2282 | , ( idTestSet, ));
|
---|
2283 | aoStack = [];
|
---|
2284 | for aoRow in self._oDb.fetchAll():
|
---|
2285 | aoStack.append(TestResultData().initFromDbRow(aoRow));
|
---|
2286 |
|
---|
2287 | for i, _ in enumerate(aoStack):
|
---|
2288 | assert aoStack[i].iNestingDepth == len(aoStack) - i - 1, self._stringifyStack(aoStack);
|
---|
2289 |
|
---|
2290 | return aoStack;
|
---|
2291 |
|
---|
2292 | def _newTestResult(self, idTestResultParent, idTestSet, iNestingDepth, tsCreated, sName, dCounts, fCommit = False):
|
---|
2293 | """
|
---|
2294 | Creates a new test result.
|
---|
2295 | Returns the TestResultData object for the new record.
|
---|
2296 | May raise exception on database error.
|
---|
2297 | """
|
---|
2298 | assert idTestResultParent is not None;
|
---|
2299 | assert idTestResultParent > 1;
|
---|
2300 |
|
---|
2301 | #
|
---|
2302 | # This isn't necessarily very efficient, but it's necessary to prevent
|
---|
2303 | # a wild test or testbox from filling up the database.
|
---|
2304 | #
|
---|
2305 | sCountName = 'cTestResults';
|
---|
2306 | if sCountName not in dCounts:
|
---|
2307 | self._oDb.execute('SELECT COUNT(idTestResult)\n'
|
---|
2308 | 'FROM TestResults\n'
|
---|
2309 | 'WHERE idTestSet = %s\n'
|
---|
2310 | , ( idTestSet,));
|
---|
2311 | dCounts[sCountName] = self._oDb.fetchOne()[0];
|
---|
2312 | dCounts[sCountName] += 1;
|
---|
2313 | if dCounts[sCountName] > config.g_kcMaxTestResultsPerTS:
|
---|
2314 | raise TestResultHangingOffence('Too many sub-tests in total!');
|
---|
2315 |
|
---|
2316 | sCountName = 'cTestResultsIn%d' % (idTestResultParent,);
|
---|
2317 | if sCountName not in dCounts:
|
---|
2318 | self._oDb.execute('SELECT COUNT(idTestResult)\n'
|
---|
2319 | 'FROM TestResults\n'
|
---|
2320 | 'WHERE idTestResultParent = %s\n'
|
---|
2321 | , ( idTestResultParent,));
|
---|
2322 | dCounts[sCountName] = self._oDb.fetchOne()[0];
|
---|
2323 | dCounts[sCountName] += 1;
|
---|
2324 | if dCounts[sCountName] > config.g_kcMaxTestResultsPerTR:
|
---|
2325 | raise TestResultHangingOffence('Too many immediate sub-tests!');
|
---|
2326 |
|
---|
2327 | # This is also a hanging offence.
|
---|
2328 | if iNestingDepth > config.g_kcMaxTestResultDepth:
|
---|
2329 | raise TestResultHangingOffence('To deep sub-test nesting!');
|
---|
2330 |
|
---|
2331 | # Ditto.
|
---|
2332 | if len(sName) > config.g_kcchMaxTestResultName:
|
---|
2333 | raise TestResultHangingOffence('Test name is too long: %d chars - "%s"' % (len(sName), sName));
|
---|
2334 |
|
---|
2335 | #
|
---|
2336 | # Within bounds, do the job.
|
---|
2337 | #
|
---|
2338 | idStrName = self.strTabString(sName, fCommit);
|
---|
2339 | self._oDb.execute('INSERT INTO TestResults (\n'
|
---|
2340 | ' idTestResultParent,\n'
|
---|
2341 | ' idTestSet,\n'
|
---|
2342 | ' tsCreated,\n'
|
---|
2343 | ' idStrName,\n'
|
---|
2344 | ' iNestingDepth )\n'
|
---|
2345 | 'VALUES (%s, %s, TIMESTAMP WITH TIME ZONE %s, %s, %s)\n'
|
---|
2346 | 'RETURNING *\n'
|
---|
2347 | , ( idTestResultParent, idTestSet, tsCreated, idStrName, iNestingDepth) )
|
---|
2348 | oData = TestResultData().initFromDbRow(self._oDb.fetchOne());
|
---|
2349 |
|
---|
2350 | self._oDb.maybeCommit(fCommit);
|
---|
2351 | return oData;
|
---|
2352 |
|
---|
2353 | def _newTestValue(self, idTestResult, idTestSet, sName, lValue, sUnit, dCounts, tsCreated = None, fCommit = False):
|
---|
2354 | """
|
---|
2355 | Creates a test value.
|
---|
2356 | May raise exception on database error.
|
---|
2357 | """
|
---|
2358 |
|
---|
2359 | #
|
---|
2360 | # Bounds checking.
|
---|
2361 | #
|
---|
2362 | sCountName = 'cTestValues';
|
---|
2363 | if sCountName not in dCounts:
|
---|
2364 | self._oDb.execute('SELECT COUNT(idTestResultValue)\n'
|
---|
2365 | 'FROM TestResultValues, TestResults\n'
|
---|
2366 | 'WHERE TestResultValues.idTestResult = TestResults.idTestResult\n'
|
---|
2367 | ' AND TestResults.idTestSet = %s\n'
|
---|
2368 | , ( idTestSet,));
|
---|
2369 | dCounts[sCountName] = self._oDb.fetchOne()[0];
|
---|
2370 | dCounts[sCountName] += 1;
|
---|
2371 | if dCounts[sCountName] > config.g_kcMaxTestValuesPerTS:
|
---|
2372 | raise TestResultHangingOffence('Too many values in total!');
|
---|
2373 |
|
---|
2374 | sCountName = 'cTestValuesIn%d' % (idTestResult,);
|
---|
2375 | if sCountName not in dCounts:
|
---|
2376 | self._oDb.execute('SELECT COUNT(idTestResultValue)\n'
|
---|
2377 | 'FROM TestResultValues\n'
|
---|
2378 | 'WHERE idTestResult = %s\n'
|
---|
2379 | , ( idTestResult,));
|
---|
2380 | dCounts[sCountName] = self._oDb.fetchOne()[0];
|
---|
2381 | dCounts[sCountName] += 1;
|
---|
2382 | if dCounts[sCountName] > config.g_kcMaxTestValuesPerTR:
|
---|
2383 | raise TestResultHangingOffence('Too many immediate values for one test result!');
|
---|
2384 |
|
---|
2385 | if len(sName) > config.g_kcchMaxTestValueName:
|
---|
2386 | raise TestResultHangingOffence('Value name is too long: %d chars - "%s"' % (len(sName), sName));
|
---|
2387 |
|
---|
2388 | #
|
---|
2389 | # Do the job.
|
---|
2390 | #
|
---|
2391 | iUnit = constants.valueunit.g_kdNameToConst.get(sUnit, constants.valueunit.NONE);
|
---|
2392 |
|
---|
2393 | idStrName = self.strTabString(sName, fCommit);
|
---|
2394 | if tsCreated is None:
|
---|
2395 | self._oDb.execute('INSERT INTO TestResultValues (\n'
|
---|
2396 | ' idTestResult,\n'
|
---|
2397 | ' idTestSet,\n'
|
---|
2398 | ' idStrName,\n'
|
---|
2399 | ' lValue,\n'
|
---|
2400 | ' iUnit)\n'
|
---|
2401 | 'VALUES ( %s, %s, %s, %s, %s )\n'
|
---|
2402 | , ( idTestResult, idTestSet, idStrName, lValue, iUnit,) );
|
---|
2403 | else:
|
---|
2404 | self._oDb.execute('INSERT INTO TestResultValues (\n'
|
---|
2405 | ' idTestResult,\n'
|
---|
2406 | ' idTestSet,\n'
|
---|
2407 | ' tsCreated,\n'
|
---|
2408 | ' idStrName,\n'
|
---|
2409 | ' lValue,\n'
|
---|
2410 | ' iUnit)\n'
|
---|
2411 | 'VALUES ( %s, %s, TIMESTAMP WITH TIME ZONE %s, %s, %s, %s )\n'
|
---|
2412 | , ( idTestResult, idTestSet, tsCreated, idStrName, lValue, iUnit,) );
|
---|
2413 | self._oDb.maybeCommit(fCommit);
|
---|
2414 | return True;
|
---|
2415 |
|
---|
2416 | def _newFailureDetails(self, idTestResult, idTestSet, sText, dCounts, tsCreated = None, fCommit = False):
|
---|
2417 | """
|
---|
2418 | Creates a record detailing cause of failure.
|
---|
2419 | May raise exception on database error.
|
---|
2420 | """
|
---|
2421 |
|
---|
2422 | #
|
---|
2423 | # Overflow protection.
|
---|
2424 | #
|
---|
2425 | if dCounts is not None:
|
---|
2426 | sCountName = 'cTestMsgsIn%d' % (idTestResult,);
|
---|
2427 | if sCountName not in dCounts:
|
---|
2428 | self._oDb.execute('SELECT COUNT(idTestResultMsg)\n'
|
---|
2429 | 'FROM TestResultMsgs\n'
|
---|
2430 | 'WHERE idTestResult = %s\n'
|
---|
2431 | , ( idTestResult,));
|
---|
2432 | dCounts[sCountName] = self._oDb.fetchOne()[0];
|
---|
2433 | dCounts[sCountName] += 1;
|
---|
2434 | if dCounts[sCountName] > config.g_kcMaxTestMsgsPerTR:
|
---|
2435 | raise TestResultHangingOffence('Too many messages under for one test result!');
|
---|
2436 |
|
---|
2437 | if len(sText) > config.g_kcchMaxTestMsg:
|
---|
2438 | raise TestResultHangingOffence('Failure details message is too long: %d chars - "%s"' % (len(sText), sText));
|
---|
2439 |
|
---|
2440 | #
|
---|
2441 | # Do the job.
|
---|
2442 | #
|
---|
2443 | idStrMsg = self.strTabString(sText, fCommit);
|
---|
2444 | if tsCreated is None:
|
---|
2445 | self._oDb.execute('INSERT INTO TestResultMsgs (\n'
|
---|
2446 | ' idTestResult,\n'
|
---|
2447 | ' idTestSet,\n'
|
---|
2448 | ' idStrMsg,\n'
|
---|
2449 | ' enmLevel)\n'
|
---|
2450 | 'VALUES ( %s, %s, %s, %s)\n'
|
---|
2451 | , ( idTestResult, idTestSet, idStrMsg, 'failure',) );
|
---|
2452 | else:
|
---|
2453 | self._oDb.execute('INSERT INTO TestResultMsgs (\n'
|
---|
2454 | ' idTestResult,\n'
|
---|
2455 | ' idTestSet,\n'
|
---|
2456 | ' tsCreated,\n'
|
---|
2457 | ' idStrMsg,\n'
|
---|
2458 | ' enmLevel)\n'
|
---|
2459 | 'VALUES ( %s, %s, TIMESTAMP WITH TIME ZONE %s, %s, %s)\n'
|
---|
2460 | , ( idTestResult, idTestSet, tsCreated, idStrMsg, 'failure',) );
|
---|
2461 |
|
---|
2462 | self._oDb.maybeCommit(fCommit);
|
---|
2463 | return True;
|
---|
2464 |
|
---|
2465 |
|
---|
2466 | def _completeTestResults(self, oTestResult, tsDone, enmStatus, cErrors = 0, fCommit = False):
|
---|
2467 | """
|
---|
2468 | Completes a test result. Updates the oTestResult object.
|
---|
2469 | May raise exception on database error.
|
---|
2470 | """
|
---|
2471 | self._oDb.dprint('** _completeTestResults: cErrors=%s tsDone=%s enmStatus=%s oTestResults=\n%s'
|
---|
2472 | % (cErrors, tsDone, enmStatus, oTestResult,));
|
---|
2473 |
|
---|
2474 | #
|
---|
2475 | # Sanity check: No open sub tests (aoStack should make sure about this!).
|
---|
2476 | #
|
---|
2477 | self._oDb.execute('SELECT COUNT(idTestResult)\n'
|
---|
2478 | 'FROM TestResults\n'
|
---|
2479 | 'WHERE idTestResultParent = %s\n'
|
---|
2480 | ' AND enmStatus = %s\n'
|
---|
2481 | , ( oTestResult.idTestResult, TestResultData.ksTestStatus_Running,));
|
---|
2482 | cOpenSubTest = self._oDb.fetchOne()[0];
|
---|
2483 | assert cOpenSubTest == 0, 'cOpenSubTest=%d - %s' % (cOpenSubTest, oTestResult,);
|
---|
2484 | assert oTestResult.enmStatus == TestResultData.ksTestStatus_Running;
|
---|
2485 |
|
---|
2486 | #
|
---|
2487 | # Make sure the reporter isn't lying about successes or error counts.
|
---|
2488 | #
|
---|
2489 | self._oDb.execute('SELECT COALESCE(SUM(cErrors), 0)\n'
|
---|
2490 | 'FROM TestResults\n'
|
---|
2491 | 'WHERE idTestResultParent = %s\n'
|
---|
2492 | , ( oTestResult.idTestResult, ));
|
---|
2493 | cMinErrors = self._oDb.fetchOne()[0] + oTestResult.cErrors;
|
---|
2494 | if cErrors < cMinErrors:
|
---|
2495 | cErrors = cMinErrors;
|
---|
2496 | if cErrors > 0 and enmStatus == TestResultData.ksTestStatus_Success:
|
---|
2497 | enmStatus = TestResultData.ksTestStatus_Failure
|
---|
2498 |
|
---|
2499 | #
|
---|
2500 | # Do the update.
|
---|
2501 | #
|
---|
2502 | if tsDone is None:
|
---|
2503 | self._oDb.execute('UPDATE TestResults\n'
|
---|
2504 | 'SET cErrors = %s,\n'
|
---|
2505 | ' enmStatus = %s,\n'
|
---|
2506 | ' tsElapsed = CURRENT_TIMESTAMP - tsCreated\n'
|
---|
2507 | 'WHERE idTestResult = %s\n'
|
---|
2508 | 'RETURNING tsElapsed'
|
---|
2509 | , ( cErrors, enmStatus, oTestResult.idTestResult,) );
|
---|
2510 | else:
|
---|
2511 | self._oDb.execute('UPDATE TestResults\n'
|
---|
2512 | 'SET cErrors = %s,\n'
|
---|
2513 | ' enmStatus = %s,\n'
|
---|
2514 | ' tsElapsed = TIMESTAMP WITH TIME ZONE %s - tsCreated\n'
|
---|
2515 | 'WHERE idTestResult = %s\n'
|
---|
2516 | 'RETURNING tsElapsed'
|
---|
2517 | , ( cErrors, enmStatus, tsDone, oTestResult.idTestResult,) );
|
---|
2518 |
|
---|
2519 | oTestResult.tsElapsed = self._oDb.fetchOne()[0];
|
---|
2520 | oTestResult.enmStatus = enmStatus;
|
---|
2521 | oTestResult.cErrors = cErrors;
|
---|
2522 |
|
---|
2523 | self._oDb.maybeCommit(fCommit);
|
---|
2524 | return None;
|
---|
2525 |
|
---|
2526 | def _doPopHint(self, aoStack, cStackEntries, dCounts, idTestSet):
|
---|
2527 | """ Executes a PopHint. """
|
---|
2528 | assert cStackEntries >= 0;
|
---|
2529 | while len(aoStack) > cStackEntries:
|
---|
2530 | if aoStack[0].enmStatus == TestResultData.ksTestStatus_Running:
|
---|
2531 | self._newFailureDetails(aoStack[0].idTestResult, idTestSet, 'XML error: Missing </Test>', dCounts);
|
---|
2532 | self._completeTestResults(aoStack[0], tsDone = None, cErrors = 1,
|
---|
2533 | enmStatus = TestResultData.ksTestStatus_Failure, fCommit = True);
|
---|
2534 | aoStack.pop(0);
|
---|
2535 | return True;
|
---|
2536 |
|
---|
2537 |
|
---|
2538 | @staticmethod
|
---|
2539 | def _validateElement(sName, dAttribs, fClosed):
|
---|
2540 | """
|
---|
2541 | Validates an element and its attributes.
|
---|
2542 | """
|
---|
2543 |
|
---|
2544 | #
|
---|
2545 | # Validate attributes by name.
|
---|
2546 | #
|
---|
2547 |
|
---|
2548 | # Validate integer attributes.
|
---|
2549 | for sAttr in [ 'errors', 'testdepth' ]:
|
---|
2550 | if sAttr in dAttribs:
|
---|
2551 | try:
|
---|
2552 | _ = int(dAttribs[sAttr]);
|
---|
2553 | except:
|
---|
2554 | return 'Element %s has an invalid %s attribute value: %s.' % (sName, sAttr, dAttribs[sAttr],);
|
---|
2555 |
|
---|
2556 | # Validate long attributes.
|
---|
2557 | for sAttr in [ 'value', ]:
|
---|
2558 | if sAttr in dAttribs:
|
---|
2559 | try:
|
---|
2560 | _ = long(dAttribs[sAttr]); # pylint: disable=R0204
|
---|
2561 | except:
|
---|
2562 | return 'Element %s has an invalid %s attribute value: %s.' % (sName, sAttr, dAttribs[sAttr],);
|
---|
2563 |
|
---|
2564 | # Validate string attributes.
|
---|
2565 | for sAttr in [ 'name', 'text' ]: # 'unit' can be zero length.
|
---|
2566 | if sAttr in dAttribs and not dAttribs[sAttr]:
|
---|
2567 | return 'Element %s has an empty %s attribute value.' % (sName, sAttr,);
|
---|
2568 |
|
---|
2569 | # Validate the timestamp attribute.
|
---|
2570 | if 'timestamp' in dAttribs:
|
---|
2571 | (dAttribs['timestamp'], sError) = ModelDataBase.validateTs(dAttribs['timestamp'], fAllowNull = False);
|
---|
2572 | if sError is not None:
|
---|
2573 | return 'Element %s has an invalid timestamp ("%s"): %s' % (sName, dAttribs['timestamp'], sError,);
|
---|
2574 |
|
---|
2575 |
|
---|
2576 | #
|
---|
2577 | # Check that attributes that are required are present.
|
---|
2578 | # We ignore extra attributes.
|
---|
2579 | #
|
---|
2580 | dElementAttribs = \
|
---|
2581 | {
|
---|
2582 | 'Test': [ 'timestamp', 'name', ],
|
---|
2583 | 'Value': [ 'timestamp', 'name', 'unit', 'value', ],
|
---|
2584 | 'FailureDetails': [ 'timestamp', 'text', ],
|
---|
2585 | 'Passed': [ 'timestamp', ],
|
---|
2586 | 'Skipped': [ 'timestamp', ],
|
---|
2587 | 'Failed': [ 'timestamp', 'errors', ],
|
---|
2588 | 'TimedOut': [ 'timestamp', 'errors', ],
|
---|
2589 | 'End': [ 'timestamp', ],
|
---|
2590 | 'PushHint': [ 'testdepth', ],
|
---|
2591 | 'PopHint': [ 'testdepth', ],
|
---|
2592 | };
|
---|
2593 | if sName not in dElementAttribs:
|
---|
2594 | return 'Unknown element "%s".' % (sName,);
|
---|
2595 | for sAttr in dElementAttribs[sName]:
|
---|
2596 | if sAttr not in dAttribs:
|
---|
2597 | return 'Element %s requires attribute "%s".' % (sName, sAttr);
|
---|
2598 |
|
---|
2599 | #
|
---|
2600 | # Only the Test element can (and must) remain open.
|
---|
2601 | #
|
---|
2602 | if sName == 'Test' and fClosed:
|
---|
2603 | return '<Test/> is not allowed.';
|
---|
2604 | if sName != 'Test' and not fClosed:
|
---|
2605 | return 'All elements except <Test> must be closed.';
|
---|
2606 |
|
---|
2607 | return None;
|
---|
2608 |
|
---|
2609 | @staticmethod
|
---|
2610 | def _parseElement(sElement):
|
---|
2611 | """
|
---|
2612 | Parses an element.
|
---|
2613 |
|
---|
2614 | """
|
---|
2615 | #
|
---|
2616 | # Element level bits.
|
---|
2617 | #
|
---|
2618 | sName = sElement.split()[0];
|
---|
2619 | sElement = sElement[len(sName):];
|
---|
2620 |
|
---|
2621 | fClosed = sElement[-1] == '/';
|
---|
2622 | if fClosed:
|
---|
2623 | sElement = sElement[:-1];
|
---|
2624 |
|
---|
2625 | #
|
---|
2626 | # Attributes.
|
---|
2627 | #
|
---|
2628 | sError = None;
|
---|
2629 | dAttribs = {};
|
---|
2630 | sElement = sElement.strip();
|
---|
2631 | while sElement:
|
---|
2632 | # Extract attribute name.
|
---|
2633 | off = sElement.find('=');
|
---|
2634 | if off < 0 or not sElement[:off].isalnum():
|
---|
2635 | sError = 'Attributes shall have alpha numberical names and have values.';
|
---|
2636 | break;
|
---|
2637 | sAttr = sElement[:off];
|
---|
2638 |
|
---|
2639 | # Extract attribute value.
|
---|
2640 | if off + 2 >= len(sElement) or sElement[off + 1] != '"':
|
---|
2641 | sError = 'Attribute (%s) value is missing or not in double quotes.' % (sAttr,);
|
---|
2642 | break;
|
---|
2643 | off += 2;
|
---|
2644 | offEndQuote = sElement.find('"', off);
|
---|
2645 | if offEndQuote < 0:
|
---|
2646 | sError = 'Attribute (%s) value is missing end quotation mark.' % (sAttr,);
|
---|
2647 | break;
|
---|
2648 | sValue = sElement[off:offEndQuote];
|
---|
2649 |
|
---|
2650 | # Check for duplicates.
|
---|
2651 | if sAttr in dAttribs:
|
---|
2652 | sError = 'Attribute "%s" appears more than once.' % (sAttr,);
|
---|
2653 | break;
|
---|
2654 |
|
---|
2655 | # Unescape the value.
|
---|
2656 | sValue = sValue.replace('<', '<');
|
---|
2657 | sValue = sValue.replace('>', '>');
|
---|
2658 | sValue = sValue.replace(''', '\'');
|
---|
2659 | sValue = sValue.replace('"', '"');
|
---|
2660 | sValue = sValue.replace('
', '\n');
|
---|
2661 | sValue = sValue.replace('
', '\r');
|
---|
2662 | sValue = sValue.replace('&', '&'); # last
|
---|
2663 |
|
---|
2664 | # Done.
|
---|
2665 | dAttribs[sAttr] = sValue;
|
---|
2666 |
|
---|
2667 | # advance
|
---|
2668 | sElement = sElement[offEndQuote + 1:];
|
---|
2669 | sElement = sElement.lstrip();
|
---|
2670 |
|
---|
2671 | #
|
---|
2672 | # Validate the element before we return.
|
---|
2673 | #
|
---|
2674 | if sError is None:
|
---|
2675 | sError = TestResultLogic._validateElement(sName, dAttribs, fClosed);
|
---|
2676 |
|
---|
2677 | return (sName, dAttribs, sError)
|
---|
2678 |
|
---|
2679 | def _handleElement(self, sName, dAttribs, idTestSet, aoStack, aaiHints, dCounts):
|
---|
2680 | """
|
---|
2681 | Worker for processXmlStream that handles one element.
|
---|
2682 |
|
---|
2683 | Returns None on success, error string on bad XML or similar.
|
---|
2684 | Raises exception on hanging offence and on database error.
|
---|
2685 | """
|
---|
2686 | if sName == 'Test':
|
---|
2687 | iNestingDepth = aoStack[0].iNestingDepth + 1 if aoStack else 0;
|
---|
2688 | aoStack.insert(0, self._newTestResult(idTestResultParent = aoStack[0].idTestResult, idTestSet = idTestSet,
|
---|
2689 | tsCreated = dAttribs['timestamp'], sName = dAttribs['name'],
|
---|
2690 | iNestingDepth = iNestingDepth, dCounts = dCounts, fCommit = True) );
|
---|
2691 |
|
---|
2692 | elif sName == 'Value':
|
---|
2693 | self._newTestValue(idTestResult = aoStack[0].idTestResult, idTestSet = idTestSet, tsCreated = dAttribs['timestamp'],
|
---|
2694 | sName = dAttribs['name'], sUnit = dAttribs['unit'], lValue = long(dAttribs['value']),
|
---|
2695 | dCounts = dCounts, fCommit = True);
|
---|
2696 |
|
---|
2697 | elif sName == 'FailureDetails':
|
---|
2698 | self._newFailureDetails(idTestResult = aoStack[0].idTestResult, idTestSet = idTestSet,
|
---|
2699 | tsCreated = dAttribs['timestamp'], sText = dAttribs['text'], dCounts = dCounts,
|
---|
2700 | fCommit = True);
|
---|
2701 |
|
---|
2702 | elif sName == 'Passed':
|
---|
2703 | self._completeTestResults(aoStack[0], tsDone = dAttribs['timestamp'],
|
---|
2704 | enmStatus = TestResultData.ksTestStatus_Success, fCommit = True);
|
---|
2705 |
|
---|
2706 | elif sName == 'Skipped':
|
---|
2707 | self._completeTestResults(aoStack[0], tsDone = dAttribs['timestamp'],
|
---|
2708 | enmStatus = TestResultData.ksTestStatus_Skipped, fCommit = True);
|
---|
2709 |
|
---|
2710 | elif sName == 'Failed':
|
---|
2711 | self._completeTestResults(aoStack[0], tsDone = dAttribs['timestamp'], cErrors = int(dAttribs['errors']),
|
---|
2712 | enmStatus = TestResultData.ksTestStatus_Failure, fCommit = True);
|
---|
2713 |
|
---|
2714 | elif sName == 'TimedOut':
|
---|
2715 | self._completeTestResults(aoStack[0], tsDone = dAttribs['timestamp'], cErrors = int(dAttribs['errors']),
|
---|
2716 | enmStatus = TestResultData.ksTestStatus_TimedOut, fCommit = True);
|
---|
2717 |
|
---|
2718 | elif sName == 'End':
|
---|
2719 | self._completeTestResults(aoStack[0], tsDone = dAttribs['timestamp'],
|
---|
2720 | cErrors = int(dAttribs.get('errors', '1')),
|
---|
2721 | enmStatus = TestResultData.ksTestStatus_Success, fCommit = True);
|
---|
2722 |
|
---|
2723 | elif sName == 'PushHint':
|
---|
2724 | if len(aaiHints) > 1:
|
---|
2725 | return 'PushHint cannot be nested.'
|
---|
2726 |
|
---|
2727 | aaiHints.insert(0, [len(aoStack), int(dAttribs['testdepth'])]);
|
---|
2728 |
|
---|
2729 | elif sName == 'PopHint':
|
---|
2730 | if len(aaiHints) < 1:
|
---|
2731 | return 'No hint to pop.'
|
---|
2732 |
|
---|
2733 | iDesiredTestDepth = int(dAttribs['testdepth']);
|
---|
2734 | cStackEntries, iTestDepth = aaiHints.pop(0);
|
---|
2735 | self._doPopHint(aoStack, cStackEntries, dCounts, idTestSet); # Fake the necessary '<End/></Test>' tags.
|
---|
2736 | if iDesiredTestDepth != iTestDepth:
|
---|
2737 | return 'PopHint tag has different testdepth: %d, on stack %d.' % (iDesiredTestDepth, iTestDepth);
|
---|
2738 | else:
|
---|
2739 | return 'Unexpected element "%s".' % (sName,);
|
---|
2740 | return None;
|
---|
2741 |
|
---|
2742 |
|
---|
2743 | def processXmlStream(self, sXml, idTestSet):
|
---|
2744 | """
|
---|
2745 | Processes the "XML" stream section given in sXml.
|
---|
2746 |
|
---|
2747 | The sXml isn't a complete XML document, even should we save up all sXml
|
---|
2748 | for a given set, they may not form a complete and well formed XML
|
---|
2749 | document since the test may be aborted, abend or simply be buggy. We
|
---|
2750 | therefore do our own parsing and treat the XML tags as commands more
|
---|
2751 | than anything else.
|
---|
2752 |
|
---|
2753 | Returns (sError, fUnforgivable), where sError is None on success.
|
---|
2754 | May raise database exception.
|
---|
2755 | """
|
---|
2756 | aoStack = self._getResultStack(idTestSet); # [0] == top; [-1] == bottom.
|
---|
2757 | if not aoStack:
|
---|
2758 | return ('No open results', True);
|
---|
2759 | self._oDb.dprint('** processXmlStream len(aoStack)=%s' % (len(aoStack),));
|
---|
2760 | #self._oDb.dprint('processXmlStream: %s' % (self._stringifyStack(aoStack),));
|
---|
2761 | #self._oDb.dprint('processXmlStream: sXml=%s' % (sXml,));
|
---|
2762 |
|
---|
2763 | dCounts = {};
|
---|
2764 | aaiHints = [];
|
---|
2765 | sError = None;
|
---|
2766 |
|
---|
2767 | fExpectCloseTest = False;
|
---|
2768 | sXml = sXml.strip();
|
---|
2769 | while sXml:
|
---|
2770 | if sXml.startswith('</Test>'): # Only closing tag.
|
---|
2771 | offNext = len('</Test>');
|
---|
2772 | if len(aoStack) <= 1:
|
---|
2773 | sError = 'Trying to close the top test results.'
|
---|
2774 | break;
|
---|
2775 | # ASSUMES that we've just seen an <End/>, <Passed/>, <Failed/>,
|
---|
2776 | # <TimedOut/> or <Skipped/> tag earlier in this call!
|
---|
2777 | if aoStack[0].enmStatus == TestResultData.ksTestStatus_Running or not fExpectCloseTest:
|
---|
2778 | sError = 'Missing <End/>, <Passed/>, <Failed/>, <TimedOut/> or <Skipped/> tag.';
|
---|
2779 | break;
|
---|
2780 | aoStack.pop(0);
|
---|
2781 | fExpectCloseTest = False;
|
---|
2782 |
|
---|
2783 | elif fExpectCloseTest:
|
---|
2784 | sError = 'Expected </Test>.'
|
---|
2785 | break;
|
---|
2786 |
|
---|
2787 | elif sXml.startswith('<?xml '): # Ignore (included files).
|
---|
2788 | offNext = sXml.find('?>');
|
---|
2789 | if offNext < 0:
|
---|
2790 | sError = 'Unterminated <?xml ?> element.';
|
---|
2791 | break;
|
---|
2792 | offNext += 2;
|
---|
2793 |
|
---|
2794 | elif sXml[0] == '<':
|
---|
2795 | # Parse and check the tag.
|
---|
2796 | if not sXml[1].isalpha():
|
---|
2797 | sError = 'Malformed element.';
|
---|
2798 | break;
|
---|
2799 | offNext = sXml.find('>')
|
---|
2800 | if offNext < 0:
|
---|
2801 | sError = 'Unterminated element.';
|
---|
2802 | break;
|
---|
2803 | (sName, dAttribs, sError) = self._parseElement(sXml[1:offNext]);
|
---|
2804 | offNext += 1;
|
---|
2805 | if sError is not None:
|
---|
2806 | break;
|
---|
2807 |
|
---|
2808 | # Handle it.
|
---|
2809 | try:
|
---|
2810 | sError = self._handleElement(sName, dAttribs, idTestSet, aoStack, aaiHints, dCounts);
|
---|
2811 | except TestResultHangingOffence as oXcpt:
|
---|
2812 | self._inhumeTestResults(aoStack, idTestSet, str(oXcpt));
|
---|
2813 | return (str(oXcpt), True);
|
---|
2814 |
|
---|
2815 |
|
---|
2816 | fExpectCloseTest = sName in [ 'End', 'Passed', 'Failed', 'TimedOut', 'Skipped', ];
|
---|
2817 | else:
|
---|
2818 | sError = 'Unexpected content.';
|
---|
2819 | break;
|
---|
2820 |
|
---|
2821 | # Advance.
|
---|
2822 | sXml = sXml[offNext:];
|
---|
2823 | sXml = sXml.lstrip();
|
---|
2824 |
|
---|
2825 | #
|
---|
2826 | # Post processing checks.
|
---|
2827 | #
|
---|
2828 | if sError is None and fExpectCloseTest:
|
---|
2829 | sError = 'Expected </Test> before the end of the XML section.'
|
---|
2830 | elif sError is None and aaiHints:
|
---|
2831 | sError = 'Expected </PopHint> before the end of the XML section.'
|
---|
2832 | if aaiHints:
|
---|
2833 | self._doPopHint(aoStack, aaiHints[-1][0], dCounts, idTestSet);
|
---|
2834 |
|
---|
2835 | #
|
---|
2836 | # Log the error.
|
---|
2837 | #
|
---|
2838 | if sError is not None:
|
---|
2839 | SystemLogLogic(self._oDb).addEntry(SystemLogData.ksEvent_XmlResultMalformed,
|
---|
2840 | 'idTestSet=%s idTestResult=%s XML="%s" %s'
|
---|
2841 | % ( idTestSet,
|
---|
2842 | aoStack[0].idTestResult if aoStack else -1,
|
---|
2843 | sXml[:min(len(sXml), 30)],
|
---|
2844 | sError, ),
|
---|
2845 | cHoursRepeat = 6, fCommit = True);
|
---|
2846 | return (sError, False);
|
---|
2847 |
|
---|
2848 |
|
---|
2849 |
|
---|
2850 |
|
---|
2851 |
|
---|
2852 | #
|
---|
2853 | # Unit testing.
|
---|
2854 | #
|
---|
2855 |
|
---|
2856 | # pylint: disable=C0111
|
---|
2857 | class TestResultDataTestCase(ModelDataBaseTestCase):
|
---|
2858 | def setUp(self):
|
---|
2859 | self.aoSamples = [TestResultData(),];
|
---|
2860 |
|
---|
2861 | class TestResultValueDataTestCase(ModelDataBaseTestCase):
|
---|
2862 | def setUp(self):
|
---|
2863 | self.aoSamples = [TestResultValueData(),];
|
---|
2864 |
|
---|
2865 | if __name__ == '__main__':
|
---|
2866 | unittest.main();
|
---|
2867 | # not reached.
|
---|
2868 |
|
---|