def _mock(self, data=None, buildData=None):
self.data.update(data or {})
self.data['data'].update(buildData or {})
self.vmwareDisk = disk = mock.MockObject()
def mockMakeHDImage(image):
buf = ''.join(chr(x) for x in range(32, 128))
f = file(image, "w")
for i in range(1024*1024):
f.write(buf)
f.flush()
disk._mock.set(totalSize=f.tell(), image=image)
return disk
img = self.GeneratorClass(self.slaveCfg, self.data)
img.swapSize = 4 * 1024 * 1024
img.makeHDImage = mockMakeHDImage
origLogCall = vmware_image.logCall
self.logCallArgs = logCallArgs = []
def mockLogCall(cmd, **kw):
logCallArgs.append((cmd, kw))
if cmd[0] != '/usr/bin/raw2vmdk':
return origLogCall(cmd, **kwargs)
hdImage = cmd[-2]
outfile = cmd[-1]
assert os.path.exists(hdImage)
with open(outfile, 'w') as f:
f.seek(1000000)
f.truncate()
self.mock(vmware_image, 'logCall', mockLogCall)
mock.mockMethod(img.downloadChangesets)
mock.mockMethod(img.postOutput)
self.img = img
return img
def testWriteLayerWithDeletions(self):
img = docker.DockerImage(self.slaveCfg, self.data)
mock.mockMethod(img.status)
layersDir = os.path.join(img.workDir, "docker-image/layers")
unpackDir = os.path.join(img.workDir, "docker-image/unpacked")
explodedDir = os.path.join(self.workDir, "exploded")
docker.util.mkdirChain(explodedDir)
regularFilePath = os.path.join(explodedDir, 'regular-file')
deletedFilePath = os.path.join(explodedDir, 'deleted-file')
symlinkFile = os.path.join(explodedDir, 'symlink-file')
file(regularFilePath, "w").write('a')
file(deletedFilePath, "w")
os.symlink("regular-file", symlinkFile)
unpackDir2 = os.path.join(self.workDir, 'unpacked')
docker.util.mkdirChain(os.path.join(unpackDir2, 'deleted-file'))
origStat = os.lstat
def mockStat(fname):
if fname.endswith('deleted-file'):
obj = mock.MockObject(st_mode=docker.stat.S_IFCHR,
st_rdev=0)
return obj
return origStat(fname)
self.mock(os, 'lstat', mockStat)
origOpen = os.open
def mockOpen(fname, mode, perms=0644):
if fname.endswith('deleted-file'):
perms = 0755
return origOpen(fname, mode, perms)
self.mock(os, 'open', mockOpen)
def mockMknod(fname, mode, dev):
file(fname, "w").write("Mocked")
self.mock(os, 'mknod', mockMknod)
imgSpec = docker.ImageSpec(name='foo', dockerImageId='aaaa-bb-cc',
nvf=docker.TroveTuple('group-foo=/cny.tv@ns:1/123.45:1-2-3[is: x86_64]'))
img.writeLayer(explodedDir, layersDir, imgSpec, withDeletions=True)
# Make sure we've reverted back to the ovf-marked deleted file
self.assertEqual(file(deletedFilePath).read(), "Mocked")
# Make sure the tarball has a .wh.deleted-file
tarfilePath = os.path.join(layersDir, imgSpec.dockerImageId, 'layer.tar')
tf = docker.tarfile.open(tarfilePath)
deleted = [ x for x in tf if x.name == './.wh.deleted-file' ]
self.assertEqual([ x.mode for x in deleted ], [ 0755 ])
# Now try to extract the layer
self.unmock()
mockTF = mock.MockObject()
mockTF._mock._dict[0] = mock.MockObject(name='./regular-file')
mockTF._mock._dict[1] = mock.MockObject(name='./.wh.deleted-file',
mode=0)
def mockOpen(fpath):
return mockTF
self.mock(docker.tarfile, 'open', mockOpen)
img._extractLayer(unpackDir2, tarfilePath)
# We should have only the regular file
self.assertEqual(sorted(os.listdir(unpackDir2)),
[ 'regular-file', 'symlink-file', ])
def testDelete(self):
handle = self.handle
mock.mockMethod(handle.facade.rbuilder.getImageDefs)
mock.mock(handle, 'product')
mock.mock(handle, 'productStore')
mock.mock(handle.ui, 'getYn')
handle.product.getProductShortname._mock.setReturn('project')
handle.product.getProductVersion._mock.setReturn('branch')
class MockBuildDefinition(object):
""" substitutes for both the robj and the product build definitions """
def __init__(self, name):
self.name = name
def export(self, f, level=0, namespace_=''):
""" this will create 'IDs' that are md5sums of the name """
f.write(self.name)
buildDefinitions = [ MockBuildDefinition('one'), MockBuildDefinition('two'), ]
handle.product._mock.set(buildDefinition=buildDefinitions)
handle.facade.rbuilder.getImageDefs._mock.setReturn(
[ buildDefinitions[0] ],
id='f97c5d29941bfb1b2fdab0874906ab82', product='project', version='branch')
handle.ui.getYn._mock.setReturn(True, "Delete one?", default=False)
handle.productStore.getProductDefinitionXmlPath._mock.setReturn(
'%s/productstore.xml' % self.workDir)
handle.ImageDefs.delete('f97c5d29941bfb1b2fdab0874906ab82')
self.assertEquals(len(buildDefinitions), 1)
self.assertEquals(buildDefinitions[0].name, 'two')
handle.productStore.commit._mock.assertCalled(message="Remove image def one")
handle.productStore.update._mock.assertCalled()
def testCreateProjectInteractive(self):
handle = self.getRbuildHandle(mock.MockObject())
handle.Create.registerCommands()
handle.CreateProjectBranch.registerCommands()
handle.CreateProjectBranch.initialize()
mock.mockMethod(handle.facade.rbuilder.createProject)
mock.mock(handle, 'ui')
handle.ui.getResponse._mock.appendReturn(
'project name', "Project name (required)", required=True)
handle.ui.getResponse._mock.appendReturn(
'desc', "Project description (optional)")
handle.ui.getResponse._mock.appendReturn(
'shortname', "Unique name (required)",
validationFn=handle.facade.rbuilder.isValidShortName,
required=True)
handle.ui.getResponse._mock.appendReturn(
'domain.name', "Domain name (blank for default)",
validationFn=handle.facade.rbuilder.isValidDomainName)
cmd = handle.Commands.getCommandClass('create')()
cmd.runCommand(handle, {}, ['rbuild', 'create', 'project'])
handle.facade.rbuilder.createProject._mock.assertCalled(
title='project name',
shortName='shortname',
domainName='domain.name',
description='desc',
)
def testCreateRmakeJobForExactPackages(self):
handle = self.getRbuildHandle()
from rbuild_plugins.build import packages
handle.productStore = mock.MockObject()
handle.productStore.getGroupFlavors._mock.setReturn([(None, 'a')])
mock.mockMethod(handle.facade.rmake._getRmakeContexts)
handle.facade.rmake._getRmakeContexts._mock.setReturn({'a': 'ACTX'})
packageRecipes = {'foo': self.workDir + '/foo/foo.recipe'}
groupRecipes = {
'group-baz': self.workDir + '/group-baz/group-baz.recipe'}
handle.productStore.getEditedRecipeDicts._mock.setReturn(
(packageRecipes, groupRecipes))
mock.mockMethod(handle.facade.rmake.createBuildJobForStage)
# normal
packages.createRmakeJobForPackages(handle,
['foo', 'bar', 'group-baz'], False)
handle.facade.rmake.createBuildJobForStage._mock.assertCalled(
[self.workDir + '/foo/foo.recipe{ACTX}', 'bar{ACTX}',
self.workDir + '/group-baz/group-baz.recipe{ACTX}'],
recurse=False, rebuild=False, useLocal=True)
# no group flavors
handle.productStore.getGroupFlavors._mock.setReturn([])
err = self.assertRaises(errors.PluginError,
packages.createRmakeJobForPackages, handle, ['foo', 'bar'], False)
self.failUnlessEqual(str(err), "no image flavors defined; don't know "
"what to build")
def setUp(self):
testcase.TestCaseWithWorkDir.setUp(self)
# Delete all root handlers
for handler in logging.root.handlers:
logging.root.removeHandler(handler)
logging.basicConfig(level=logging.DEBUG)
self.logHandler = logging.root.handlers[0]
mock.mockMethod(self.logHandler.handle)
self.cfg = config.UpsrvConfig()
self.cfg.downloadDB = "sqlite:///%s/%s" % (self.workDir, "upsrv.sqlite")
salt = file("/dev/urandom").read(8).encode('hex')
self.cfg.configLine('password %s %s' % (
self.Username, crypt.crypt(self.Password, '$1$%s$' % salt)))
self.wcfg = app.configure(self.cfg)
maker = self.wcfg.registry.settings['db.sessionmaker']
# New maker, without extensions, we don't need transaction
# management
makerArgs = maker.kw.copy()
del makerArgs['extension']
maker = maker.__class__(**makerArgs)
conn = maker()
db.schema.updateSchema(conn)
conn.commit()
self.conn = conn
self.app = self.wcfg.make_wsgi_app()
# Mock the conary config object
self.conaryCfg = conarycfg.ConaryConfiguration(False)
self.conaryCfg.root = "%s/%s" % (self.workDir, "__root__")
mock.mock(conarycfg, 'ConaryConfiguration', self.conaryCfg)
def testBuildJob(self):
_, facade = self.prep()
mock.mockMethod(facade._getRmakeHelper)
client = mock.MockObject()
facade._getRmakeHelper._mock.setDefaultReturn(client)
facade.buildJob(1)
client.buildJob._mock.assertCalled(1)
def testShowJobStatus(self):
handle = self.getRbuildHandle(mock.MockObject())
handle.Show.registerCommands()
handle.productStore.getPackageJobId._mock.setReturn(10)
mock.mockMethod(handle.facade.rmake.displayJob)
handle.Show.showJobStatus(10)
handle.facade.rmake.displayJob._mock.assertCalled(10)
def testWatchJob(self):
handle = self.getRbuildHandle()
mock.mockMethod(handle.facade.rmake.watchJob)
handle.facade.rmake.watchJob._mock.setReturn(2, 1)
ret = handle.Build.watchJob(1)
handle.facade.rmake.watchJob._mock.assertCalled(1)
self.assertEquals(ret, 2)
def testRaiseErrorIfProddefSchemaIncompatible(self):
handle = self.getRbuildHandle()
from rbuild_plugins.rebase import proddef
from rbuild_plugins.rebase import IncompatibleProductDefinitionError
from rbuild_plugins.rebase import OlderProductDefinitionError
rbuilder = handle.facade.rbuilder
mock.mockMethod(rbuilder.getProductDefinitionSchemaVersion)
mock.mock(proddef, 'ProductDefinition')
proddef.ProductDefinition._mock.set(version='4.0')
# client newer than server, no change in schema version
rbuilder.getProductDefinitionSchemaVersion._mock.setReturn('2.0')
self.failUnlessEqual('2.0',
handle.Rebase._getrBuilderProductDefinitionSchemaVersion('2.0'))
# client newer than server, change in schema version
self.failUnlessEqual('2.0',
handle.Rebase._getrBuilderProductDefinitionSchemaVersion('1.0'))
# client same version as server
rbuilder.getProductDefinitionSchemaVersion._mock.setReturn('4.0')
self.failUnlessEqual('4.0',
handle.Rebase._getrBuilderProductDefinitionSchemaVersion('4.0'))
# client older than server
rbuilder.getProductDefinitionSchemaVersion._mock.setReturn('5.0')
self.failUnlessRaises(OlderProductDefinitionError,
handle.Rebase._getrBuilderProductDefinitionSchemaVersion,
'4.0')
self.failUnlessRaises(IncompatibleProductDefinitionError,
handle.Rebase._getrBuilderProductDefinitionSchemaVersion,
'4.0')
def testModifiedFileNames(self):
handle = self.getRbuildHandle()
cf = handle.facade.conary
mock.mockMethod(cf.getCheckoutStatus)
cf.getCheckoutStatus._mock.setReturn((('A', '/p/1'), ('M', '/p/2')),
'/p')
self.assertEquals(handle.Rebase._modifiedFileNames('/p'), ['/p/2'])
def testCreateBranchInteractive(self):
handle = self.getRbuildHandle(mock.MockObject())
handle.Create.registerCommands()
handle.CreateProjectBranch.registerCommands()
handle.CreateProjectBranch.initialize()
mock.mockMethod(handle.facade.rbuilder.listPlatforms)
mock.mockMethod(handle.facade.rbuilder.createBranch)
mock.mock(handle, 'ui')
Platform = namedtuple('Platform', 'platformName label id')
rb = handle.facade.rbuilder
rb.listPlatforms._mock.setReturn([
Platform('the platform', 'the@platform', 'http://the/platform'),
Platform('not platform', 'not@platform', 'http://not/platform'),
])
handle.ui.getResponse._mock.appendReturn('proj', "Project name", validationFn=rb.isValidShortName)
handle.ui.getResponse._mock.appendReturn('branch', "Branch name", validationFn=rb.isValidBranchName)
handle.ui.input._mock.appendReturn('desc', "Branch description (optional): ")
handle.ui.input._mock.appendReturn('nsp', "Namespace (blank for default): ")
choiceArgs = ("Platform", [
'the platform - the@platform',
'not platform - not@platform'],
"The following platforms are available:")
handle.ui.getChoice._mock.setReturn(0, *choiceArgs)
cmd = handle.Commands.getCommandClass('create')()
cmd.runCommand(handle, {}, ['rbuild', 'create', 'branch'])
rb.createBranch._mock.assertCalled(
project='proj',
name='branch',
platformLabel='the@platform',
namespace='nsp',
description='desc',
)
def testDelete(self):
handle = self.handle
_target1 = mock.MockObject(name="foo", id="1")
_target2 = mock.MockObject(name="bar", id="2")
mock.mockMethod(handle.facade.rbuilder.getTargets)
handle.facade.rbuilder.getTargets._mock.setReturn(
[_target1, _target2])
handle.facade.rbuilder.getTargets._mock.appendReturn(
[_target1], target_id="1")
handle.facade.rbuilder.getTargets._mock.appendReturn(
[], target_id="bar")
mock.mock(handle, "ui")
handle.ui.getYn._mock.setDefaultReturn(False)
handle.ui.getYn._mock.setReturn(True, "Delete foo?", default=False)
handle.ui.getYn._mock.setReturn(True, "Delete bar?", default=False)
handle.Targets.delete("1", force=True)
handle.facade.rbuilder.getTargets._mock.assertCalled(target_id="1")
handle.ui.getYn._mock.assertNotCalled()
_target1.delete._mock.assertCalled()
handle.Targets.delete("1")
handle.facade.rbuilder.getTargets._mock.assertCalled(target_id="1")
handle.ui.getYn._mock.assertCalled("Delete foo?", default=False)
_target1.delete._mock.assertCalled()
handle.Targets.delete("bar")
handle.facade.rbuilder.getTargets._mock.assertCalled(target_id="bar")
handle.facade.rbuilder.getTargets._mock.assertCalled()
handle.ui.getYn._mock.assertCalled("Delete bar?", default=False)
_target2.delete._mock.assertCalled()
def prepReposState(self, facade):
mock.mockMethod(facade._getRepositoryStateFromDirectory)
repos = mock.MockObject()
sourceState = mock.MockObject()
facade._getRepositoryStateFromDirectory._mock.setDefaultReturn(
[repos, sourceState])
return (repos, sourceState)
def testCreateBranchCmdline(self):
handle = self.getRbuildHandle(mock.MockObject())
handle.Create.registerCommands()
handle.CreateProjectBranch.initialize()
mock.mockMethod(handle.facade.rbuilder.listPlatforms)
mock.mockMethod(handle.facade.rbuilder.createBranch)
mock.mock(handle, 'ui')
Platform = namedtuple('Platform', 'platformName label id')
handle.facade.rbuilder.listPlatforms._mock.setReturn([
Platform('the platform', 'the@platform', 'http://the/platform'),
Platform('not platform', 'not@platform', 'http://not/platform'),
])
cmd = handle.Commands.getCommandClass('create')()
cmd.runCommand(handle, {
'project': 'proj',
'branch': 'branch',
'platform': 'the platform',
}, ['rbuild', 'create', 'branch'])
handle.facade.rbuilder.createBranch._mock.assertCalled(
project='proj',
name='branch',
platformLabel='the@platform',
namespace=None,
description='',
)
err = self.assertRaises(errors.PluginError,
cmd.runCommand, handle, {
'project': 'proj',
'branch': 'branch',
'platform': 'missing platform',
}, ['rbuild', 'create', 'branch'])
self.assertEquals(str(err),
"No platform matching term 'missing platform' was found")
def testDeleteNoImageDefs(self):
from rbuild_plugins import imagedefs
handle = self.handle
mock.mockMethod(handle.facade.rbuilder.getImageDefs)
mock.mock(handle, 'product')
mock.mock(handle, 'productStore')
mock.mock(handle.ui, 'getYn')
handle.product.getProductShortname._mock.setReturn('project')
handle.product.getProductVersion._mock.setReturn('branch')
buildDefinitions = [ ]
handle.product._mock.set(buildDefinition=buildDefinitions)
handle.facade.rbuilder.getImageDefs._mock.setReturn(
[ ],
id='f97c5d29941bfb1b2fdab0874906ab82', product='project', version='branch')
err = self.assertRaises(Exception,
handle.ImageDefs.delete, 'f97c5d29941bfb1b2fdab0874906ab82')
self.assertEquals(len(buildDefinitions), 0)
handle.productStore.update._mock.assertNotCalled()
handle.ui.getYn._mock.assertNotCalled()
self.assertEquals(str(err), "Unable to find imagedef with id "
"'f97c5d29941bfb1b2fdab0874906ab82' on branch version of "
"project project")
def testListNoProduct(self):
handle = self.handle
mock.mockMethod(handle.facade.rbuilder.getImages)
err = self.assertRaises(errors.MissingProductStoreError,
handle.ImageDefs.list)
self.assertIn('rbuild init', str(err))
def testGetCheckoutLog(self):
_, facade = self.prep()
repos, sourceState = self.prepReposState(facade)
sourceState.getName._mock.setDefaultReturn('name')
mock.mockMethod(facade._getRepositoryVersions)
mock.mockMethod(facade._getNewerRepositoryVersions)
facade._getRepositoryVersions._mock.setDefaultReturn(['1'])
facade._getNewerRepositoryVersions._mock.setDefaultReturn(['broken'])
flavor = mock.MockObject()
flavor._mock.setDefaultReturn(flavor)
self.mock(deps, 'Flavor', flavor)
trove = mock.MockObject()
repos.getTroves._mock.setReturn(trove, [('name', '1', flavor)])
mockedIterLogMessages = mock.MockObject()
mockedIterLogMessages._mock.setDefaultReturn(['asdf'])
self.mock(checkin, 'iterLogMessages', mockedIterLogMessages)
ret = facade.getCheckoutLog('targetDirName')
mockedIterLogMessages._mock.assertCalled(trove)
self.assertEquals(ret, ['asdf'])
facade._getNewerRepositoryVersions._mock.setDefaultReturn(['1'])
facade._getRepositoryVersions._mock.setDefaultReturn(['broken'])
ret = facade.getCheckoutLog('dir2', newerOnly=True)
mockedIterLogMessages._mock.assertCalled(trove)
self.assertEquals(ret, ['asdf'])
mock.mock(facade, '_getVersion')
facade._getVersion._mock.setReturn('1', 'string')
ret = facade.getCheckoutLog('dir3', versionList=['string'])
mockedIterLogMessages._mock.assertCalled(trove)
self.assertEquals(ret, ['asdf'])
def testCancel(self):
from rbuild_plugins import images
mock.mockMethod(self.handle.DescriptorConfig.createDescriptorData)
mock.mock(images, 'xobj')
_doc = mock.MockObject()
_doc._mock.enable('job')
images.xobj.Document._mock.setReturn(_doc)
_job = mock.MockObject()
_job._mock.enable('job_type', 'descriptor')
images.xobj.XObj._mock.setReturn(_job)
_image_action = mock.MockObject()
_image_action._mock.set(key=images.Images.CANCEL)
_image_action._root._mock.set(job_type='job_type',
descriptor='descriptor')
_image = mock.MockObject()
_image._mock.set(key=images.Images.CANCEL, image_id='10', status='100',
actions=[_image_action])
_image.jobs.append._mock.setReturn(_doc, _doc)
rv = self.handle.Images.cancel(_image)
self.assertEqual(rv, _doc)
self.assertEqual(rv.job, _job)
self.assertEqual('job_type', rv.job.job_type)
self.assertEqual('descriptor', rv.job.descriptor)
def testIterRepositoryDiff(self):
_, facade = self.prep()
repos, sourceState = self.prepReposState(facade)
ver = mock.MockObject()
lastver = mock.MockObject()
sourceState.getName._mock.setDefaultReturn('name')
sourceState.getVersion._mock.setDefaultReturn(ver)
mock.mockMethod(facade._getNewerRepositoryVersions)
facade._getNewerRepositoryVersions._mock.setDefaultReturn(['broken'])
mock.mock(facade, '_getVersion')
facade._getVersion._mock.setReturn(lastver, lastver)
mockedGetIterRdiff = mock.MockObject()
mockedGetIterRdiff._mock.setDefaultReturn(['asdf'])
self.mock(checkin, '_getIterRdiff', mockedGetIterRdiff)
output = [x for x in facade.iterRepositoryDiff('targetDirName',
lastver=lastver)]
mockedGetIterRdiff._mock.assertCalled(repos, ver.branch().label(),
'name', ver.asString(), lastver.asString())
self.assertEquals(output, ['asdf'])
facade._getNewerRepositoryVersions._mock.setDefaultReturn(
[None, None, None, lastver])
output = [x for x in facade.iterRepositoryDiff('targetDirName')]
mockedGetIterRdiff._mock.assertCalled(repos, ver.branch().label(),
'name', ver.asString(), lastver.asString())
self.assertEquals(output, ['asdf'])
def testPromoteGroups(self):
_, facade = self.prep()
client = mock.MockObject()
mock.mockMethod(facade._getConaryClient, client)
success = True
cs = mock.MockObject()
groupList = [('group-dist', '/localhost@rpl:devel/1.0-1-1', '')],
trv = mock.MockObject()
trv.getNewNameVersionFlavor._mock.setReturn(
('group-dist', VFS('/localhost@rpl:qa/1.0-1-1'), ''))
cs.iterNewTroveList()._mock.setList([trv])
client.createSiblingCloneChangeSet._mock.setReturn((success, cs),
{Label('localhost@rpl:devel'): Label('localhost@rpl:qa'),
Label('other@somewhere:else'): Label('localhost@rpl:qa'),
Label('yetanother@somewhere:else'): VFS('/localhost@rpl:qa')},
groupList, cloneSources=True)
mock.mockMethod(facade._getRepositoryClient)
repos = facade._getRepositoryClient()
rc = facade.promoteGroups(groupList,
{'localhost@rpl:devel': 'localhost@rpl:qa',
'other@somewhere:else': facade._getLabel('localhost@rpl:qa'),
'yetanother@somewhere:else': '/localhost@rpl:qa'}) # RBLD-91
assert(rc == [('group-dist', '/localhost@rpl:qa/1.0-1-1', '')])
repos.commitChangeSet._mock.assertCalled(cs)
# failureCase
success = False
client.createSiblingCloneChangeSet._mock.setReturn((success, None),
{Label('localhost@rpl:devel'): Label('localhost@rpl:qa')},
groupList, cloneSources=True)
err = self.assertRaises(errors.RbuildError,
facade.promoteGroups, groupList,
{'localhost@rpl:devel': 'localhost@rpl:qa'})
assert(str(err) == 'Promote failed.')
def testGetImage(self):
from rbuild_plugins import images
handle = self.handle
rb = handle.facade.rbuilder
_image1 = mock.MockObject(name="foo", trailing_version="1-1-1", id="1")
_image2 = mock.MockObject(name="foo", trailing_version="2-2-2", id="2")
kwargs = dict((x, x) for x in ("project", "stage", "branch"))
kwargs["order_by"] = "-time_created"
mock.mockMethod(rb.getImages, None)
rb.getImages._mock.appendReturn([_image1, _image2], name="foo",
**kwargs)
rb.getImages._mock.appendReturn([_image2], name="foo",
trailing_version="2-2-2", **kwargs)
rb.getImages._mock.appendReturn([_image1], image_id="1", **kwargs)
mock.mockMethod(handle.Images._getProductStage,
("project", "branch", "stage"))
self.assertRaises(images.MissingImageError, handle.Images.getImage, "5")
err = self.assertRaises(errors.PluginError, handle.Images.getImage,
"foo")
self.assertIn("Matched more than one image", str(err))
self.assertEqual(_image1, handle.Images.getImage("1"))
self.assertEqual(_image2, handle.Images.getImage("foo=2-2-2"))
def testFindPackageInSearchPaths(self):
_, facade = self.prep()
repos = mock.MockObject()
mock.mockMethod(facade._getRepositoryClient, repos)
groupSpecFoo = ('group-foo', 'localhost@rpl:1', deps.parseFlavor(''))
groupSpecBar = ('group-bar', 'localhost@rpl:1', deps.parseFlavor(''))
groupTup = self.makeTroveTuple('group-foo=localhost@rpl:1/1:1.0-1-1')
groupTup2 = self.makeTroveTuple(
'group-foo=localhost@rpl:1/2:2.0-2-1[is:x86]')
groupTupBar = self.makeTroveTuple(
'group-bar=localhost@rpl:1/3:1.0-1-1')
groupTrv = mock.MockObject(stableReturnValues=True)
repos.findTroves._mock.setReturn({groupSpecFoo : [groupTup, groupTup2],
groupSpecBar : [groupTupBar]},
None, [groupSpecFoo],
allowMissing = True)
repos.getTroves._mock.setReturn([groupTrv],
[groupTup2], withFiles=False)
iterator = mock.MockObject()
fooTup = self.makeTroveTuple('foo')
iterator._mock._dict[0] = fooTup
iterator._mock._dict[1] = self.makeTroveTuple('blah')
groupTrv.iterTroveList._mock.setDefaultReturn(iterator)
self.assertEquals(facade._findPackageInSearchPaths([groupSpecFoo], 'foo'),
[fooTup])
# when no groups are found, return nothing
repos.findTroves._mock.setReturn({}, None, [groupSpecFoo],
allowMissing = True)
self.assertEquals(facade._findPackageInSearchPaths([groupSpecFoo], 'foo'),
[])
def testRemoveNonRecipeFilesFromCheckout(self):
handle, facade = self.prep()
repos = mock.MockObject()
mock.mockMethod(facade._getRepositoryClient, repos)
mock.mock(state, 'ConaryStateFromFile')
conaryState = mock.MockObject(stableReturnValues=True)
state.ConaryStateFromFile._mock.setDefaultReturn(conaryState)
sourceState = conaryState.getSourceState()
iterator = sourceState.iterFileList()
iterator._mock.setList([('pathId', 'foo.recipe', 'fileId', 'version'),
('pathId2', 'bam', 'fileId', 'version'),
('pathId3', 'directory', 'fileId', 'version')])
os.mkdir(self.workDir + '/foo')
os.mkdir(self.workDir + '/foo/directory')
self.writeFile(self.workDir + '/foo/foo.recipe', 'recipe')
self.writeFile(self.workDir + '/foo/bam', 'otherfile')
facade._removeNonRecipeFilesFromCheckout(
self.workDir + '/foo/foo.recipe')
conaryState.write._mock.assertCalled(self.workDir + '/foo/CONARY')
sourceState.removeFile._mock.assertCalled('pathId2')
sourceState.removeFile._mock.assertCalled('pathId3')
assert(sorted(os.listdir(self.workDir + '/foo')) == ['foo.recipe'])
# one more time, this time raising error on attempt to unlink
mock.mock(os, 'unlink')
os.unlink._mock.raiseErrorOnAccess(OSError('foo', 'bar'))
self.writeFile(self.workDir + '/foo/bam', 'otherfile')
facade._removeNonRecipeFilesFromCheckout(
self.workDir + '/foo/foo.recipe')
handle.ui.warning._mock.assertCalled(
'cannot remove %s: %s', '%s/foo/bam' % self.workDir, 'bar')
def testShadowSource(self):
_, facade = self.prep()
troveTup = ('name', 'version', 'targetLabel')
mock.mock(facade, '_getVersion')
mock.mock(facade, '_getFlavor')
mock.mock(facade, '_getLabel')
mock.mockMethod(facade._getConaryClient)
facade._getConaryClient._mock.setDefaultReturn(mock.MockObject())
# First, test the error-return case
client = facade._getConaryClient()
client.createShadowChangeSet._mock.setDefaultReturn(None)
assert facade.shadowSource(*troveTup) == False
facade._getVersion._mock.assertCalled('version')
facade._getFlavor._mock.assertCalled()
facade._getLabel._mock.assertCalled('targetLabel')
# now test the existing-shadow case
facade._getConaryClient().createShadowChangeSet._mock.setDefaultReturn(
([troveTup], None))
assert facade.shadowSource(*troveTup) == troveTup
# finally, test the actually-created-a-shadow case
cs = mock.MockObject(stableReturnValues=True)
cs.isEmpty._mock.setDefaultReturn(False)
trvCs = cs.iterNewTroveList()[0]
trvCs.getNewNameVersionFlavor._mock.setDefaultReturn(troveTup)
facade._getConaryClient().createShadowChangeSet._mock.setDefaultReturn(
(None, cs))
assert(facade.shadowSource('name', 'version', 'targetLabel')
== troveTup)
def testCheckoutBinaryPackage(self):
_, facade = self.prep()
mock.mock(facade, '_getVersion')
mock.mock(facade, '_getFlavor')
mockConaryCfg = mock.MockObject()
mockConaryCfg._mock.enable('root')
mock.mockMethod(facade.getConaryConfig)
facade.getConaryConfig._mock.setDefaultReturn(mockConaryCfg)
# Pin callback object
callback = conaryfacade._QuietUpdateCallback()
self.mock(conaryfacade, '_QuietUpdateCallback', lambda: callback)
# quiet
savedArgs = []
doUpdateFn = lambda *args, **kwargs: mockedFunction(None, savedArgs,
None, *args, **kwargs)
self.mock(updatecmd, 'doUpdate', doUpdateFn)
facade.checkoutBinaryPackage('packageName', 'packageVersion',
'packageFlavor', 'targetDir')
self.assertEquals(mockConaryCfg.root, 'targetDir')
self.assertEquals(savedArgs, [
((mockConaryCfg, 'packageName=packageVersion[packageFlavor]'),
{'tagScript': None, 'callback': callback, 'depCheck': False})
])
# noisy
savedArgs = []
facade.checkoutBinaryPackage('packageName', 'packageVersion',
'packageFlavor', 'targetDir', quiet=False)
self.assertEquals(savedArgs, [
((mockConaryCfg, 'packageName=packageVersion[packageFlavor]'),
{'tagScript': None, 'callback': None, 'depCheck': False})
])
def testGetChoice(self):
h = self.getRbuildHandle()
choices = ["a", "b", "c"]
mock.mockMethod(h.ui.input)
h.ui.input._mock.setReturns(["", "x", "0", "4", "3"], "prompt [1-3]: ")
rc, txt = self.captureOutput(h.ui.getChoice, "prompt", choices)
self.assertEqual(rc, 2)
def testCreateImagesJobForStage(self):
handle, facade = self.prep()
handle.productStore.getActiveStageName._mock.setReturn('devel')
handle.productStore.getActiveStageLabel._mock.setReturn(
'localhost@rpl:devel')
handle.product.getProductShortname._mock.setReturn('product')
handle.product.getProductVersion._mock.setReturn('1')
build = mock.MockObject(containerTemplateRef='imageType')
build.getBuildImageGroup._mock.setReturn('group-foo')
build.getBuildName._mock.setReturn('Ann Image')
build.getBuildImage._mock.setReturn(mock.MockObject(containerFormat='imageType',
fields={'foo' : 'bar'}))
containerTemplate = mock.MockObject(fields={'foo': 'baz'})
handle.product.getContainerTemplate._mock.setReturn(
containerTemplate,
'imageType', None
)
flavor = deps.parseFlavor('foo')
handle.productStore.getBuildsWithFullFlavors._mock.setReturn(
[(build, flavor)],
'devel')
mock.mockMethod(facade._getRmakeHelper)
facade.createImagesJobForStage()
facade._getRmakeHelper().createImageJob._mock.assertCalled('product',
[(('group-foo', 'localhost@rpl:devel', flavor), 'imageType',
{'foo': 'bar'}, 'Ann Image')])
def testList(self):
handle = self.handle
mock.mockMethod(handle.facade.rbuilder.getTargets)
handle.Targets.list()
handle.facade.rbuilder.getTargets._mock.assertCalled()
def testCommandParsing(self):
handle = self.handle
cmd = handle.Commands.getCommandClass('delete')()
mock.mockMethod(handle.Images.delete)
mock.mockMethod(handle.ui.warning)
err = self.assertRaises(
errors.ParseError, cmd.runCommand, handle, {},
['rbuild', 'delete', 'images'])
self.assertIn('IMAGEID', str(err))
cmd.runCommand(handle, {}, ['rbuild', 'delete', 'images', '10', '11'])
handle.Images.delete._mock.assertCalled('10', False)
handle.Images.delete._mock.assertCalled('11', False)
cmd.runCommand(handle, {"force": True},
['rbuild', 'delete', 'images', '10'])
handle.Images.delete._mock.assertCalled('10', True)
cmd.runCommand(handle, {},
['rbuild', 'delete', 'images', '&^%&*%$^&$'])
handle.Images.delete._mock.assertNotCalled()
handle.ui.warning._mock.assertCalled(
"Cannot parse image id '&^%&*%$^&$'")
def testList(self):
handle = self.handle
mock.mockMethod(handle.facade.rbuilder.getImages)
mock.mockMethod(handle.Images._getProductStage)
handle.Images._getProductStage._mock.setReturn(
('project', 'branch', 'stage'))
handle.Images.list()
handle.facade.rbuilder.getImages._mock.assertCalled(project='project',
branch='branch',
stage='stage')
def testBuildAllImages(self):
handle = self.getRbuildHandle()
handle.productStore = mock.MockObject()
handle.product = mock.MockObject()
mock.mockMethod(handle.Build.warnIfOldProductDefinition)
mock.mockMethod(handle.facade.rbuilder.buildAllImagesForStage, [1])
rc = handle.BuildImages.buildImages()
self.assertEqual(rc, [1])
handle.facade.rbuilder.buildAllImagesForStage._mock.assertCalled(
buildNames=None)
handle.Build.warnIfOldProductDefinition._mock.assertCalled(
'building images')
def testRebaseCommandParsing(self):
handle = self.getRbuildHandle(mock.MockObject())
handle.Rebase.registerCommands()
handle.Rebase.initialize()
cmd = handle.Commands.getCommandClass('rebase')()
mock.mockMethod(handle.Rebase.rebaseProduct)
cmd.runCommand(handle, {}, ['rbuild', 'rebase', 'localhost@rpl:1'])
handle.Rebase.rebaseProduct._mock.assertCalled(
interactive=False, label='localhost@rpl:1', test=False)
cmd.runCommand(handle, {}, ['rbuild', 'rebase'])
handle.Rebase.rebaseProduct._mock.assertCalled(
interactive=False, label=None, test=False)
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.getImageJobIds)
self.assertRaises(errors.IncompleteInterfaceError, p.setPackageJobId, 1)
self.assertRaises(errors.IncompleteInterfaceError, p.setGroupJobId, 1)
self.assertRaises(errors.IncompleteInterfaceError, p.setImageJobIds, 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 testBuildGroups(self):
handle = self.getRbuildHandle()
from rbuild_plugins.build import groups
mock.mock(groups, 'createRmakeJobForGroups', 'group-foo')
mock.mockMethod(handle.facade.rmake.buildJob)
mock.mockMethod(handle.Build.warnIfOldProductDefinition)
handle.productStore = mock.MockObject()
handle.BuildGroups.buildGroups(['pkg1'])
groups.createRmakeJobForGroups._mock.assertCalled(handle, ['pkg1'])
handle.facade.rmake.buildJob._mock.assertCalled('group-foo')
handle.Build.warnIfOldProductDefinition._mock.assertCalled(
'building groups')
def testIsJobBuilt(self):
_, facade = self.prep()
client = mock.MockObject()
job = mock.MockObject()
job.isBuilt._mock.setDefaultReturn(True)
client.getJob._mock.setDefaultReturn(job)
mock.mockMethod(facade._getRmakeHelper, client)
rc = facade.isJobBuilt(1)
client.getJob._mock.assertCalled(1)
job.isBuilt._mock.assertCalled()
assert(rc==True)
def testNodeServer(self):
from rmake.messagebus import messages
from rmake.multinode import messages as mnmessages
from rmake.multinode import workernode
# test how the node responds to various messages sent in from our
# fake client.
server, sessionClient = self._setupMockNode()
trv = self.addComponent('simple:source', '1',
[('simple.recipe', recipes.simpleRecipe)])
# send a build command
buildTrove = self.newBuildTrove(1, *trv.getNameVersionFlavor())
m = mnmessages.BuildCommand('CMD-1', self.buildCfg, 1, buildTrove, [],
[], self.cfg.buildLabel,
targetNode='WORKER-foo')
# this should result in the command being queued...
mock.mockMethod(server.queueCommand)
mock.mockMethod(server.chrootManager.getRootFactory)
sessionClient.handle_message(m)
commandClass = server.queueCommand._mock.calls[0][0][0]
self.assertEquals(commandClass, command.BuildCommand)
commandClass = mock.mockClass(command.BuildCommand,
mock_enable=['pid'],
getCommandId=lambda: 'CMD-1',
isErrored=lambda: False)
server.queueCommand._mock.method(commandClass, self.cfg, 1, 'CMD-1')
assert(server.listQueuedCommands())
# pretend we forked this command...
mock.mockFunctionOnce(os, 'fork', 342)
server._serveLoopHook()
assert(server.listCommands())
# and now it's died...
mock.mockFunctionOnce(os, 'waitpid', (342, 0))
server._serveLoopHook()
assert(not server.listCommands())
self._check(sessionClient, mnmessages.CommandStatus,
destination='/commandstatus', commandId='CMD-1',
status=mnmessages.CommandStatus.COMPLETED)
# let's create another command, one that fails on initialization
commandClass = command.Command
def _raise(*args, **kw):
raise RuntimeError('foo')
mock.replaceFunctionOnce(commandClass, '__init__', _raise)
server.queueCommand._mock.method(commandClass, self.cfg, 'CMD-1')
server._serveLoopHook()
self._check(sessionClient, mnmessages.CommandStatus,
destination='/commandstatus', commandId='CMD-1',
status=mnmessages.CommandStatus.ERROR)
def testEdit(self):
h = self.handle
mock.mock(h, 'DescriptorConfig')
mock.mock(h.facade, 'rbuilder')
mock.mock(h, 'ui')
mock.mockMethod(h.Targets.configureTargetCredentials)
mock.mockMethod(h.getConfig)
rb = h.facade.rbuilder
# mock out target fetching
_target = mock.MockObject()
_target.target_configuration._mock.set(elements=list())
_target.target_type._mock.set(name='type')
_desc = mock.MockObject()
_ddata = mock.MockObject()
_ttype = mock.MockObject(
name="type",
descriptor_create_target=StringIO("descriptor xml"),
)
rb.getTargets._mock.setReturn([_target], name='foo')
rb.getTargetTypes._mock.setReturn([_ttype])
h.DescriptorConfig.createDescriptorData._mock.setReturn(_ddata,
fromStream="descriptor xml", defaults={})
rb.configureTarget._mock.setReturn(_target, _target, _ddata)
# no target 'bar'
rb.getTargets._mock.setReturn(None, name='bar')
err = self.assertRaises(errors.PluginError, h.Targets.edit, 'bar')
self.assertEqual("No target found with name 'bar'", str(err))
_config = mock.MockObject()
h.getConfig._mock.setReturn(_config)
rb.isAdmin._mock.setReturn(True, 'admin')
rb.isAdmin._mock.setReturn(False, 'user')
# user is not admin
_config._mock.set(user=('user', 'secret'))
h.Targets.edit('foo')
rb.configureTarget._mock.assertNotCalled()
h.Targets.configureTargetCredentials._mock.assertCalled(_target)
# user is admin
_config._mock.set(user=('admin', 'secret'))
h.Targets.edit('foo')
rb.configureTarget._mock.assertCalled(_target, _ddata)
h.Targets.configureTargetCredentials._mock.assertCalled(_target)
def testLoadRecipeClassFromCheckout(self):
_, facade = self.prep()
repos = mock.MockObject()
mock.mockMethod(facade._getRepositoryClient, repos)
mock.mockMethod(facade.getConaryConfig)
mock.mock(state, 'ConaryStateFromFile')
mock.mock(loadrecipe, 'RecipeLoader')
loader = mock.MockObject()
loadrecipe.RecipeLoader._mock.setDefaultReturn(loader)
loader.getRecipe._mock.setDefaultReturn('recipe')
result = facade._loadRecipeClassFromCheckout(self.workDir +
'/foo.recipe')
self.assertEquals(result, 'recipe')
def testBuildPackages(self):
handle = self.getRbuildHandle()
from rbuild_plugins.build import packages
mock.mock(packages, 'createRmakeJobForPackages', 'foo')
mock.mockMethod(handle.facade.rmake.buildJob)
mock.mockMethod(handle.Build.warnIfOldProductDefinition)
handle.productStore = mock.MockObject()
handle.BuildPackages.buildPackages(['pkg1'])
packages.createRmakeJobForPackages._mock.assertCalled(
handle, ['pkg1'], True)
handle.facade.rmake.buildJob._mock.assertCalled('foo')
handle.Build.warnIfOldProductDefinition._mock.assertCalled(
'building packages')
def testConaryCfgRepoUser(self):
homeDir = self.workDir + '/home'
os.mkdir(homeDir)
oldHome = os.environ['HOME']
try:
os.environ['HOME'] = homeDir
# update self.rbuildCfg
self.rbuildCfg.repositoryUser = [('bar.com', 'bar', 'barpass')]
# regenerate conaryrc-rbuild
handle = self.getRbuildHandle(productStore=mock.MockObject(),
mockOutput=False)
mock.mockMethod(handle.facade.conary._parseRBuilderConfigFile)
rc, out = self.captureOutput(
handle.Config.writeConaryConfiguration)
# Now test contents of synced conary/rmake config files
expectedTxt = '''\
# Include config file maintained by rBuild:
includeConfigFile ~/.conaryrc-rbuild
'''
txt = open(self.workDir + '/home/.conaryrc').read()
self.assertEqualsText(txt, expectedTxt)
self.assertEquals(
os.stat(self.workDir + '/home/.conaryrc').st_mode & 0777,
0600)
expectedTxt = '''\
# This file will be overwritten automatically by rBuild
# You can ignore it by removing the associated includeConfigFile
# line from ~/.conaryrc
# contact (Default: None)
contact http://bugzilla.rpath.com/
# name (Default: None)
name Test
# repositoryMap (Default: [])
repositoryMap []
# user (Default: [])
user bar.com bar barpass
user * test foo
'''
txt = open(self.workDir + '/home/.conaryrc-rbuild').read()
self.assertEqualsText(txt, expectedTxt)
self.assertEquals(
os.stat(self.workDir +
'/home/.conaryrc-rbuild').st_mode & 0777,
0600)
finally:
os.environ['HOME'] = oldHome
def testCheckout(self):
_, facade = self.prep()
mockConaryCfg = mock.MockObject()
mock.mockMethod(facade.getConaryConfig)
facade.getConaryConfig._mock.setDefaultReturn(mockConaryCfg)
mock.mockMethod(facade._getRepositoryClient)
facade._getRepositoryClient._mock.setDefaultReturn('r')
savedArgs = []
self.mock(checkin, 'checkout',
lambda *args: mockedFunction(None, savedArgs, None, *args))
facade.checkout('packageName', 'labelName', targetDir='targetDirName')
expectedArgs = [(('r', mockConaryCfg, 'targetDirName',
['packageName=labelName']), {})]
self.assertEquals(savedArgs, expectedArgs)
def testLatestPackages(self):
_, facade = self.prep()
client = mock.MockObject()
mock.mockMethod(facade._getConaryClient, client)
client.getRepos().getTroveLatestByLabel._mock.setReturn(
{
'foo': {
'foover': ['flav1', 'flav2']
},
'foo:runtime': {
'foover': ['flav1', 'flav2']
},
'bar': {
'barver': ['flav3']
},
'group-baz': {
'bazver': ['flav4']
},
}, {None: {
versions.Label('localhost@rpl:devel'): [None]
}})
# Defaults
packages = facade.getLatestPackagesOnLabel('localhost@rpl:devel')
self.failUnlessEqual(sorted(packages), [
('bar', 'barver', 'flav3'),
('foo', 'foover', 'flav1'),
('foo', 'foover', 'flav2'),
])
# With components
packages = facade.getLatestPackagesOnLabel('localhost@rpl:devel',
keepComponents=True)
self.failUnlessEqual(sorted(packages), [
('bar', 'barver', 'flav3'),
('foo', 'foover', 'flav1'),
('foo', 'foover', 'flav2'),
('foo:runtime', 'foover', 'flav1'),
('foo:runtime', 'foover', 'flav2'),
])
# With groups
packages = facade.getLatestPackagesOnLabel('localhost@rpl:devel',
keepGroups=True)
self.failUnlessEqual(sorted(packages), [
('bar', 'barver', 'flav3'),
('foo', 'foover', 'flav1'),
('foo', 'foover', 'flav2'),
('group-baz', 'bazver', 'flav4'),
])
def testRestartNoUpdate(self):
a = self.addComponent('a:source=1')
b = self.addComponent('b:source=1')
d = self.addComponent('d:source=1')
ia = self.addComponent('info-a:source=1')
ib = self.addComponent('info-b:source=1')
ibbb = self.addComponent('info-bob:source=1')
troveList1 = [a, b, ia, ib, ibbb]
a = self.addComponent('a:source=2')
#b = self.addComponent('b:source=2')
c = self.addComponent('c:source=2')
ia = self.addComponent('info-a:source=2')
ib = self.addComponent('info-b:source=2')
ibbb = self.addComponent('info-bob:source=2')
troveList2 = [a, b, ia, ib, ibbb]
self.buildCfg.buildTroveSpecs = [(x, None, None)
for x in ('a', 'b', 'd', 'info-a',
'info-b', 'info-bob')]
job = self.newJob(*troveList1)
jobId = job.jobId
helper = self.getRmakeHelper()
mock.mockMethod(helper.client.buildJob)
def _rebuild(updateSpecs=[], troveSpecs=[], excludeSpecs=[]):
self.discardOutput(helper.restartJob,
jobId,
troveSpecs=troveSpecs,
updateSpecs=updateSpecs,
excludeSpecs=excludeSpecs)
restartJob, = helper.client.buildJob._mock.popCall()[0]
nameVersion = sorted([(x[0].split(':')[0],
x[1].trailingRevision().getVersion())
for x in restartJob.iterTroveList()])
return nameVersion
nameVersion = _rebuild(updateSpecs=['info-*', '-info-b*', 'info-bob'],
troveSpecs=[('c', None, None)],
excludeSpecs=['d'])
self.assertEquals(nameVersion, [('a', '1'), ('b', '1'), ('c', '2'),
('info-a', '2'), ('info-b', '1'),
('info-bob', '2')])
nameVersion = _rebuild(updateSpecs=['-*'],
excludeSpecs=['d'],
troveSpecs=[('c', None, None)])
self.assertEquals(nameVersion, [('a', '1'), ('b', '1'), ('c', '2'),
('info-a', '1'), ('info-b', '1'),
('info-bob', '1')])
def testActOnTrove(self):
w = worker.Worker(self.rmakeCfg, log)
eventHandler = mock.MockObject()
mock.mockMethod(w.queueCommand)
trv = imagetrove.ImageTrove(1, *self.makeTroveTuple('group-foo'))
trv.logPath = self.workDir + '/log'
w.actOnTrove(trv.getCommand(), self.cfg, trv.jobId, trv, eventHandler,
None)
# this is a horrible API
w.queueCommand._mock.assertCalled
assertCalled = w.queueCommand._mock.assertCalled
assertCalled(w.commandClasses['image'], self.rmakeCfg,
'IMAGE-1-group-foo-1', trv.jobId, eventHandler, self.cfg,
trv, None, self.workDir + '/log')
def testCommandParsing(self):
handle = self.getRbuildHandle()
handle.Build.registerCommands()
handle.Build.initialize()
handle.BuildImages.initialize()
cmd = handle.Commands.getCommandClass('build')()
mock.mockMethod(handle.BuildImages.buildImages, 1)
mock.mockMethod(handle.Build.watchJob)
mock.mockMethod(handle.facade.rmake.isJobBuilt, True)
mock.mockMethod(handle.BuildImages.printImageUrlsForJob)
handle.productStore = mock.MockObject()
handle.product = mock.MockObject()
cmd.runCommand(handle, {}, ['rbuild', 'build', 'images'])
handle.BuildImages.buildImages._mock.assertCalled(None)
handle.Build.watchJob._mock.assertCalled(1)
handle.facade.rmake.isJobBuilt._mock.assertCalled(1)
cmd.runCommand(handle, {},
['rbuild', 'build', 'images', 'image 1', 'image 2'])
handle.BuildImages.buildImages._mock.assertCalled(
['image 1', 'image 2'])
cmd.runCommand(handle, {}, ['rbuild', 'build', 'images'])
cmd.runCommand(handle, {'no-watch': True},
['rbuild', 'build', 'images'])
handle.facade.rmake.isJobBuilt._mock.setDefaultReturn(False)
self.assertRaises(errors.PluginError, cmd.runCommand, handle, {},
['rbuild', 'build', 'images'])
def testGetResponse(self):
h = self.getRbuildHandle(mockOutput=False)
mock.mockMethod(h.ui.input)
h.ui.input._mock.setReturns(['invalid', '', 'valid'], 'prompt: ')
validationFn = lambda x: x == 'valid'
rc, txt = self.captureOutput(h.ui.getResponse,
'prompt',
validationFn=validationFn)
assert (rc == 'valid')
assert (txt == 'Empty response not allowed.\n')
h.ui.input._mock.setReturns([''], 'prompt (Default: default): ')
rc = h.ui.getResponse('prompt', default='default')
assert (rc == 'default')
def testCommandParsing(self):
handle = self.getRbuildHandle()
handle.List.registerCommands()
handle.Branches.initialize()
handle.List.initialize()
cmd = handle.Commands.getCommandClass('list')()
mock.mockMethod(handle.Branches.list)
err = self.assertRaises(errors.ParseError, cmd.runCommand, handle, {},
['rbuild', 'list', 'branches'])
cmd.runCommand(handle, {}, ['rbuild', 'list', 'branches', 'foo'])
handle.Branches.list._mock.assertCalled('foo')
def testCancelCommandParsing(self):
handle = self.getRbuildHandle(mock.MockObject())
handle.Cancel.registerCommands()
handle.Cancel.initialize()
cmd = handle.Commands.getCommandClass('cancel')()
mock.mockMethod(handle.Cancel.cancelImages)
cmd.runCommand(handle, {}, ['rbuild', 'cancel', 'images'])
handle.Cancel.cancelImages._mock.assertCalled([])
cmd.runCommand(handle, {}, ['rbuild', 'cancel', 'images', 'foo'])
handle.Cancel.cancelImages._mock.assertCalled(['foo'])
cmd.runCommand(handle, {},
['rbuild', 'cancel', 'images', 'foo', 'bar'])
handle.Cancel.cancelImages._mock.assertCalled(['foo', 'bar'])
def testCommandParsing(self):
handle = self.getRbuildHandle()
handle.Build.registerCommands()
handle.Build.initialize()
handle.BuildGroups.initialize()
cmd = handle.Commands.getCommandClass('build')()
mock.mockMethod(handle.BuildGroups.buildAllGroups, 1)
mock.mockMethod(handle.Build.watchAndCommitJob)
cmd.runCommand(handle, {}, ['rbuild', 'build', 'groups'])
handle.BuildGroups.buildAllGroups._mock.assertCalled()
handle.Build.watchAndCommitJob._mock.assertCalled(1, None)
mock.mockMethod(handle.BuildGroups.buildGroups, 1)
mock.mockMethod(handle.Build.watchJob)
cmd.runCommand(handle, {'no-commit': True},
['rbuild', 'build', 'groups', 'group-foo'])
handle.BuildGroups.buildGroups._mock.assertCalled(['group-foo'])
handle.Build.watchJob._mock.assertCalled(1)
cmd.runCommand(handle, {'no-watch': True},
['rbuild', 'build', 'groups', 'group-foo'])
handle.Build.watchJob._mock.assertNotCalled()
handle.Build.watchAndCommitJob._mock.setDefaultReturn(False)
self.assertRaises(errors.PluginError, cmd.runCommand, handle, {},
['rbuild', 'build', 'groups'])
def _setupMockNode(self):
from rmake.messagebus import messages
from rmake.multinode import messages as mnmessages
from rmake.multinode import workernode
# test how the node responds to various messages sent in from our
# fake client.
cfg = self.getNodeCfg()
server = workernode.rMakeWorkerNodeServer(cfg,
messageBusInfo=('localhost', None))
sessionClient = server.client.getBusClient().getSession()
mock.mockMethod(sessionClient.poll)
mock.mockMethod(sessionClient.connect)
mock.mockMethod(sessionClient.disconnect)
mock.mockMethod(sessionClient.messageProcessor.sendMessage)
mock.mock(sessionClient, 'logger')
sessionClient.handle_connect()
self._check(sessionClient, messages.ConnectionRequest,
sessionClass='WORKER')
m = messages.ConnectedResponse()
m.set(sessionId='WORKER-foo')
sessionClient.handle_message(m)
self._check(sessionClient, mnmessages.RegisterNodeMessage,
nodeType='WORKER', destination='/register')
self._check(sessionClient, messages.SubscribeRequest,
destination='/command?targetNode=WORKER-foo')
server._serveLoopHook()
self._check(sessionClient, mnmessages.NodeInfo,
destination='/nodestatus')
return server, sessionClient
def testRestartUpdatesResolveTroves(self):
self.openRmakeRepository()
jobId = fixtures.addBuiltJob1(self)
client = self.startRmakeServer()
helper = self.getRmakeHelper(client.uri)
# update the resolveTrove item: buildReq.
# make sure that restart finds the new version.
buildReq = fixtures.updateBuiltJob1BuildReq(self)
mock.mockMethod(helper.client.buildJob)
self.discardOutput(helper.restartJob, jobId)
(job, ), kw = helper.client.buildJob._mock.popCall()
assert (job.getMainConfig().resolveTroveTups == [[
buildReq.getNameVersionFlavor()
]])
def testBuildAllImagesForStage(self):
handle, facade = self.prep()
handle.product.getProductShortname._mock.setReturn('shortname')
handle.product.getProductVersion._mock.setReturn('1.0')
mock.mockMethod(facade._getRbuilderRPCClient)
client = facade._getRbuilderRPCClient()
client.startProductBuilds._mock.setReturn([1],
'shortname',
'1.0',
'devel',
buildNames=None,
groupSpecs=None)
buildIds = facade.buildAllImagesForStage()
self.assertEquals(buildIds, [1])
def testSaveProduct(self):
self._prepProductStore()
os.chdir('foo/stable')
handle = self.getRbuildHandle(productStore=mock.MockObject())
productStore = dirstore.CheckoutProductStore(handle)
mock.mockMethod(productStore._getSourceTroveVersion,
returnValue='cny.tv@ns:1/2-3')
prodDef = productStore.getProduct()
self.assertEqual(prodDef.getProductDescription(), 'More foo')
# Update the product definition, and make sure save will persist it
prodDef.setProductDescription("Even more foo")
productStore.save(prodDef)
prodDef = productStore.getProduct()
self.assertEqual(prodDef.getProductDescription(), 'Even more foo')
def testCallbackEnumeratedMultiple(self):
handle = self.getRbuildHandle(mock.MockObject())
callback = handle.DescriptorConfig.callbackClass(handle.ui)
fDef = handle.DescriptorConfig.descriptorClass()
fDef.addDataField('lotsaValues',
descriptions=[fDef.Description("foo")],
multiple=True,
type=fDef.EnumeratedType([
fDef.ValueWithDescription(
'one',
descriptions=[fDef.Description("One")]),
fDef.ValueWithDescription(
'two',
descriptions=[fDef.Description("Two")]),
]))
fDef.addDataField('lotsaValuesDefault',
descriptions=[fDef.Description("foodef")],
multiple=True,
default=['two'],
type=fDef.EnumeratedType([
fDef.ValueWithDescription(
'one',
descriptions=[fDef.Description("One")]),
fDef.ValueWithDescription(
'two',
descriptions=[fDef.Description("Two")]),
]))
mock.mockMethod(handle.ui.getChoices)
mock.mockMethod(handle.ui.getTerminalSize, (24, 80))
# field with no default
handle.ui.getChoices._mock.setReturn([0],
'Enter choice', ["One", "Two"],
default=None,
prePrompt="Pick foo:",
pageSize=21)
rv = callback.getValueForField(fDef.getDataField('lotsaValues'))
self.assertEqual(rv, ['one'])
# field with default
handle.ui.getChoices._mock.setReturn(
[0],
'Enter choice (blank for default)', ["One", "Two"],
default=[1],
prePrompt="Pick foodef:",
pageSize=21)
rv = callback.getValueForField(fDef.getDataField('lotsaValuesDefault'))
self.assertEqual(rv, ['one'])
def testCommandParsing(self):
handle = self.getRbuildHandle()
handle.List.registerCommands()
handle.List.initialize()
handle.Platforms.initialize()
cmd = handle.Commands.getCommandClass('list')()
mock.mockMethod(handle.Platforms.list)
_platform = mock.MockObject()
_platform._mock.enable('enabled')
_platform._mock.set(enabled='true')
handle.Platforms.list._mock.setReturn([_platform])
cmd.runCommand(handle, {}, ['rbuild', 'list', 'platforms'])
handle.Platforms.list._mock.assertCalled()
def testGetRemotePackage(self):
handle = self._getHandle()
checkout = handle.Checkout
conaryFacade = handle.facade.conary
fooTrove = self.makeTroveTuple('foo', 'foo.rpath.org@foo:1')
mock.mockMethod(conaryFacade._findTrove)
conaryFacade._findTrove._mock.setDefaultReturn(fooTrove)
self.assertEquals(checkout._getRemotePackage('foo',
'foo.rpath.org@foo:1'), fooTrove)
self.assertEquals(checkout._getRemotePackage('foo:source',
'foo.rpath.org@foo:1'), fooTrove)
conaryFacade._findTrove._mock.setDefaultReturn(None)
self.assertEquals(checkout._getRemotePackage('foo',
'foo.rpath.org@foo:1'), None)
def testRemoveThenRestart(self):
self.openRmakeRepository()
jobId = fixtures.addBuiltJob1(self)
self.markRemoved('testcase:source')
self.addComponent('simple:source')
client = self.startRmakeServer()
helper = self.getRmakeHelper(client.uri)
mock.mockMethod(helper.client.buildJob)
restartJobId = self.discardOutput(helper.restartJob,
jobId, ['simple:source'],
clearBuildList=True)
args, kw = helper.client.buildJob._mock.popCall()
troveTup, = list(args[0].iterTroveList())
assert (troveTup[0] == 'simple:source')
def testGetNewerRepositoryVersions(self):
_, facade = self.prep()
repos, sourceState = self.prepReposState(facade)
sourceState.getVersion._mock.setDefaultReturn(1)
ver0 = mock.MockObject()
ver1 = mock.MockObject()
ver2 = mock.MockObject()
ver0.isAfter._mock.setReturn(False, 1)
ver1.isAfter._mock.setReturn(False, 1)
ver2.isAfter._mock.setReturn(True, 1)
mock.mockMethod(facade._getRepositoryVersions)
facade._getRepositoryVersions._mock.setDefaultReturn(
[ver0, ver1, ver2])
output = facade._getNewerRepositoryVersions('.')
self.assertEquals(output, [ver2])
def testCreateNewPackageFactory(self):
_, facade = self.prep()
mock.mockMethod(facade._getRepositoryClient)
facade._getRepositoryClient._mock.setDefaultReturn('r')
mock.mockMethod(facade.getConaryConfig)
facade.getConaryConfig._mock.setDefaultReturn('c')
newTrove = mock.MockObject()
self.mock(checkin, 'newTrove', newTrove)
facade.createNewPackage('packageName', 'labelName', factory='thefact')
newTrove._mock.assertCalled('r',
'c',
'packageName=labelName',
dir=None,
template=None,
factory='thefact')
