def testCreateProductVersion(self):
db = self.openMintDatabase(createRepos=False)
self.createUser('admin', admin=True)
self.createProduct('foo', owners=['admin'], db=db)
self.assertRaises(mint_error.ProductVersionInvalid,
self.createProductVersion, db, 'foo', '/',
description='desc', platformLabel=None)
self.assertRaises(mint_error.InvalidLabel,
self.createProductVersion, db, 'foo', '1',
namespace='/',
description='desc', platformLabel=None)
self.assertRaises(mint_error.InvalidNamespace,
self.createProductVersion, db, 'foo', '1',
namespace='1'*20,
description='desc', platformLabel=None)
self.createProductVersion(db, 'foo', '1', description='desc',
platformLabel=None)
args, kw = db.productMgr.reposMgr.createSourceTrove._mock.popCall()
assert(not kw)
assert(len(args) == 6)
assert(args[0:4] == ('foo', 'group-foo-appliance',
'foo.rpath.local2@rpl:foo-1-devel', '1'))
assert(args[4].keys() == ['group-foo-appliance.recipe'])
assert(args[5] == 'Initial appliance image group template')
self.assertRaises(mint_error.DuplicateProductVersion,
self.createProductVersion,
db, 'foo', '1')
mock.mock(proddef.ProductDefinition, 'rebase')
self.createProductVersion(db, 'foo', '2',
platformLabel='conary.rpath.com@rpl:1')
args, kw = proddef.ProductDefinition.rebase._mock.popCall()
assert(args[1] == 'conary.rpath.com@rpl:1')
def test_branch_jobs_template_macros_templateerror(self):
self.cmd.fromMacros = None
self.cmd.toMacros = conarymacros.Macros({'branch': 'bar'})
mock.mock(bc.utils, 'readJob', 'job')
mock.mock(bc.utils, 'readTemplate', {
'name': '/jobs/%(branch)s.xml',
'templates': [],
'macros': [
['branch', 'foo'],
]
})
mock.mock(bc.utils, 'writeJob')
mock.mock(bc.utils, 'writeTemplate')
mock.mock(bc.warnings, 'warn')
mock.mockMethod(self.cmd._updateJobData, 'newJob')
templateList = ['template']
self.cmd._updateJobData._mock.raiseErrorOnAccess(
jberrors.TemplateError('error'))
err = self.assertRaises(
jberrors.CommandError,
self.cmd.branchJobs,
templateList,
)
self.assertEqual(str(err), "error parsing job '/jobs/foo.xml'")
bc.warnings.warn._mock.assertCalled(
'Support for macros stored in templates is deprecated.',
DeprecationWarning,
)
def testGetPackagePath(self):
realListDir = os.listdir
realExists = os.path.exists
def mockListDir(path):
if path.endswith('/qa'):
return ['asdf' ]
return realListDir(path)
def mockExists(path):
if path.endswith('CONARY'):
return True
if path.startswith('/PROD'):
return True
return realExists(path)
self.mock(os, 'listdir', lambda *args: mockListDir(*args))
self.mock(os.path, 'exists', lambda *args: mockExists(*args))
productStore = mock.MockInstance(dirstore.CheckoutProductStore)
productStore._mock.enableMethod('getPackagePath')
productStore.getStageDirectory._mock.setDefaultReturn('/PROD/qa')
handle = self.getRbuildHandle(productStore=productStore)
productStore._handle.facade.conary = mock.MockObject()
stateObj = mock.MockObject()
stateObj.getSourceState().getName._mock.setDefaultReturn('asdf:source')
mock.mock(state, 'ConaryStateFromFile')
state.ConaryStateFromFile._mock.setDefaultReturn(stateObj)
productStore._handle.facade.conary.getNameForCheckout._mock.setDefaultReturn('asdf')
productStore._handle.facade.conary.isGroupName._mock.setDefaultReturn(False)
packagePath = productStore.getPackagePath('asdf')
assert(packagePath == '/PROD/qa/asdf')
packagePath = productStore.getPackagePath('blah')
assert(packagePath is None)
def test_createJob(self):
job = self.job
mock.mock(dispatcher, 'getHandlerClass')
dispatcher.getHandlerClass._mock.setReturn(MockHandler, 'test')
saved = []
def db_createJob(newJob, frozen_handler, callback=None):
self.assertEqual(job.job_uuid, newJob.job_uuid)
ret = newJob.freeze()
saved.append(ret)
return defer.succeed(ret)
self.disp.db._mock.set(createJob=db_createJob)
fh_uuid = uuid.uuid4()
d = self.disp.createJob(job, firehose=str(fh_uuid))
assert isinstance(d, defer.Deferred)
def callback(result):
handler = self.disp.jobs.values()[0]
self.assertEqual(handler.job.freeze(), saved[0])
self.assertEqual(handler.started, True)
self.disp.firehose.subscribe._mock.assertCalled(
('job', str(job.job_uuid)), fh_uuid)
self.disp.firehose.publish._mock.assertCalled(
('job', str(job.job_uuid), 'self'), 'created')
d.addCallback(callback)
return d
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 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 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 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 testCreate(self):
handle = self.handle
_ddata = mock.MockObject()
_ttype = mock.MockObject(
name="type",
descriptor_create_target=StringIO("descriptor"),
)
mock.mock(handle, "DescriptorConfig")
handle.DescriptorConfig.createDescriptorData._mock.setReturn(
_ddata, fromStream="descriptor", defaults=dict())
mock.mock(handle.facade, "rbuilder")
handle.facade.rbuilder.getTargetTypes._mock.setReturn([_ttype])
handle.facade.rbuilder.createTarget._mock.setReturn(
"target", _ttype.name, _ddata)
err = self.assertRaises(
errors.PluginError,
handle.Targets.createTarget,
"notype"
)
self.assertEqual(str(err), "No such target type 'notype'. Run"
" `rbuild list targettypes` to see valid target types")
rv = handle.Targets.createTarget("type")
self.assertEqual(rv, "target")
def testLoadCommand(self):
job = buildjob.BuildJob(1)
trv1 = buildtrove.BuildTrove(1, *self.getNVF('foo:source'))
trv2 = buildtrove.BuildTrove(1, *self.getNVF('bar:source'))
job.addBuildTrove(trv1)
job.addBuildTrove(trv2)
result1 = buildtrove.LoadTroveResult()
result1.packages = set(['foo', 'baz'])
result2 = buildtrove.LoadTroveResult()
result2.buildRequirements = set(['initscripts:runtime'])
troves = [trv1, trv2]
tups = [x.getNameVersionFlavor(True) for x in troves]
results = [result1, result2]
resultSet = dict(zip(tups, results))
def getSourceTrovesFromJob(job_, troves_, repos, reposName):
self.assertEqual(job_, job)
self.assertEqual(troves_, troves)
self.assertEqual(reposName, self.rmakeCfg.reposName)
return resultSet
self.mock(recipeutil, 'getSourceTrovesFromJob', getSourceTrovesFromJob)
mock.mock(conaryclient, 'ConaryClient')
# call
cmd = command.LoadCommand(self.rmakeCfg, 'cmd', job.jobId, None,
job, tups, self.rmakeCfg.reposName)
cmd.publisher = mock.MockObject()
cmd.runAttachedCommand()
cmd.publisher.attach._mock.assertCalled(trv1)
cmd.publisher.attach._mock.assertCalled(trv2)
self.assertEqual(trv1.packages, set(['foo', 'baz']))
self.assertEqual(trv2.buildRequirements, set(['initscripts:runtime']))
def setUp(self):
testcase.TestCase.setUp(self)
self.cfg = config.UpsrvConfig()
self.cfg.downloadSignatureExpiry = 3600
self.cfg.downloadSignatureKey = ['default key']
self.now = 1000000000.0
mock.mock(time, 'time', self.now)
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 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 test_branch_jobs_template_macros(self):
self.cmd.fromMacros = None
self.cmd.toMacros = conarymacros.Macros({'branch': 'bar'})
mock.mock(bc.utils, 'readJob', 'job')
mock.mock(bc.utils, 'readTemplate', {
'name': '/jobs/%(branch)s.xml',
'templates': [],
'macros': [
['branch', 'foo'],
]
})
mock.mock(bc.utils, 'writeJob')
mock.mock(bc.utils, 'writeTemplate')
mock.mock(bc.warnings, 'warn')
mock.mockMethod(self.cmd._updateJobData, 'newJob')
templateList = ['template']
self.cmd.branchJobs(templateList)
bc.utils.readTemplate._mock.assertCalled('template')
bc.utils.readJob._mock.assertCalled('/jobs/foo.xml')
bc.utils.writeJob._mock.assertCalled('/jobs/bar.xml', 'newJob')
bc.warnings.warn._mock.assertCalled(
'Support for macros stored in templates is deprecated.',
DeprecationWarning,
)
def testImageCommand(self):
eventHandler = mock.MockObject()
mock.mock(rbuilderclient, "RbuilderClient")
self.buildCfg.configLine("rmakeUser foo bar")
self.buildCfg.rbuilderUrl = "http://foo"
trv = imagetrove.ImageTrove(1, *self.makeTroveTuple("group-foo"))
trv.setProductName("product")
cmd = imagecommand.ImageCommand(self.rmakeCfg, "commandId", 1, eventHandler, self.buildCfg, trv)
client = cmd.client
client.newBuildWithOptions._mock.setDefaultReturn(21)
cmd.logger = mock.MockObject()
mock.mockMethod(cmd.watchImage)
cmd.runAttachedCommand()
cmd.watchImage._mock.assertCalled(21)
client.startImage._mock.assertCalled(21)
client.newBuildWithOptions._mock.assertCalled(
"product",
"group-foo",
trv.getVersion(),
trv.getFlavor(),
trv.getImageType(),
trv.getBuildName(),
trv.getImageOptions(),
)
client.newBuildWithOptions._mock.raiseErrorOnAccess(RuntimeError("error!"))
cmd.runAttachedCommand()
assert trv.isFailed()
assert str(trv.getFailureReason()) == "Failed while building: error!"
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 testGetWindowsBuildService(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
client._api._mock.set(inventory=mock.MockObject())
notwbs = mock.MockObject(system_type=mock.MockObject(
name='foobar'))
# Correct WBS system.
wbs = mock.MockObject(system_type=mock.MockObject(
name='infrastructure-windows-build-node'),
networks=[mock.MockObject(ip_address='1.2.3.4',
dns_name='foo.example.com'), ])
client._api.inventory._mock.set(infrastructure_systems=[wbs, notwbs])
address = client.getWindowsBuildService()
self.failUnlessEqual(address, '1.2.3.4')
# No WBS systems found.
wbs2 = mock.MockObject(system_type=mock.MockObject(name='bar'))
client._api.inventory._mock.set(infrastructure_systems=[wbs2, notwbs])
self.failUnlessRaises(errors.RbuildError, client.getWindowsBuildService)
# Selected WBS system doesn't have any networks.
wbs3 = mock.MockObject(system_type=mock.MockObject(
name='infrastructure-windows-build-node'),
networks=[])
client._api.inventory._mock.set(infrastructure_systems=[wbs3, notwbs])
self.failUnlessRaises(errors.RbuildError, client.getWindowsBuildService)
def testWatchImages(self):
client = self._getClient()
server = client.server
mock.mock(time, 'sleep')
server.getBuildStatus._mock.setReturns(
[(False, {'message' : 'foo', 'status' : 0}),
(False, {'message' : 'bar', 'status' : 300})],
1)
server.getBuildStatus._mock.setReturns(
[(False, {'message' : 'bam', 'status' : 200}),
(False, {'message' : 'zap', 'status' : 500})],
2)
client.watchImages([1, 2])
client._handle.ui.info._mock.assertNotCalled()
client._handle.ui.warning._mock.assertNotCalled()
client._handle.ui.error._mock.assertNotCalled()
self.assertEquals(
[x[0][0]%x[0][1:] for x in client._handle.ui.write._mock.calls],
['1: Waiting "foo"',
'2: Built "bam"',
'1: Finished "bar"',
'2: Unknown "zap"',
'All jobs completed',
'Finished builds:',
" Build 1 ended with 'Finished' status: bar",
" Build 2 ended with 'Unknown' status: zap"])
server.getBuildStatus._mock.setReturns(
[(False, {'message' : 'bam', 'status' : 200}),
(True, ('Error', ''))], 1)
err = self.assertRaises(errors.RbuildError, self.captureOutput,
client.watchImages, [1])
self.assertEqual(str(err), "rBuilder error Error: ''")
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 test_getRbuilderRPCClient(self):
_, facade = self.prep()
mock.mock(rbuilderfacade, 'RbuilderRPCClient')
facade._getRbuilderRPCClient()
rbuilderfacade.RbuilderRPCClient._mock.assertCalled('http://localhost',
'foo', 'bar',
facade._handle)
def testUpdateOnBoot(self):
from conary.cmds import conarycmd
mock.mock(conarycmd, 'main')
r = self.Runner()
r.processProperties({'com.sas.app-engine.update-on-boot' : [ 'true' ]})
self.assertEquals(conarycmd.main._mock.calls,
[((['conary', 'updateall', '--no-interactive'],), ())])
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 testWatchImage(self):
eventHandler = mock.MockObject()
mock.mock(rbuilderclient, "RbuilderClient")
self.buildCfg.configLine("rmakeUser foo bar")
self.buildCfg.rbuilderUrl = "http://foo"
mock.mock(time, "sleep")
trv = imagetrove.ImageTrove(1, *self.makeTroveTuple("group-foo"))
trv.setProductName("product")
cmd = imagecommand.ImageCommand(self.rmakeCfg, "commandId", 1, eventHandler, self.buildCfg, trv)
client = cmd.client
client.server.getBuildStatus._mock.setReturns(
[
(False, {"message": "foo", "status": 10}),
(False, {"message": "foo", "status": 10}),
(False, {"message": "bar", "status": 300}),
],
21,
)
rc, txt = self.captureOutput(cmd.watchImage, 21)
assert (
txt
== """\
21: foo
21: bar
"""
)
client.server.getBuildStatus._mock.setReturns([(True, "Error with build")], 31)
err = self.assertRaises(errors.RmakeError, cmd.watchImage, 31)
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 testVirtualHardwareVersion(self):
img = self.img
Mocked = set(['mkfs.ext3', 'tune2fs', ])
origLogCall = raw_hd_image.logCall
logCallArgs = []
def mockLogCall(cmd, **kw):
logCallArgs.append((cmd, kw))
if (isinstance(cmd, list) and cmd[0] in Mocked) or cmd.startswith('mount') or cmd.startswith('umount') or cmd.startswith('chroot'):
return
return origLogCall(cmd, **kw)
self.mock(raw_hd_image, 'logCall', mockLogCall)
self.mock(bootable_image, 'logCall', mockLogCall)
self.mock(bootable_image.loophelpers, 'logCall', mockLogCall)
mknodArgs = []
def mockMknod(*args):
mknodArgs.append(args)
self.mock(os, 'mknod', mockMknod)
chmodArgs = []
def mockChmod(*args):
chmodArgs.append(args)
self.mock(os, 'chmod', mockMknod)
util.mkdirChain(os.path.join(img.root, "root"))
file(os.path.join(img.root, "root", "conary-tag-script.in"), "w").write(
"echo nothing here")
util.mkdirChain(img.changesetDir)
mock.mockMethod(img.downloadChangesets)
mock.mockMethod(img.postOutput)
mock.mockMethod(img.loadRPM)
mock.mock(bootable_image.Filesystem, '_get_uuid')
bootable_image.Filesystem._get_uuid()._mock.setDefaultReturn('abc123')
self.mock(img, 'updateGroupChangeSet', lambda x: None)
img.write()
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 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 setupPlatforms(self):
mock.mock(platformmgr.Platforms, "_checkMirrorPermissions", True)
repos = self.openRepository()
self.cclient = self.getConaryClient()
self.cclient.repos = repos
platformLabel1 = self.availablePlatforms[0]
pl1 = self.productDefinition.toPlatformDefinition()
cst = pl1.newContentSourceType("RHN", "RHN", isSingleton=True)
cst2 = pl1.newContentSourceType("satellite", "satellite")
ds = pl1.newDataSource("Channel 1", "Channel 1")
pl1.setContentProvider("Crowbar", "Crowbar", [cst, cst2], [ds])
pl1.setPlatformName("Crowbar Linux 1")
pl1.setPlatformUsageTerms("Terms of Use 1")
pl1.addArchitecture("x86", "x86", "is:x86 x86(~i486, ~i586, ~i686, ~cmov, ~mmx, ~sse, ~sse2)")
pl1.addArchitecture("x86_64", "x86 (64-bit)", "is:x86_64 x86(~i486, ~i586, ~i686, ~cmov, ~mmx, ~sse, ~sse2)")
pl1.addFlavorSet("xen", "Xen DomU", "~xen, ~domU, ~!dom0, ~!vmware")
pl1.addFlavorSet("vmware", "VMware", "~vmware, ~!xen, !domU, ~!dom0")
pl1.addContainerTemplate(
pl1.imageType(
"vmwareEsxImage",
{
"autoResolve": "false",
"natNetworking": "true",
"baseFileName": "",
"vmSnapshots": "false",
"swapSize": "512",
"vmMemory": "256",
"installLabelPath": "",
"freespace": "1024",
},
)
)
pl1.addContainerTemplate(
pl1.imageType(
"xenOvaImage",
{
"autoResolve": "false",
"baseFileName": "",
"swapSize": "512",
"vmMemory": "256",
"installLabelPath": "",
"freespace": "1024",
},
)
)
pl1.saveToRepository(self.cclient, platformLabel1)
self._addPlatform(platformLabel1, pl1)
platformLabel2 = self.availablePlatforms[1]
pl2 = self.productDefinition.toPlatformDefinition()
cst = pl1.newContentSourceType("RHN", "RHN")
ds = pl1.newDataSource("Channel 1", "Channel 1")
pl1.setContentProvider("Crowbar", "Crowbar", [cst], [ds])
pl2.setPlatformName("Crowbar Linux 2")
pl2.setPlatformUsageTerms("Terms of Use 2")
sp = pl2.getSearchPaths()[0]
sp.set_isPlatformTrove(True)
pl2.saveToRepository(self.cclient, platformLabel2)
self._addPlatform(platformLabel2, pl2)
def setUp(self):
RpathToolsTest.setUp(self)
mock.mock(register.LocalUuid, '_getDmidecodeUuid')
register.LocalUuid._getDmidecodeUuid._mock.setReturn('GENERATEDUUID')
self.reg = register.Registration.registration(self.cfg)
clientsDir = os.path.join(self.cfg.topDir, 'clients')
cfg = self.reg.sfcbConfig
cfg['sslClientTrustStore'] = os.path.join(self.cfg.topDir, 'clients')
def setUp(self):
RbuildHelper.setUp(self)
self.getRbuildHandle()
from rbuild_plugins import config
mock.mock(config.Config, 'isComplete', True)
os.chdir(self.workDir)
self.rbuildCfg.resetToDefault('serverUrl')
self.rbuildCfg.writeToFile(self.workDir + '/rbuildrc')
def testValidateRbuilderUrl(self):
handle, facade = self.prep()
mock.mock(rbuilderfacade, 'RbuilderRPCClient')
rbuilderfacade.RbuilderRPCClient().checkAuth._mock.setDefaultReturn(
dict(authorized=True))
rbuilderfacade.RbuilderRPCClient._mock.popCall()
ret = facade.validateRbuilderUrl('http://foo')
self.assertEquals(rbuilderfacade.RbuilderRPCClient._mock.popCall(),
(('http://foo', '', '', handle), ()))
assert ((True, '') == ret)
e = Exception()
rbuilderfacade.RbuilderRPCClient().checkAuth._mock.raiseErrorOnAccess(
e)
ret = facade.validateRbuilderUrl('http://foo')
assert ((False, e) == ret)
def testListPlatforms(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
Platform = namedtuple('Platform',
'enabled hidden abstract platformName label')
client._api.platforms._mock.set(platform=[
Platform('true', 'false', 'false', 'plat1', 'plat@1'),
Platform('false', 'false', 'false', 'plat2', 'plat@2'),
Platform('true', 'true', 'false', 'plat3', 'plat@3'),
Platform('true', 'false', 'true', 'plat4', 'plat@4'),
])
results = client.listPlatforms()
self.assertEqual(
results, [Platform('true', 'false', 'false', 'plat1', 'plat@1')])
def testGetEditedRecipeDicts(self):
realListDir = os.listdir
realExists = os.path.exists
def mockListDir(path):
if path.endswith('/qa'):
return ['asdf' ]
return realListDir(path)
def mockExists(path):
if path.endswith('CONARY'):
return True
if path.startswith('/PROD'):
return True
return realExists(path)
self.mock(os, 'listdir', lambda *args: mockListDir(*args))
self.mock(os.path, 'exists', lambda *args: mockExists(*args))
productStore = mock.MockInstance(dirstore.CheckoutProductStore)
productStore._mock.enableMethod('getEditedRecipeDicts')
productStore.getRbuildConfigPath._mock.setReturn(
self.workDir + '/rbuildrc')
handle = self.getRbuildHandle(productStore=productStore)
productStore._handle.facade.conary = mock.MockObject()
stateObj = mock.MockObject()
stateObj.getSourceState().getName._mock.setDefaultReturn('asdf:source')
mock.mock(state, 'ConaryStateFromFile')
state.ConaryStateFromFile._mock.setDefaultReturn(stateObj)
productStore._handle.facade.conary.getNameForCheckout._mock.setDefaultReturn('asdf')
productStore._handle.facade.conary.isGroupName._mock.setDefaultReturn(False)
productStore.getActiveStageName._mock.setDefaultReturn(None)
productStore.getStageDirectory._mock.setDefaultReturn('/PROD/qa')
packageDict, groupDict = productStore.getEditedRecipeDicts('qa')
assert packageDict == {'asdf' : '/PROD/qa/asdf/asdf.recipe'}
assert groupDict == {}
productStore.getActiveStageName._mock.setDefaultReturn('qa')
packageDict, groupDict = productStore.getEditedRecipeDicts()
assert packageDict == {'asdf' : '/PROD/qa/asdf/asdf.recipe'}
assert groupDict == {}
productStore._handle.facade.conary.getNameForCheckout._mock.setDefaultReturn('group-asdf')
productStore._handle.facade.conary.isGroupName._mock.setDefaultReturn(True)
stateObj.getSourceState().getName._mock.setDefaultReturn(
'group-asdf:source')
packageDict, groupDict = productStore.getEditedRecipeDicts('qa')
assert packageDict == {}
assert groupDict == {'group-asdf' : '/PROD/qa/asdf/group-asdf.recipe'}
def testInitializeBuild(self):
builderObj = mock.MockInstance(builder.Builder)
regTrv = mock.MockObject()
regTrv2 = mock.MockObject()
specTrv = mock.MockObject()
regTrv.isSpecial._mock.setReturn(False)
regTrvTup = self.makeTroveTuple('reg:source')
regTrv.getNameVersionFlavor._mock.setReturn(regTrvTup)
regTrv2.isSpecial._mock.setReturn(False)
regTrv2Tup = self.makeTroveTuple('reg:source')
regTrv2.getNameVersionFlavor._mock.setReturn(regTrv2Tup)
specTrv.isSpecial._mock.setReturn(True)
job = mock.MockObject(jobId=1)
job.iterConfigList._mock.setDefaultReturn([])
job.getMainConfig()._mock.set(primaryTroves=[])
job.iterTroves._mock.setDefaultReturn([regTrv, regTrv2, specTrv])
job.iterLoadableTroveList._mock.setDefaultReturn(
[regTrvTup, regTrv2Tup])
job.isLoading._mock.setDefaultReturn(False)
job.isFailed._mock.setDefaultReturn(False)
job.isLoaded._mock.setDefaultReturn(True)
mock.mock(dephandler, 'DependencyHandler')
builderObj._mock.set(job=job)
builderObj._mock.enableMethod('initializeBuild')
builderObj._mock.set(serverCfg=self.rmakeCfg)
builderObj.buildCfg._mock.set(isolateTroves=False)
# Call
self.failUnless(builderObj.initializeBuild())
builderObj.worker.loadTroves._mock.assertCalled(
job, [regTrvTup, regTrv2Tup], builderObj.eventHandler,
self.rmakeCfg.reposName)
expectReg = sorted([regTrv, regTrv2])
expected = sorted(expectReg + [specTrv])
job.setBuildTroves._mock.assertCalled(expected)
rscache = self.rmakeCfg.getResolverCachePath()
dephandler.DependencyHandler._mock.assertCalled(
builderObj.job.getPublisher(),
builderObj.logger,
expectReg, [specTrv],
dumbMode=False,
resolverCachePath=rscache)
def testNodeServerSlowToConnect(self):
from rmake.multinode import workernode
from rmake.server import client
fclient = mock.MockObject()
self.mock(client, 'rMakeClient', fclient)
mock.mock(time, 'sleep') #Otherwise we wait 5 seconds for no good reason
cfg = self.getNodeCfg()
msgBusInfo = mock.MockObject()
# The first time through, raise RuntimeError, and on the subsequent
# runs return None and a mock object sequentially
fclient().getMessageBusInfo._mock.raiseErrorOnAccess(RuntimeError('connect to server error'))
fclient().getMessageBusInfo._mock.setReturns([None, msgBusInfo])
server = workernode.rMakeWorkerNodeServer(cfg)
self.assertEquals(len(time.sleep._mock.calls), 2, 'sleep should have been called twice')
self.assertEquals(len(fclient().getMessageBusInfo._mock.calls), 3)
def testCommandParsing(self):
handle = self.getRbuildHandle()
handle.Build.registerCommands()
handle.Build.initialize()
handle.BuildPlatform.initialize()
cmd = handle.Commands.getCommandClass('build')()
mock.mockMethod(handle.BuildPlatform.buildPlatform)
err = self.assertRaises(errors.PluginError, cmd.runCommand, handle, {},
['rbuild', 'build', 'platform'])
self.assertIn('rbuild init', str(err))
mock.mock(handle, 'productStore')
cmd.runCommand(handle, {}, ['rbuild', 'build', 'platform'])
handle.BuildPlatform.buildPlatform._mock.assertCalled()
def testCreateRmakeJobForAllPackages(self):
handle = self.getRbuildHandle()
from rbuild_plugins.build import packages
handle.productStore = mock.MockObject()
handle.productStore.getGroupFlavors._mock.setReturn([])
packageRecipes = {'foo': self.workDir + '/foo/foo.recipe'}
handle.productStore.getEditedRecipeDicts._mock.setReturn(
(packageRecipes, {}))
mock.mock(packages, '_addInEditedPackages', 'return')
rc = packages.createRmakeJobForAllPackages(handle)
assert (rc == 'return')
handle.productStore.getEditedRecipeDicts._mock.setReturn(({}, {}))
err = self.assertRaises(errors.PluginError,
packages.createRmakeJobForAllPackages, handle)
assert (str(err) == ('no packages are currently being edited'
' - nothing to build'))
def testShow(self):
handle = self.handle
mock.mock(handle, 'productStore')
mock.mock(handle, 'product')
handle.product.getProductShortname._mock.setReturn('project')
handle.productStore.getActiveStageName._mock.setReturn('stage')
handle.product.getBaseLabel._mock.setReturn('branch')
mock.mockMethod(handle.facade.rbuilder.getImages, ['image'])
rv = handle.Images.show(10)
self.assertEqual(rv, 'image')
handle.facade.rbuilder.getImages._mock.assertCalled(image_id=10,
project='project',
branch='branch',
stage='stage')
def testRbuilderRPCClientInit(self):
mock.mock(fac_mod, 'ServerProxy')
rbuilderfacade.RbuilderRPCClient('http://localhost', 'foo', 'bar',
None)
fac_mod.ServerProxy._mock.assertCalled(
'http://localhost/xmlrpc-private',
username='******',
password='******',
allow_none=True)
rbuilderfacade.RbuilderRPCClient('https://localhost2', 'foo2', 'bar',
None)
fac_mod.ServerProxy._mock.assertCalled(
'https://localhost2/xmlrpc-private',
username='******',
password='******',
allow_none=True)
def testList(self):
handle = self.handle
mock.mock(handle, 'product')
mock.mock(handle, 'productStore')
_group_1 = mock.MockObject()
_group_1._mock.set(timeStamp=1)
_group_2 = mock.MockObject()
_group_2._mock.set(timeStamp=2)
_group_3 = mock.MockObject()
_group_3._mock.set(timeStamp=3)
mock.mockMethod(handle.facade.rbuilder.getGroups,
[_group_1, _group_3, _group_2])
self.assertEqual([_group_3, _group_2, _group_1], handle.Groups.list())
def testDerivePackage(self):
handle = self._getHandle()
from rbuild_plugins.checkout import derive
checkout = handle.Checkout
mock.mockMethod(checkout._getUpstreamPackage)
mock.mock(derive, 'derive')
fooTrove = self.makeTroveTuple('foo')
checkout._getUpstreamPackage._mock.setDefaultReturn(fooTrove)
checkout.derivePackage('foo')
derive.derive._mock.assertCalled(handle, fooTrove)
checkout._getUpstreamPackage._mock.setDefaultReturn(None)
err = self.assertRaises(errors.PluginError,
checkout.derivePackage, 'foo')
self.assertEquals(str(err), 'cannot derive foo: no upstream binary')
def testGetStageDirectory(self):
productStore = mock.MockInstance(dirstore.CheckoutProductStore)
productStore._mock.enableMethod('getStageDirectory')
mock.mock(os.path, 'exists')
os.path.exists._mock.setReturn(False, self.workDir + '/foo')
productStore._mock.set(_baseDirectory=self.workDir)
err = self.assertRaises(errors.RbuildError,
productStore.getStageDirectory, 'foo')
assert (str(err) == "Stage directory for 'foo' does not exist")
os.path.exists._mock.setReturn(True, self.workDir + '/foo')
workDir = productStore.getStageDirectory('foo')
assert (workDir == self.workDir + '/foo')
productStore.getActiveStageName._mock.setReturn(None)
workDir = productStore.getStageDirectory()
assert (workDir is None)
productStore.getActiveStageName._mock.assertCalled()
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.facade.rbuilder.watchImages)
mock.mockMethod(handle.BuildImages.printImageUrlsForBuild)
err = self.assertRaises(errors.MissingProductStoreError,
cmd.runCommand, handle, {},
['rbuild', 'build', 'images'])
self.assertIn('rbuild init', str(err))
mock.mock(handle, 'productStore')
handle.productStore._mock.set(_currentStage=None)
err = self.assertRaises(errors.MissingActiveStageError,
cmd.runCommand, handle, {},
['rbuild', 'build', 'images'])
self.assertIn('valid stage', str(err))
handle.productStore._mock.set(_currentStage='stage')
handle.product = mock.MockObject()
cmd.runCommand(handle, {}, ['rbuild', 'build', 'images'])
handle.BuildImages.buildImages._mock.assertCalled(None, None)
handle.facade.rbuilder.watchImages._mock.assertCalled([1])
handle.BuildImages.printImageUrlsForBuild._mock.assertCalled(1)
cmd.runCommand(handle, {}, ['rbuild', 'build', 'images', 'image 1', 'image 2'])
handle.BuildImages.buildImages._mock.assertCalled(['image 1', 'image 2'], None)
cmd.runCommand(handle, {'group-version': '1.0-1-1'},
['rbuild', 'build', 'images', 'image 1', 'image 2'])
handle.BuildImages.buildImages._mock.assertCalled(
['image 1', 'image 2'], '1.0-1-1')
handle.facade.rbuilder.watchImages._mock.setReturn(False, [1])
rv = cmd.runCommand(handle, {}, ['rbuild', 'build', 'images'])
self.assertEqual(rv, 10)
self.mock(sys, 'stdout', StringIO())
cmd.runCommand(handle, {'no-watch':True},
['rbuild', 'build', 'images'])
self.assertEqual(sys.stdout.getvalue(), '1\n')
def testGetProject(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
client._api._mock.set(_uri='http://localhost')
client._api._client.do_GET._mock.setReturn(
'response', 'http://localhost/projects/foo')
self.assertEqual(client.getProject('foo'), 'response')
client._api._client.do_GET._mock.raiseErrorOnAccess(
robj.errors.HTTPNotFoundError(uri=None,
status=None,
reason=None,
response=None))
err = self.assertRaises(errors.RbuildError, client.getProject, 'bar')
self.assertIn('not found', str(err))
def testStopDaemon(self):
raise testsuite.SkipTestException('Fails in bamboo')
daemonClass = self.generateDaemonClass()
util.mkdirChain(self.workDir + '/var/log')
util.mkdirChain(self.workDir + '/var/lock')
d = daemonClass()
rv, txt = self.captureOutput(d.main, ['./daemontest', 'start'])
assert (not rv)
mock.mock(os, 'kill')
mock.mock(time, 'sleep')
mock.mockMethod(d.error)
err, txt = self.captureOutput(d.main, ['./daemontest', 'stop'],
_returnException=True)
msg = d.error._mock.popCall()[0][0]
assert ('Failed to kill foobar (pid ' in msg)
mock.unmockAll()
self.captureOutput(d.main, ['./daemontest', 'stop'])
def testDispatcherServer(self):
# Test only the server class, not the entire dispatcher
# hierarchy
db = mock.MockObject()
self.rmakeCfg.messageBusPort = None
server = dispatcher.DispatcherServer(self.rmakeCfg, db)
mock.mock(server, 'client')
cmd1 = self.makeCommandMessage(1, 1, self.getNVF('foo:source'))
trv = cmd1.getTrove()
cmd2 = self.makeCommandMessage(2, 2, self.getNVF('bar:source',
flavor='is:x86_64'),
[('foo:runtime', (None, None), (trv.getVersion(), parseFlavor('is:x86_64')))])
cmd3 = self.makeCommandMessage(3, 3, self.getNVF('foo:source',
flavor='bar is:x86'),
[('foo:runtime', (None, None), (trv.getVersion(), parseFlavor('bar is:x86')))])
# command 4 is also from job 2.
cmd4 = self.makeCommandMessage(4, 2, self.getNVF('bam:source'))
server.requestCommandAssignment(cmd1, cmd2, cmd3, cmd4)
server._assignQueuedCommands()
assert(server.listQueuedCommands() == [ cmd1.getMessageId(),
cmd2.getMessageId(),
cmd3.getMessageId(),
cmd4.getMessageId()])
node = self.makeRegisterNodeMessage().getNode()
# this assigns a command to this node as well.
server.nodeRegistered('session1', node)
server.client.assignCommand._mock.assertCalled(cmd1, node)
server._assignQueuedCommands()
assert(server.listQueuedCommands() == [ cmd2.getMessageId(),
cmd3.getMessageId(),
cmd4.getMessageId()])
assert(server.listAssignedCommands()
== [(cmd1.getCommandId(), node.sessionId)])
server.commandCompleted(cmd1.getCommandId())
assert(server.listAssignedCommands()
== [(cmd3.getCommandId(), node.sessionId)])
assert(server.listQueuedCommands() == [ cmd2.getMessageId(),
cmd4.getMessageId()])
server.commandErrored(cmd3.getCommandId())
assert(server.listQueuedCommands() == [ cmd2.getMessageId()])
assert(server.listAssignedCommands()
== [(cmd4.getCommandId(), node.sessionId)])
cmd5 = self.makeStopMessage(6, cmd2)
server.requestCommandAssignment(cmd5)
assert(not server.listQueuedCommands())
def testRunCommand(self):
mainHandler = main.RbuildMain()
cmd = mainHandler.getCommand(['rbuild', 'help'], self.rbuildCfg)
productStore = mock.MockObject()
h = mainHandler.handle
h.productStore = productStore
cfg = h.getConfig()
mock.mock(h.Config, 'isComplete')
h.Config.isComplete._mock.setReturn(False, cfg)
mock.mockMethod(h.Config.initializeConfig)
outputList = []
rc, txt = self.captureOutput(mainHandler.runCommand, cmd,
self.rbuildCfg, {}, ['rbuild', 'help'])
h.Config.initializeConfig._mock.assertNotCalled()
cmd = mainHandler.getCommand(['rbuild', 'build'], self.rbuildCfg)
self.rbuildCfg.serverUrl = 'some value'
productStore = mock.MockObject()
mainHandler.handle.productStore = productStore
self.checkCall(mainHandler.runCommand,
[cmd, self.rbuildCfg, {
'stage': 'foo'
}, []], {},
'rbuild_plugins.build.BuildCommand.runCommand',
[cmd, handle.RbuildHandle, {}, []])
productStore.setActiveStageName._mock.assertCalled('foo')
class FakeCommand:
def runCommand(self, handle, argSet, args):
raise errors.PluginError('eek')
cmd = FakeCommand()
h = mainHandler.handle
h.ui = mock.MockObject()
self.assertRaises(errors.PluginError, mainHandler.runCommand, cmd,
mock.MockObject(), {}, [])
self.assertEquals(h.ui.popContext._mock.popCall()[0][0],
'Command failed with exception %r')
h.ui.popContext._mock.raiseErrorOnAccess(IOError)
# Note: not IOError -- the IOError should be ignored and the
# PluginError should propogate
self.assertRaises(errors.PluginError, mainHandler.runCommand, cmd,
mock.MockObject(), {}, [])
def _setupMockDispatcher(self):
db = mock.MockObject()
self.rmakeCfg.messageBusPort = None
server = dispatcher.DispatcherServer(self.rmakeCfg, db)
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')
mock.mock(server.client.getBusClient(), 'logger')
sessionClient.handle_connect()
self._check(sessionClient, mbmessages.ConnectionRequest,
sessionClass='DSP')
m = mbmessages.ConnectedResponse()
m.set(sessionId='DSP-foo')
sessionClient.handle_message(m)
return server, sessionClient
def testInitializeConfig(self):
mainHandler = main.RbuildMain()
cmd = mainHandler.getCommand(['rbuild', 'build'], self.rbuildCfg)
self.rbuildCfg.serverUrl = 'some value'
productStore = mock.MockObject()
h = mainHandler.handle
h.productStore = productStore
cfg = h.getConfig()
mock.mock(h.Config, 'isComplete')
h.Config.isComplete._mock.setReturn(False, cfg)
mock.mockMethod(h.Config.initializeConfig)
self.checkCall(mainHandler.runCommand,
[cmd, self.rbuildCfg, {
'stage': 'foo'
}, []], {},
'rbuild_plugins.build.BuildCommand.runCommand',
[cmd, handle.RbuildHandle, {}, []])
def testInit(self):
self.getRbuildHandle()
from rbuild_plugins import config
mock.mock(config.Config, 'isComplete', lambda: True)
self.addProductDefinition(shortName='foo',
upstream=['group-dist=localhost@rpl:linux'])
txt = self.runCommand('init localhost@rpl:foo-1')
self.assertEquals(
txt, 'Created checkout for localhost@foo:foo-1 at foo-1\n')
self.verifyFile('foo-1/stable/.stage', 'stable\n')
self.verifyFile('foo-1/qa/.stage', 'qa\n')
self.verifyFile('foo-1/devel/.stage', 'devel\n')
assert (os.path.exists('foo-1/.rbuild/rbuildrc'))
self.assertEquals(
os.stat('foo-1/.rbuild/rbuildrc').st_mode & 0777, 0600)
# confirm that the cached product directory looks the same as the
# fresh one
self.initProductDirectory('foo2')
try:
for root, dirs, files in os.walk('foo2'):
for f in files:
if f == 'CONARY':
continue
if f == 'product-definition.xml':
# unfortunately, this file looks different
# under addProductDefinition now because it
# has arch-specific flavors for building.
continue
self.verifyFile('foo-1%s/%s' % (root[4:], f),
open('%s/%s' % (root, f)).read())
for d in dirs:
assert os.path.exists('foo-1%s/%s' % (root[4:], d))
except Exception, err:
os.chdir('foo-1')
util.execute('tar -czf foo-product.tgz * .rbuild/* '
'--exclude ".rbuild/rbuildrc"')
errorStr = str(err) + """
New tarball at %s/foo-product.tgz.
Run:
cp %s/foo-product.tgz %s
To update the archived product definition
""" % (os.getcwd(), os.getcwd(), pathManager.getPath("RBUILD_ARCHIVE_PATH"))
raise RuntimeError(errorStr)
def testGetPassword(self):
h = self.getRbuildHandle()
mock.mock(getpass, 'getpass')
getpass.getpass._mock.setFailOnMismatch()
# test no verification
getpass.getpass._mock.setReturn('result', 'foo: ')
getpass.getpass._mock.appendReturn('result', 'Retype password: '******'foo'), 'result')
self.assertEquals(len(getpass.getpass._mock.calls), 1)
getpass.getpass._mock.calls = []
self.assertEquals(h.ui.getPassword('foo', verify=True), 'result')
self.assertEquals(len(getpass.getpass._mock.calls), 2)
getpass.getpass._mock.calls = []
# test with default provided
getpass.getpass._mock.setReturn('result', 'foo (Default: <obscured>): ')
getpass.getpass._mock.appendReturn('result', 'Retype password: '******'foo', default='bar'), 'result')
self.assertEquals(len(getpass.getpass._mock.calls), 1)
getpass.getpass._mock.calls = []
self.assertEquals(h.ui.getPassword('foo', default='bar', verify=True), 'result')
self.assertEquals(len(getpass.getpass._mock.calls), 2)
getpass.getpass._mock.calls = []
# user accepts the default
getpass.getpass._mock.setReturn('', 'foo (Default: <obscured>): ')
self.assertEquals(h.ui.getPassword('foo', default='result'), 'result')
self.assertEquals(len(getpass.getpass._mock.calls), 1)
getpass.getpass._mock.calls = []
self.assertEquals(h.ui.getPassword('foo', default='result', verify=True),
'result')
self.assertEquals(len(getpass.getpass._mock.calls), 1)
getpass.getpass._mock.calls = []
# user mistypes password
getpass.getpass._mock.callReturns = []
getpass.getpass._mock.setDefaultReturns(["result", "reslt", "result", "result"])
self.assertEquals(h.ui.getPassword("foo", verify=True), "result")
self.assertEquals(len(getpass.getpass._mock.calls), 4)
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 testRpmToCpioXz(self):
# ensure that we are testing the /usr/bin/xz path here
realExists = os.path.exists
def access_xz(*args):
if args[0].endswith('/unlzma'):
return False
return realExists(*args)
mock.mock(os.path, 'exists', access_xz)
f = os.popen(
"%s %s/gnome-main-menu-0.9.10-26.x86_64.rpm | cpio -t --quiet" %
(self.rpm2cpio, resources.get_archive()))
l = f.readlines()
assert (len(l) > 0)
self.assertEqual(l[0],
'./etc/gconf/schemas/application-browser.schemas\n')
mock.unmockAll()
def testCreateBranch(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
proj = mock.MockObject()
proj._mock.set(id='id',
name='proj',
short_name='short',
domain_name='dom')
mock.mockMethod(client.getProject)
client.getProject._mock.setReturn(proj, 'proj')
client.createBranch('proj', 'branch', 'plat', 'nsp', 'desc')
xml = proj.project_branches.append._mock.popCall()[0][0].project_branch
self.assertEqual(xml.name, 'branch')
self.assertEqual(xml.platform_label, 'plat')
self.assertEqual(xml.description, 'desc')
self.assertEqual(xml.namespace, 'nsp')
self.assertEqual(xml.project.id, 'id')
def testGetImageTypeDef(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
client._api._mock.set(_uri='http://localhost')
_imageTypeDef1 = mock.MockObject()
_imageTypeDef1.container._mock.set(name='foo')
_imageTypeDef1.architecture._mock.set(name='bar')
_imageTypeDef2 = mock.MockObject()
_imageTypeDef2.container._mock.set(name='spam')
_imageTypeDef2.architecture._mock.set(name='eggs')
client._api._client.do_GET._mock.setReturn(
[_imageTypeDef2, _imageTypeDef1],
'/products/baz/versions/1/imageTypeDefinitions')
self.assertEqual(client.getImageTypeDef('baz', '1', 'foo', 'bar'),
_imageTypeDef1)
client._api._client.do_GET._mock.raiseErrorOnAccess(
robj.errors.HTTPNotFoundError(uri=None,
status=None,
reason=None,
response=None))
err = self.assertRaises(
errors.RbuildError,
client.getImageTypeDef,
'none',
'none',
'foo',
'bar',
)
self.assertIn('not found', str(err))
err = self.assertRaises(
errors.RbuildError,
client.getImageTypeDef,
'baz',
'1',
'none',
'none',
)
self.assertIn("No image type", str(err))
def testMacroInComment(self):
self.initProductDirectory(self.workDir)
os.chdir(self.workDir)
handle = self.getRbuildHandle(productStore=mock.MockObject())
from rbuild_plugins import status
mock.mockMethod(handle.facade.conary.getCheckoutLog)
mock.mock(dirstore, 'getStageNameFromDirectory')
mock.mock(handle.facade.conary, 'isConaryCheckoutDirectory')
dirstore.getStageNameFromDirectory._mock.setDefaultReturn('devel')
mock.mockMethod(handle.facade.conary._getNewerRepositoryVersions)
outputList = []
def captureOutput(k, msg, *args):
outputList.append('%s' % (msg % args, ))
self.mock(ui.UserInterface, 'write', captureOutput)
os.chdir('devel')
self.newpkg('NewPackage')
os.chdir(self.workDir)
handle.facade.conary.isConaryCheckoutDirectory._mock.setDefaultReturn(
True)
mock.mockMethod(handle.facade.conary.getCheckoutStatus)
mock.mockMethod(handle.facade.conary.iterCheckoutDiff)
handle.facade.conary.getCheckoutStatus._mock.setDefaultReturn(
[('A', 'NewPackage.recipe')])
handle.facade.conary.iterCheckoutDiff._mock.setDefaultReturn(
['+++ NewPackage.recipe', '--- /dev/null', '+the %(recipe)s text'])
pendingAnnounce = handle.Status._printOneDirectoryStatus('.',
'NewPackage', status.VERBOSE, pendingAnnounce='', repository=False)
expectedTxt = [
'\n',
'devel stage status:\n===================',
'L- NewPackage',
' * Local changes not committed to repository:',
'L- A NewPackage/NewPackage.recipe',
'+++ NewPackage.recipe',
'--- /dev/null',
'+the %(recipe)s text',
]
self.assertEquals(outputList, expectedTxt)
del outputList[:]
self.assertEquals(pendingAnnounce, 'devel')
def testCore(self):
handle = self.getRbuildHandle()
productClass = mock.MockObject(stableReturnValues=True)
stage = mock.MockObject(label='localhost@rpl:1')
productClass().getStage._mock.setReturn(stage, 'foo')
productClass._mock.popCall()
self.mock(proddef, 'ProductDefinition', productClass)
os.chdir(self.workDir)
util.mkdirChain('foo/.rbuild/product-definition')
self.writeFile('foo/.rbuild/product-definition/product-definition.xml',
'')
p = dirstore.CheckoutProductStore(handle, 'foo')
err = self.assertRaises(errors.RbuildError, p.getActiveStageName)
self.assertEquals(str(err), 'No current stage (setActiveStageName)')
mock.mock(dirstore.CheckoutProductStore, 'checkStageIsValid')
p.setActiveStageName('foo')
assert(p.getActiveStageName() == 'foo')
mock.mockMethod(p._getSourceTroveVersion,
returnValue='cny.tv@ns:1/2-3')
proddefObj = p.getProduct()
_, kw = productClass._mock.popCall()
kw = dict(kw)
kw.pop('fromStream')
configPath = self.workDir + '/foo/.rbuild/product-definition/rmakerc'
self.assertEquals(p.getRmakeConfigPath(), configPath)
mock.mockMethod(handle.facade.conary.updateCheckout)
p.update()
rbuildDir = p.getProductDefinitionDirectory()
platformDir = p.getPlatformDefinitionDirectory()
assert(platformDir == self.workDir + '/foo/.rbuild/platform-definition')
handle.facade.conary.updateCheckout._mock.assertCalled(rbuildDir)
proddefObj.getStages._mock.setDefaultReturn(
[mock.MockObject(name='a'),
mock.MockObject(name='b'),
mock.MockObject(name='c')])
stageNames = [x for x in p.iterStageNames()]
self.assertEquals(stageNames, ['a', 'b', 'c'])
def testList(self):
handle = self.handle
# no proddef test
_imageType1 = mock.MockObject(name="imagetype1")
_imageType2 = mock.MockObject(name="")
_imageType3 = mock.MockObject(name="imagetype2")
mock.mockMethod(handle.facade.rbuilder.getImageTypes,
[_imageType3, _imageType1, _imageType2])
self.assertEqual([_imageType1, _imageType3], handle.ImageTypes.list())
# set proddefs
mock.mock(handle, "product")
mock.mock(handle, "productStore")
handle.product.getPlatformBuildTemplates._mock.setReturn(
[mock.MockObject(containerTemplateRef="imagetype1")])
actual = handle.ImageTypes.list()
self.assertEqual(len(actual), 1)
self.assertEqual(actual[0].name, "imagetype1")
def testDetachPackage(self):
_, facade = self.prep()
mockConaryCfg = mock.MockObject()
mock.mockMethod(facade.getConaryConfig)
facade.getConaryConfig._mock.setDefaultReturn(mockConaryCfg)
mock.mock(clone, 'CloneTrove')
troveSpec = self.makeTroveTuple('foo:source')
facade.detachPackage(troveSpec, '/targetlabel.rpath.org@rpath:1')
clone.CloneTrove._mock.assertCalled(
mockConaryCfg,
'/targetlabel.rpath.org@rpath:1',
[troveSpec[0] + '=' + troveSpec[1].asString()],
message='Automatic promote by rBuild.')
facade.detachPackage(troveSpec, '/targetlabel.rpath.org@rpath:1',
'blech')
clone.CloneTrove._mock.assertCalled(
mockConaryCfg,
'/targetlabel.rpath.org@rpath:1',
[troveSpec[0] + '=' + troveSpec[1].asString()],
message='blech')
def testThreshold(self):
db = mock.MockObject()
self.rmakeCfg.messageBusPort = None
server = dispatcher.DispatcherServer(self.rmakeCfg, db)
mock.mock(server, 'client')
cmd1 = self.makeCommandMessage(1, 1, self.getNVF('foo:source'))
cmd2 = self.makeCommandMessage(2, 2, self.getNVF('bar:source'))
server.requestCommandAssignment(cmd1, cmd2)
node = self.makeRegisterNodeMessage(loadThreshold=1).getNode()
server.nodeRegistered('session1', node)
nodeInfo = self.makeMachineInfo(loadavg=10)
server.nodeUpdated('session1', nodeInfo, ['CMD-1'])
# the command completed, but the load average for this node is
# too high, so we wait.
server.commandCompleted(cmd1.getCommandId())
assert(not server.listAssignedCommands())
nodeInfo = self.makeMachineInfo(loadavg=0.5)
# the load average is low again, so now the second job is assigned.
server.nodeUpdated('session1', nodeInfo, [])
assert(server.listAssignedCommands())
