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