def _validateAndConvertData(self, oData, enmValidateFor):
# type: (TestBoxDataEx, str) -> None
"""
Helper for addEntry and editEntry that validates the scheduling group IDs in
addtion to what's covered by the default validateAndConvert of the data object.
Raises exception on invalid input.
"""
dDataErrors = oData.validateAndConvert(self._oDb, enmValidateFor)
if len(dDataErrors) > 0:
raise TMInvalidData('TestBoxLogic.addEntry: %s' % (dDataErrors, ))
if isinstance(oData, TestBoxDataEx):
if len(oData.aoInSchedGroups):
sSchedGrps = ', '.join('(%s)' % oCur.idSchedGroup
for oCur in oData.aoInSchedGroups)
self._oDb.execute(
'SELECT SchedGroupIDs.idSchedGroup\n'
'FROM (VALUES ' + sSchedGrps +
' ) AS SchedGroupIDs(idSchedGroup)\n'
' LEFT OUTER JOIN SchedGroups\n'
' ON SchedGroupIDs.idSchedGroup = SchedGroups.idSchedGroup\n'
' AND SchedGroups.tsExpire = \'infinity\'::TIMESTAMP\n'
'WHERE SchedGroups.idSchedGroup IS NULL\n')
aaoRows = self._oDb.fetchAll()
if len(aaoRows) > 0:
raise TMInvalidData(
'TestBoxLogic.addEntry missing scheduling groups: %s' %
(', '.join(str(aoRow[0]) for aoRow in aaoRows), ))
return None
def editEntry(self, oData, uidAuthor, fCommit=False):
"""
Modifies a failure reason category.
"""
#
# Validate inputs and read in the old(/current) data.
#
assert isinstance(oData, FailureCategoryData)
dErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Edit)
if dErrors:
raise TMInvalidData('editEntry invalid input: %s' % (dErrors, ))
oOldData = FailureCategoryData().initFromDbWithId(
self._oDb, oData.idFailureCategory)
#
# Update the data that needs updating.
#
if not oData.isEqualEx(oOldData, [
'tsEffective',
'tsExpire',
'uidAuthor',
]):
self._historizeEntry(oData.idFailureCategory)
self._readdEntry(uidAuthor, oData)
self._oDb.maybeCommit(fCommit)
return True
def addEntry(self, oData, uidAuthor, fCommit=False):
"""
Adds a testgroup to the database.
"""
#
# Validate inputs.
#
assert isinstance(oData, TestGroupDataEx)
dErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Add)
if dErrors:
raise TMInvalidData('addEntry invalid input: %s' % (dErrors, ))
self._assertUniq(oData, None)
#
# Do the job.
#
self._oDb.execute(
'INSERT INTO TestGroups (uidAuthor, sName, sDescription, sComment)\n'
'VALUES (%s, %s, %s, %s)\n'
'RETURNING idTestGroup\n',
(uidAuthor, oData.sName, oData.sDescription, oData.sComment))
idTestGroup = self._oDb.fetchOne()[0]
oData.idTestGroup = idTestGroup
for oMember in oData.aoMembers:
oMember.idTestGroup = idTestGroup
self._insertTestGroupMember(uidAuthor, oMember)
self._oDb.maybeCommit(fCommit)
return True
def addBuildCategory(self, oData, fCommit=False):
"""
Add Build Category record into the database if needed, returning updated oData.
Raises exception on input and database errors.
"""
# Check BuildCategoryData before do anything
dDataErrors = oData.validateAndConvert(self._oDb,
oData.ksValidateFor_Add)
if dDataErrors:
raise TMInvalidData(
'Invalid data passed to addBuildCategory(): %s' %
(dDataErrors, ))
# Does it already exist?
if self.tryFindByData(oData) is None:
# No, We'll have to add it.
self._oDb.execute(
'INSERT INTO BuildCategories (sProduct, sRepository, sBranch, sType, asOsArches)\n'
'VALUES (%s, %s, %s, %s, %s)\n'
'RETURNING idBuildCategory', (
oData.sProduct,
oData.sRepository,
oData.sBranch,
oData.sType,
sorted(oData.asOsArches),
))
oData.idBuildCategory = self._oDb.fetchOne()[0]
self._oDb.maybeCommit(fCommit)
return oData
def editEntry(self, oData, uidAuthor, fCommit=False):
"""
Modifies a test result failure reason.
"""
#
# Validate inputs and read in the old(/current) data.
#
assert isinstance(oData, TestResultFailureData)
dErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Edit)
if len(dErrors) > 0:
raise TMInvalidData('editEntry invalid input: %s' % (dErrors, ))
oOldData = self.getById(oData.idTestResult)
oData.idTestSet = oOldData.idTestSet
#
# Update the data that needs updating.
#
if not oData.isEqualEx(oOldData, [
'tsEffective',
'tsExpire',
'uidAuthor',
]):
self._historizeEntry(oData.idTestResult)
self._readdEntry(uidAuthor, oData)
self._oDb.maybeCommit(fCommit)
return True
def addEntry(self, oData, uidAuthor, fCommit=False):
"""
Add a test result failure reason record.
"""
#
# Validate inputs and read in the old(/current) data.
#
assert isinstance(oData, TestResultFailureData)
dErrors = oData.validateAndConvert(self._oDb,
oData.ksValidateFor_AddForeignId)
if len(dErrors) > 0:
raise TMInvalidData('editEntry invalid input: %s' % (dErrors, ))
# Check if it exist first (we're adding, not editing, collisions not allowed).
oOldData = self.getById(oData.idTestResult)
if oOldData is not None:
raise TMRowAlreadyExists(
'TestResult %d already have a failure reason associated with it:'
'%s\n'
'Perhaps someone else beat you to it? Or did you try resubmit?'
% (oData.idTestResult, oOldData))
oData = self._resolveSetTestIdIfMissing(oData)
#
# Add record.
#
self._readdEntry(uidAuthor, oData)
self._oDb.maybeCommit(fCommit)
return True
def editEntry(self, oData, uidAuthor, fCommit=False):
"""Edit Scheduling Group record"""
#
# Validate input and retrieve the old data.
#
dErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Edit)
if dErrors:
raise TMInvalidData('editEntry got invalid data: %s' % (dErrors, ))
self._assertUnique(oData.sName, oData.idSchedGroup)
oOldData = SchedGroupDataEx().initFromDbWithId(self._oDb,
oData.idSchedGroup)
#
# Make the changes.
#
if not oData.isEqualEx(oOldData, [
'tsEffective',
'tsExpire',
'uidAuthor',
'aoMembers',
'aoTestBoxes',
'oBuildSrc',
'oBuildSrcValidationKit',
]):
self._historizeEntry(oData.idSchedGroup)
self._readdEntry(uidAuthor, oData)
# Remove groups.
for oOld in oOldData.aoMembers:
fRemove = True
for oNew in oData.aoMembers:
if oNew.idTestGroup == oOld.idTestGroup:
fRemove = False
break
if fRemove:
self._removeSchedGroupMember(uidAuthor, oOld)
# Add / modify groups.
for oMember in oData.aoMembers:
oOldMember = None
for oOld in oOldData.aoMembers:
if oOld.idTestGroup == oMember.idTestGroup:
oOldMember = oOld
break
oMember.idSchedGroup = oData.idSchedGroup
if oOldMember is None:
self._addSchedGroupMember(uidAuthor, oMember)
elif not oMember.isEqualEx(
oOldMember,
['tsEffective', 'tsExpire', 'uidAuthor', 'oTestGroup']):
self._historizeSchedGroupMember(oMember)
self._addSchedGroupMember(uidAuthor, oMember)
self._oDb.maybeCommit(fCommit)
return True
def editEntry(self, oData, uidAuthor, fCommit=False):
"""
Modifies a build source.
"""
#
# Validate the input and read the old entry.
#
dErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Edit)
if dErrors:
raise TMInvalidData('addEntry invalid input: %s' % (dErrors, ))
self._assertUnique(oData, oData.idBuildSrc)
oOldData = BuildSourceData().initFromDbWithId(self._oDb,
oData.idBuildSrc)
#
# Make the changes (if something actually changed).
#
if not oData.isEqualEx(oOldData, [
'tsEffective',
'tsExpire',
'uidAuthor',
]):
self._historizeBuildSource(oData.idBuildSrc)
self._oDb.execute(
'INSERT INTO BuildSources (\n'
' uidAuthor,\n'
' idBuildSrc,\n'
' sName,\n'
' sDescription,\n'
' sProduct,\n'
' sBranch,\n'
' asTypes,\n'
' asOsArches,\n'
' iFirstRevision,\n'
' iLastRevision,\n'
' cSecMaxAge)\n'
'VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)\n', (
uidAuthor,
oData.idBuildSrc,
oData.sName,
oData.sDescription,
oData.sProduct,
oData.sBranch,
oData.asTypes,
oData.asOsArches,
oData.iFirstRevision,
oData.iLastRevision,
oData.cSecMaxAge,
))
self._oDb.maybeCommit(fCommit)
return True
def addEntry(self, oData, uidAuthor, fCommit=False):
"""
Add a failure reason.
"""
#
# Validate.
#
dErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Add)
if dErrors:
raise TMInvalidData('addEntry invalid input: %s' % (dErrors, ))
#
# Add the record.
#
self._readdEntry(uidAuthor, oData)
self._oDb.maybeCommit(fCommit)
return True
def addEntry(self, oData, uidAuthor, fCommit=False):
"""
Add a failure reason category.
"""
#
# Validate inputs and read in the old(/current) data.
#
assert isinstance(oData, FailureCategoryData)
dErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Add)
if dErrors:
raise TMInvalidData('editEntry invalid input: %s' % (dErrors, ))
#
# Add the record.
#
self._readdEntry(uidAuthor, oData)
self._oDb.maybeCommit(fCommit)
return True
def addEntry(self, oData, uidAuthor, fCommit=False):
"""
Add a new build source to the database.
"""
#
# Validate the input.
#
dErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Add)
if dErrors:
raise TMInvalidData('addEntry invalid input: %s' % (dErrors, ))
self._assertUnique(oData, None)
#
# Add it.
#
self._oDb.execute(
'INSERT INTO BuildSources (\n'
' uidAuthor,\n'
' sName,\n'
' sDescription,\n'
' sProduct,\n'
' sBranch,\n'
' asTypes,\n'
' asOsArches,\n'
' iFirstRevision,\n'
' iLastRevision,\n'
' cSecMaxAge)\n'
'VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)\n', (
uidAuthor,
oData.sName,
oData.sDescription,
oData.sProduct,
oData.sBranch,
oData.asTypes,
oData.asOsArches,
oData.iFirstRevision,
oData.iLastRevision,
oData.cSecMaxAge,
))
self._oDb.maybeCommit(fCommit)
return True
def addEntry(self, oData, uidAuthor, fCommit = False):
"""Add Scheduling Group record"""
#
# Validate.
#
dDataErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Add);
if dDataErrors:
raise TMInvalidData('Invalid data passed to addEntry: %s' % (dDataErrors,));
if self.exists(oData.sName):
raise TMRowAlreadyExists('Scheduling group "%s" already exists.' % (oData.sName,));
#
# Add it.
#
self._oDb.execute('INSERT INTO SchedGroups (\n'
' uidAuthor,\n'
' sName,\n'
' sDescription,\n'
' fEnabled,\n'
' enmScheduler,\n'
' idBuildSrc,\n'
' idBuildSrcTestSuite,\n'
' sComment)\n'
'VALUES (%s, %s, %s, %s, %s, %s, %s, %s)\n'
'RETURNING idSchedGroup\n'
, ( uidAuthor,
oData.sName,
oData.sDescription,
oData.fEnabled,
oData.enmScheduler,
oData.idBuildSrc,
oData.idBuildSrcTestSuite,
oData.sComment ));
idSchedGroup = self._oDb.fetchOne()[0];
oData.idSchedGroup = idSchedGroup;
for oMember in oData.aoMembers:
oMember.idSchedGroup = idSchedGroup;
self._addSchedGroupMember(uidAuthor, oMember);
self._oDb.maybeCommit(fCommit);
return True;
def editEntry(self, oData, uidAuthor=None, fCommit=False):
"""Modify database record"""
#
# Validate input and get current data.
#
dErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Edit)
if dErrors:
raise TMInvalidData('editEntry invalid input: %s' % (dErrors, ))
oOldData = BuildData().initFromDbWithId(self._oDb, oData.idBuild)
#
# Do the work.
#
if not oData.isEqualEx(oOldData,
['tsEffective', 'tsExpire', 'uidAuthor']):
self._historizeBuild(oData.idBuild)
self._oDb.execute(
'INSERT INTO Builds (uidAuthor,\n'
' idBuild,\n'
' tsCreated,\n'
' idBuildCategory,\n'
' iRevision,\n'
' sVersion,\n'
' sLogUrl,\n'
' sBinaries,\n'
' fBinariesDeleted)\n'
'VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)\n'
'RETURNING idBuild, tsCreated\n', (
uidAuthor,
oData.idBuild,
oData.tsCreated,
oData.idBuildCategory,
oData.iRevision,
oData.sVersion,
oData.sLogUrl,
oData.sBinaries,
oData.fBinariesDeleted,
))
self._oDb.maybeCommit(fCommit)
return True
def editEntry(self, oData, uidAuthor, fCommit = False):
"""
Modifies a blacklisting.
"""
#
# Validate inputs and read in the old(/current) data.
#
assert isinstance(oData, BuildBlacklistData);
dErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Edit);
if dErrors:
raise TMInvalidData('editEntry invalid input: %s' % (dErrors,));
oOldData = BuildBlacklistData().initFromDbWithId(self._oDb, oData.idBlacklisting);
#
# Update the data that needs updating.
#
if not oData.isEqualEx(oOldData, [ 'tsEffective', 'tsExpire', 'uidAuthor', ]):
self._historizeEntry(oData.idBlacklisting, None);
self._readdEntry(uidAuthor, oData, None);
self._oDb.maybeCommit(fCommit);
return True;
def editEntry(self, oData, uidAuthor, fCommit=False):
"""
Modifies a test group.
"""
#
# Validate inputs and read in the old(/current) data.
#
assert isinstance(oData, TestGroupDataEx)
dErrors = oData.validateAndConvert(self._oDb, oData.ksValidateFor_Edit)
if dErrors:
raise TMInvalidData('editEntry invalid input: %s' % (dErrors, ))
self._assertUniq(oData, oData.idTestGroup)
oOldData = TestGroupDataEx().initFromDbWithId(self._oDb,
oData.idTestGroup)
#
# Update the data that needs updating.
#
if not oData.isEqualEx(oOldData, [
'aoMembers',
'tsEffective',
'tsExpire',
'uidAuthor',
]):
self._historizeTestGroup(oData.idTestGroup)
self._oDb.execute(
'INSERT INTO TestGroups\n'
' (uidAuthor, idTestGroup, sName, sDescription, sComment)\n'
'VALUES (%s, %s, %s, %s, %s)\n',
(uidAuthor, oData.idTestGroup, oData.sName, oData.sDescription,
oData.sComment))
# Create a lookup dictionary for old entries.
dOld = {}
for oOld in oOldData.aoMembers:
dOld[oOld.idTestCase] = oOld
assert len(dOld) == len(oOldData.aoMembers)
# Add new members, updated existing ones.
dNew = {}
for oNewMember in oData.aoMembers:
oNewMember.idTestGroup = oData.idTestGroup
if oNewMember.idTestCase in dNew:
raise TMRowAlreadyExists(
'Duplicate test group member: idTestCase=%d (%s / %s)' % (
oNewMember.idTestCase,
oNewMember,
dNew[oNewMember.idTestCase],
))
dNew[oNewMember.idTestCase] = oNewMember
oOldMember = dOld.get(oNewMember.idTestCase, None)
if oOldMember is not None:
if oNewMember.isEqualEx(
oOldMember, ['uidAuthor', 'tsEffective', 'tsExpire']):
continue
# Skip, nothing changed.
self._historizeTestGroupMember(oData.idTestGroup,
oNewMember.idTestCase)
self._insertTestGroupMember(uidAuthor, oNewMember)
# Expire members that have been removed.
sQuery = self._oDb.formatBindArgs(
'UPDATE TestGroupMembers\n'
'SET tsExpire = CURRENT_TIMESTAMP\n'
'WHERE idTestGroup = %s\n'
' AND tsExpire = \'infinity\'::TIMESTAMP\n',
(oData.idTestGroup, ))
if dNew:
sQuery += ' AND idTestCase NOT IN (%s)' % (', '.join(
[str(iKey) for iKey in dNew]), )
self._oDb.execute(sQuery)
self._oDb.maybeCommit(fCommit)
return True
