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())