def testGetPlatformAutoLoadRecipes(self):
pd = proddef.ProductDefinition()
handle = conaryfacadetest.MockHandle()
handle.product = pd
handle.facade = mock.MockObject()
handle.getConfig().user = ('JeanValjean', 'password')
productStore = mock.MockInstance(dirstore.CheckoutProductStore)
productStore._mock.enableMethod('getPlatformAutoLoadRecipes')
productStore._mock.set(_handle=handle)
facade = conaryfacade.ConaryFacade(handle)
repos = conaryfacadetest.MockRepositoryClient()
self.mock(facade, '_getRepositoryClient', lambda: repos)
handle.facade._mock.set(conary=facade)
alr = productStore.getPlatformAutoLoadRecipes()
self.assertEquals(alr, [])
alRecipes = ['foo', 'bar']
for troveName in alRecipes:
pd.addPlatformAutoLoadRecipe(troveName)
pkg1 = self.makeTroveTuple('foo=/foo.rpath.com@foo:2/2-2-2')
groupTup1 = self.makeTroveTuple('group-foo=/foo.rpath.com@foo:1/1-1-1')
groupTrv1 = mock.MockObject(stableReturnValues=True)
groupTrv1.iterTroveList._mock.setDefaultReturn([pkg1])
self.mock(repos, 'getTroves', lambda *args, **kwargs: [groupTrv1])
pd.addSearchPath(groupTup1[0],
label=str(groupTup1[1].branch()),
version=str(groupTup1[1].trailingRevision()))
alr = productStore.getPlatformAutoLoadRecipes()
self.assertEquals(alr, ['foo=/foo.rpath.com@foo:2/2-2-2'])
def getProductLabelFromNameAndVersion(self, productName, versionName):
versionId = self.getBranchIdFromName(productName, versionName)
error, stream = self.server.getProductDefinitionForVersion(versionId)
if error:
raise errors.RbuilderError(*stream)
product = proddef.ProductDefinition(stream)
return product.getProductDefinitionLabel()
def getProductDefinition(cfg, version='1.0', upstream=None, buildFlavors=None):
p = proddef.ProductDefinition()
p.setBaseFlavor(str(cfg.buildFlavor))
p.setProductName('foo')
p.setProductDescription('foo')
p.setProductShortname('foo')
p.setProductVersion(version)
p.setProductVersionDescription('version description')
p.setConaryRepositoryHostname('localhost')
p.setConaryNamespace('foo')
p.setImageGroup('group-os')
p.addStage(name='devel', labelSuffix='-devel')
p.addStage(name='qa', labelSuffix='-qa')
p.addStage(name='stable', labelSuffix='')
if upstream:
if not isinstance(upstream, list):
upstream = [upstream]
for item in upstream:
upstreamName, upstreamLabel = item.split('=', 1)
p.addSearchPath(upstreamName, upstreamLabel)
if not buildFlavors:
buildFlavors = ['']
arch = deps.getMajorArch(cfg.buildFlavor)
for idx, buildFlavor in enumerate(buildFlavors):
buildFlavor = buildFlavor.strip()
if buildFlavor:
buildFlavor += ' '
buildFlavor += 'is: ' + arch
p.addBuildDefinition(name='build%s' % idx,
image=p.imageType('applianceIsoImage'),
stages=['devel', 'qa', 'stable'],
imageGroup='group-dist',
flavor=buildFlavor)
xmlsubs = p.xmlFactory()
platformClassifier = xmlsubs.platformClassifierTypeSub(tags='linux')
if platform_information is None:
platformInformation = xmlsubs.platformInformationTypeSub(
originLabel=str(cfg.buildLabel), )
platformInformation.set_platformClassifier(platformClassifier)
platformInformation.set_bootstrapTrove([])
platformInformation.set_rpmRequirement([])
else:
platformInformation = platform_information.PlatformInformation(
str(cfg.buildLabel),
platformClassifier=platformClassifier,
bootstrapTroves=[],
rpmRequirements=[],
)
def export(*args, **kwargs):
pass
platformInformation.export = export
p.setPlatformInformation(platformInformation)
return p
def testCore(self):
pd = proddef.ProductDefinition()
pd.setConaryRepositoryHostname('localhost')
pd.setConaryNamespace('rpl')
pd.setProductShortname('a')
pd.setProductVersion('1')
pd.addStage('foo', '')
pd.addStage('bar', '-bar')
productClass = mock.MockObject(stableReturnValues=True)
productClass._mock.setReturn(pd)
self.mock(proddef, 'ProductDefinition', productClass)
handle = self.getRbuildHandle()
p = abstract.ProductStore(handle)
proddefObj = p.getProduct()
_, kw = productClass._mock.popCall()
kw = dict(kw)
self.assertEquals(kw, {}) # no fromStream=
# get trivial errors out of the way first
self.assertRaises(errors.IncompleteInterfaceError, p.getStatus, 'asdf')
self.assertRaises(errors.IncompleteInterfaceError, p.getPackageJobId)
self.assertRaises(errors.IncompleteInterfaceError, p.getGroupJobId)
self.assertRaises(errors.IncompleteInterfaceError, p.getImageJobId)
self.assertRaises(errors.IncompleteInterfaceError, p.setPackageJobId,
1)
self.assertRaises(errors.IncompleteInterfaceError, p.setGroupJobId, 1)
self.assertRaises(errors.IncompleteInterfaceError, p.setImageJobId, 1)
self.assertRaises(errors.IncompleteInterfaceError,
p.getRbuildConfigData)
self.assertRaises(errors.RbuildError, p.getRbuildConfigPath)
self.assertRaises(errors.IncompleteInterfaceError,
p.getRmakeConfigData)
self.assertRaises(errors.RbuildError, p.getRmakeConfigPath)
handle.product = None
p.update()
self.assertEquals(handle.product, proddefObj)
self.assertEquals([x for x in p.iterStageNames()], ['foo', 'bar'])
self.assertEquals(p.getNextStageName('foo'), 'bar')
self.assertEquals(p.getNextStageName('bar'), None)
self.assertRaises(errors.RbuildError, p.checkStageIsValid, 'fdsa')
p._currentStage = None
self.assertRaises(errors.RbuildError, p.getActiveStageName)
mock.mockMethod(p.checkStageIsValid)
p.setActiveStageName('foo')
p.checkStageIsValid._mock.assertCalled('foo')
self.assertEquals(p.getActiveStageName(), 'foo')
self.assertEquals(p.getActiveStageLabel(), 'localhost@rpl:a-1')
def _newProduct(self, name='Foo', shortName='foo', description='More foo',
version='1.0', versionDescription='Super version 1.0',
conaryRepositoryHostname='cny.tv', conaryNamespace='ns'):
pd = proddef.ProductDefinition()
pd.setProductName(name)
pd.setProductShortname(shortName)
pd.setProductDescription(description)
pd.setProductVersion(version)
pd.setProductVersionDescription(versionDescription)
pd.setConaryRepositoryHostname(conaryRepositoryHostname)
pd.setConaryNamespace(conaryNamespace)
pd.setImageGroup('group-os')
return pd
def testGetBuildDefinitionGroupToBuild(self):
handle = self.getRbuildHandle()
productStore = abstract.ProductStore(handle)
product = proddef.ProductDefinition()
handle.product = product
mock.mockMethod(productStore.getSourceGroupMatch)
productStore.getSourceGroupMatch._mock.setDefaultReturn(
'group-source-match')
product.addBuildDefinition(imageGroup='group-foo',
sourceGroup='group-foo-source',
flavor='is: x86')
bd = product.buildDefinition[0]
results = productStore.getBuildDefinitionGroupToBuild(bd)
self.assertEquals(results, 'group-foo-source')
product.addBuildDefinition(imageGroup='group-bar',
sourceGroup='group-bar-source',
flavor='is: x86')
bd = product.buildDefinition[1]
results = productStore.getBuildDefinitionGroupToBuild(bd)
self.assertEquals(results, 'group-bar-source')
product.setSourceGroup('group-toplevel-source')
product.addBuildDefinition(imageGroup='group-bar',
flavor='is: x86')
bd = product.buildDefinition[2]
results = productStore.getBuildDefinitionGroupToBuild(bd)
self.assertEquals(results, 'group-toplevel-source')
product.addBuildDefinition(imageGroup='group-bar',
sourceGroup='group-bar-source',
flavor='is: x86')
bd = product.buildDefinition[3]
results = productStore.getBuildDefinitionGroupToBuild(bd)
self.assertEquals(results, 'group-bar-source')
product.setSourceGroup(None)
product.addBuildDefinition(imageGroup='group-bar',
flavor='is: x86')
bd = product.buildDefinition[4]
results = productStore.getBuildDefinitionGroupToBuild(bd)
self.assertEquals(results, 'group-source-match')
def testGetSourceGroupMatch(self):
handle = self.getRbuildHandle()
productStore = abstract.ProductStore(handle)
product = proddef.ProductDefinition()
product.setBaseFlavor('ssl,readline')
handle.product = product
product.addBuildDefinition(imageGroup='group-foo',
sourceGroup='group-foo-source',
flavor='is: x86')
product.addBuildDefinition(imageGroup='group-foo', flavor='is: x86')
bd = product.buildDefinition[1]
results = productStore.getSourceGroupMatch(bd)
self.assertEquals(results, 'group-foo-source')
product.addBuildDefinition(flavor='is: x86')
bd = product.buildDefinition[2]
results = productStore.getSourceGroupMatch(bd)
self.assertEquals(results, None)
def testGetGroupFlavors(self):
handle = self.getRbuildHandle()
productStore = abstract.ProductStore(handle)
product = proddef.ProductDefinition()
product.setBaseFlavor('ssl,readline')
handle.product = product
mock.mockMethod(productStore.getProduct)
productStore.getProduct._mock.setDefaultReturn(product)
# First, make sure that zero images defined is an error RBLD-171
self.assertRaises(errors.MissingImageDefinitionError,
productStore.getGroupFlavors)
# Now, test that the right flavor sets are found
product.addBuildDefinition(imageGroup='group-foo', flavor='is: x86')
product.addBuildDefinition(imageGroup='group-bar', flavor='is: x86_64')
results = productStore.getGroupFlavors()
# These flavors are too simplistic to work in practice! RBLD-172
x86Flavor = 'readline,ssl is: x86'
x8664Flavor = 'readline,ssl is: x86_64'
assert (results == [('group-foo', x86Flavor),
('group-bar', x8664Flavor)])
def getProductLabelFromNameAndVersion(self, productName, versionName):
#pylint: disable-msg=R0914
# not a great candidate for refactoring
productId = self.getProductId(productName)
error, versionList = self.server.getProductVersionListForProduct(
productId)
if error:
raise errors.RbuilderError(*versionList)
versionId = None
versionNames = []
# W0612: leave unused variables as documentation
# W0631: versionId is guaranteed to be defined
#pylint: disable-msg=W0612,W0631
for (versionId2, productId2, namespace, versionName2,
desc) in versionList:
versionNames.append(versionName2)
if versionName == versionName2:
versionId = versionId2
break
if versionId:
error, stream = self.server.getProductDefinitionForVersion(
versionId)
if error:
raise errors.RbuilderError(*stream)
product = proddef.ProductDefinition(stream)
return product.getProductDefinitionLabel()
else:
errstr = '%s is not a valid version for product %s.' % \
(versionName, productName)
if versionNames:
errstr += '\nValid versions are: %s' % \
', '.join(versionNames)
else:
errstr += '\nNo versions found for product %s.' % productName
raise errors.RbuildError(errstr)