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 testGetImages(self):
handle = self.handle
kwargs = dict((x, x) for x in ("project", "stage", "branch"))
kwargs["order_by"] = "-time_created"
_image1 = mock.MockObject(name="foo", trailing_version="1-1-1", id="1")
_image2 = mock.MockObject(name="foo", trailing_version="2-2-2", id="2")
rb = handle.facade.rbuilder
mock.mockMethod(rb.getImages, None)
mock.mockMethod(handle.Images._getProductStage,
("project", "branch", "stage"))
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)
self.assertEqual([_image1], handle.Images.getImages("1"))
self.assertEqual([_image1, _image2], handle.Images.getImages("foo"))
self.assertEqual([_image2], handle.Images.getImages("foo=2-2-2"))
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 test_cancelImage(self):
handle = self.getRbuildHandle(mock.MockObject())
handle.Cancel.registerCommands()
handle.Cancel.initialize()
mock.mockMethod(handle.Cancel._promptUser)
mock.mockMethod(handle.Cancel._getCancelBuildJob)
_job = mock.MockObject()
_job._mock.set(status_code='200')
_bad_job = mock.MockObject()
_bad_job._mock.set(status_code='500')
handle.Cancel._promptUser._mock.setReturn(True, 'image1')
handle.Cancel._promptUser._mock.setReturn(True, 'image2')
handle.Cancel._promptUser._mock.setReturn(False, 'image3')
handle.Cancel._getCancelBuildJob._mock.setReturn(_job, 'image1')
handle.Cancel._getCancelBuildJob._mock.setReturn(_bad_job, 'image2')
handle.Cancel._cancelImage('image3')
handle.Cancel._promptUser._mock.assertCalled('image3')
handle.Cancel._getCancelBuildJob._mock.assertNotCalled()
handle.Cancel._cancelImage(['image1'])
handle.Cancel._promptUser._mock.assertCalled('image1')
handle.Cancel._getCancelBuildJob._mock.assertCalled('image1')
self.assertRaises(
errors.PluginError,
handle.Cancel._cancelImage,
['image1', 'image2'],
)
handle.Cancel._promptUser._mock.assertCalled('image1')
handle.Cancel._getCancelBuildJob._mock.assertCalled('image1')
def getRbuildHandle(self,
productStore=None,
cfg=None,
pluginManager=None,
userInterface=None,
logRoot=None,
mockOutput=True):
# Note: order of arguments is different because code in test suite
# assumes that first argument is productStore not cfg
if isinstance(productStore, mock.MockObject):
productStore.getRbuildConfigPath._mock.setReturn(self.workDir +
'/rbuildrc')
productStore.getRmakeConfigPath._mock.setReturn(self.workDir +
'/rmakerc')
if cfg is None:
self.rbuildCfg.repositoryMap = self.cfg.repositoryMap
cfg = self.rbuildCfg
if logRoot is None:
logRoot = self.workDir + '/.rbuild'
h = handle.RbuildHandle(cfg=cfg,
pluginManager=pluginManager,
productStore=productStore,
userInterface=userInterface,
logRoot=logRoot)
if mockOutput:
h.ui.outStream = mock.MockObject()
h.ui.errorStream = mock.MockObject()
return h
def testParseDescriptorData(self):
handle = self.getRbuildHandle(mock.MockObject())
dc = handle.DescriptorConfig
dc.initialize()
_field1 = mock.MockObject()
_field1._mock.set(name='foo')
_field2 = mock.MockObject()
_field2._mock.set(name='bar')
_field3 = mock.MockObject()
_field3._mock.set(name='baz')
_ddata = mock.MockObject()
_ddata.getField._mock.setReturn('FOO', 'foo')
_ddata.getField._mock.setReturn('BAR', 'bar')
_ddata.getField._mock.setReturn('BAZ', 'baz')
_ddata._descriptor.getDataFields._mock.setReturn([_field1, _field2])
dc._parseDescriptorData(_ddata)
self.assertEqual(dc._config, {'foo': 'FOO', 'bar': 'BAR'})
_ddata._descriptor.getDataFields._mock.setReturn([_field3])
dc._parseDescriptorData(_ddata)
self.assertEqual(dc._config, {
'foo': 'FOO',
'bar': 'BAR',
'baz': 'BAZ'
})
def testCreateBuildJobForStage(self):
handle, facade = self.prep()
handle.productStore.getActiveStageName._mock.setDefaultReturn('QA')
handle.productStore.getActiveStageLabel._mock.setReturn('localhost@foo:bar')
handle.product.getGroupSearchPaths._mock.setReturn([])
# rMake helper setup
mock.mockMethod(facade._getRmakeConfigWithContexts)
buildConfig = facade._getRmakeConfigWithContexts()[0]
buildConfig._mock.set(resolveTroves=[])
mock.mockMethod(facade._getRmakeHelperWithContexts)
rmakeClient = facade._getRmakeHelperWithContexts()[0]
rmakeClient._mock.enable('BUILD_RECURSE_GROUPS_SOURCE')
rmakeClient.BUILD_RECURSE_GROUPS_SOURCE = 'z'
# Set up the createBuildJob argument check and the job it returns
buildJob = mock.MockObject()
trv = mock.MockObject(cfg=buildConfig)
buildJob.iterTroves._mock.setReturn([trv])
rmakeClient.createBuildJob._mock.setDefaultReturn(buildJob)
mock.mockMethod(handle.facade.conary._findTroves)
handle.facade.conary._findTroves._mock.setDefaultReturn({})
facade.createBuildJobForStage(['a', 'b', 'c'])
handle.ui.progress._mock.assertCalled(
'Creating rMake build job for 3 items')
rmakeClient.createBuildJob._mock.assertCalled(['a', 'b', 'c'],
rebuild=True, recurseGroups='z',
limitToLabels=['localhost@foo:bar'], buildConfig=buildConfig)
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 _setupMockCommand(self, jobId, troveTup):
from rmake.worker import command
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.
buildTrove = self.newBuildTrove(jobId, *troveTup)
commandClass = mock.mockClass(command.BuildCommand, mock_runInit=True)
buildCommand = commandClass(self.getNodeCfg(),
'CMD-1',
jobId,
mock.MockObject(),
self.buildCfg,
mock.MockObject(),
buildTrove,
targetLabel=self.cfg.buildLabel,
builtTroves=[])
buildCommand._mock.disable('chrootFactory')
buildCommand._mock.disable('chroot')
buildCommand.chroot._mock.set(pid=50)
buildCommand.chroot._mock.set(
buildTrove=lambda *args, **kw: ('/tmp/foo', 50))
buildCommand._mock.disable('readPipe')
buildCommand._mock.disable('writePipe')
return buildCommand
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 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 testGetProductDefinitionSchemaVersion(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
client._api = mock.MockObject()
# no REST api case
client._api._mock.set(proddefSchemaVersion=None)
client._api._mock.set(version_info=None)
result = client.getProductDefinitionSchemaVersion()
self.failUnlessEqual(result, '2.0')
# pre 5.2.3 api
client._api._mock.set(proddefSchemaVersion='2.0')
client._api._mock.set(version_info=None)
result = client.getProductDefinitionSchemaVersion()
self.failUnlessEqual(result, '2.0')
# 5.2.3 > 6.1.0
client._api._mock.set(proddefSchemaVersion='3.0')
client._api._mock.set(version_info=None)
result = client.getProductDefinitionSchemaVersion()
self.failUnlessEqual(result, '3.0')
# 6.1.0 and later
vinfo = mock.MockObject()
vinfo._mock.set(product_definition_schema_version='4.3')
client._api._mock.set(version_info=vinfo)
client._api._mock.set(proddefSchemaVersion=None)
result = client.getProductDefinitionSchemaVersion()
self.failUnlessEqual(result, '4.3')
def testCreateDescriptorData(self):
handle = self.getRbuildHandle(mock.MockObject())
dc = handle.DescriptorConfig
dc.initialize()
mock.mock(dc, 'callbackClass')
mock.mock(dc, 'descriptorClass')
mock.mockMethod(dc._parseDescriptorData)
_ddata = mock.MockObject()
_descr = mock.MockObject()
_descr.createDescriptorData._mock.setReturn(_ddata, dc.callbackClass())
dc.descriptorClass._mock.setReturn(_descr, fromStream='bar')
self.assertEqual(dc.createDescriptorData(fromStream='bar'), _ddata)
dc.callbackClass._mock.assertCalled(handle.ui, {})
dc._parseDescriptorData._mock.assertCalled(_ddata)
dc._config = {'foo': 'FOO'}
dc.createDescriptorData(fromStream='bar'),
dc.callbackClass._mock.assertCalled(handle.ui, {'foo': 'FOO'})
dc._parseDescriptorData._mock.assertCalled(_ddata)
_descr.createDescriptorData._mock.raiseErrorOnAccess(
ConstraintsValidationError(['m1', 'm2']))
err = self.assertRaises(errors.PluginError,
dc.createDescriptorData,
fromStream='bar')
self.assertEqual(str(err), 'm1\nm2')
dc._parseDescriptorData._mock.assertNotCalled()
def testCreateTarget(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
_targets = []
def _append(x, tag=None):
_targets.append(x)
return x
client._api.targets._mock.set(append=_append)
_ddata = {
'name': 'foo',
'zone': 'local',
'description': 'Foo',
}
ddata = mock.MockObject()
ddata._mock.set(getField=lambda x: _ddata[x])
expected_results = xobj.parse(TARGET_XML)
results = client.createTarget(ddata, 'vmware')
self.assertEqual(results.toxml(), expected_results.toxml())
self.assertTrue(len(_targets) == 1)
def _append_error(x, tag=None):
raise robj.errors.HTTPConflictError(uri=None,
status=None,
reason=None,
response=None)
client._api.targets._mock.set(append=_append_error)
self.assertRaises(errors.RbuildError, client.createTarget, ddata,
'vmware')
self.assertTrue(len(_targets) == 1)
def testGetPlatformAutoLoadRecipes(self):
pd = proddef.ProductDefinition()
handle = conaryfacadetest.MockHandle()
handle.product = pd
handle.facade = mock.MockObject()
handle.getConfig().user = ('JeanValjean', 'password')
productStore = mock.MockInstance(dirstore.CheckoutProductStore)
productStore._mock.enableMethod('getPlatformAutoLoadRecipes')
productStore._mock.set(_handle=handle)
facade = conaryfacade.ConaryFacade(handle)
repos = conaryfacadetest.MockRepositoryClient()
self.mock(facade, '_getRepositoryClient', lambda: repos)
handle.facade._mock.set(conary=facade)
alr = productStore.getPlatformAutoLoadRecipes()
self.assertEquals(alr, [])
alRecipes = ['foo', 'bar']
for troveName in alRecipes:
pd.addPlatformAutoLoadRecipe(troveName)
pkg1 = self.makeTroveTuple('foo=/foo.rpath.com@foo:2/2-2-2')
groupTup1 = self.makeTroveTuple('group-foo=/foo.rpath.com@foo:1/1-1-1')
groupTrv1 = mock.MockObject(stableReturnValues=True)
groupTrv1.iterTroveList._mock.setDefaultReturn([pkg1])
self.mock(repos, 'getTroves', lambda *args, **kwargs: [groupTrv1])
pd.addSearchPath(groupTup1[0],
label=str(groupTup1[1].branch()),
version=str(groupTup1[1].trailingRevision()))
alr = productStore.getPlatformAutoLoadRecipes()
self.assertEquals(alr, ['foo=/foo.rpath.com@foo:2/2-2-2'])
def 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 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 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 testGetAllLabelsFromTroves(self):
handle, facade = self.prep()
mock.mock(facade, '_findTrovesFlattened')
specs = [('group-foo-appliance', 'foo@foo:foo', None)]
tups = [('group-foo-appliance', '/foo@foo:foo/1.2-3-4', 'is: x86')]
facade._findTrovesFlattened._mock.setReturn(tups, specs)
subTups = [mock.MockObject(), mock.MockObject()]
subTups[0][1].trailingLabel().asString._mock.setReturn(
'foo@foo:foo-bar')
subTups[1][1].trailingLabel().asString._mock.setReturn(
'foo@foo:foo-baz')
troves = [mock.MockObject()]
troves[0].iterTroveList._mock.setReturn(subTups,
strongRefs=True,
weakRefs=True)
troves[0].getVersion().trailingLabel().asString._mock.setReturn(
'foo@foo:foo')
mock.mock(facade, '_getRepositoryClient')
facade._getRepositoryClient().getTroves._mock.setReturn(
troves, tups, withFiles=False)
self.assertEquals(
facade.getAllLabelsFromTroves(specs),
set(['foo@foo:foo', 'foo@foo:foo-bar', 'foo@foo:foo-baz']))
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 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 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 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 prepReposState(self, facade):
mock.mockMethod(facade._getRepositoryStateFromDirectory)
repos = mock.MockObject()
sourceState = mock.MockObject()
facade._getRepositoryStateFromDirectory._mock.setDefaultReturn(
[repos, sourceState])
return (repos, sourceState)
def testGetProductDefinitionSchemaVersion(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
client._api = mock.MockObject()
# no REST api case
client._api._mock.set(proddefSchemaVersion=None)
client._api._mock.set(version_info=None)
e = self.assertRaises(errors.RbuildError,
client.getProductDefinitionSchemaVersion)
self.assertEquals(
e.msg,
'Unable to determine the product definition version offered by rBuilder'
)
# pre 5.2.3 api
client._api._mock.set(proddefSchemaVersion='2.0')
client._api._mock.set(version_info=None)
result = client.getProductDefinitionSchemaVersion()
self.failUnlessEqual(result, '2.0')
# 5.2.3 > 6.1.0
client._api._mock.set(proddefSchemaVersion='3.0')
client._api._mock.set(version_info=None)
result = client.getProductDefinitionSchemaVersion()
self.failUnlessEqual(result, '3.0')
# 6.1.0 and later
vinfo = mock.MockObject()
vinfo._mock.set(product_definition_schema_version='4.3')
client._api._mock.set(version_info=vinfo)
client._api._mock.set(proddefSchemaVersion=None)
result = client.getProductDefinitionSchemaVersion()
self.failUnlessEqual(result, '4.3')
def testRbuildConfigPath(self):
productStore = mock.MockObject()
cfg = mock.MockObject()
handle = self.getRbuildHandle(cfg=cfg,
pluginManager=mock.MockObject(),
productStore=productStore)
cfg.read._mock.assertCalled(self.workDir + '/rbuildrc',
exception=False)
def __init__(self, serverUrl=None):
self.serverUrl = serverUrl
self._cfg = None
self.facade = Facade()
self.facade.conary = conaryfacade.ConaryFacade(self)
self.productStore = mock.MockObject()
self.product = mock.MockObject()
self.ui = mock.MockObject()
def prep(self):
handle = mock.MockObject()
cfg = mock.MockObject(serverUrl='http://localhost',
user=('foo', 'bar'))
handle.getConfig._mock.setReturn(cfg)
handle.productStore.getActiveStageName._mock.setReturn('devel')
facade = rbuilderfacade.RbuilderFacade(handle)
return handle, facade
def testCheckProductCheckout(self):
self.getRbuildHandle()
from rbuild_plugins import init
class Stage(object):
def __init__(self, name):
self.name = name
os.chdir(self.workDir)
co = init.Init('init', None, None)
handle = mock.MockObject(stableReturnValues=True)
co.setHandle(handle)
#pylint: disable-msg=W0622
def mkdtemp(dir):
os.mkdir(dir + '/temp')
return dir + '/temp'
self.mock(tempfile, 'mkdtemp', mkdtemp)
handle.product.getProductShortname._mock.setReturn('foo')
handle.product.getProductVersion._mock.setReturn('1')
handle.product.getStages._mock.setReturn([Stage('devel'),
Stage('stable')])
handle.product.getLabelForStage._mock.setReturn(
'localhost@rpl:1-devel', 'devel')
handle.product.getLabelForStage._mock.setReturn(
'localhost@rpl:1', 'stable')
productStore = mock.MockObject()
productStore.getProduct._mock.setReturn(handle.product)
mock.mock(dirstore, 'CheckoutProductStore', returnValue=productStore)
# actual function call
co.createProductDirectory('/localhost@rpl:1/1.0-1')
# tests of result
handle.facade.conary.checkout._mock.assertCalled(
'product-definition',
'/localhost@rpl:1/1.0-1',
targetDir=self.workDir + '/temp/.rbuild/product-definition')
directories = [x[0][1] for x in dirstore.CheckoutProductStore._mock.calls]
self.assertEquals(directories,
[self.workDir+'/temp', 'foo-1'])
self.assertEquals(file(self.workDir+'/foo-1/devel/conaryrc').read(),
'# This file may be automatically overwritten by rbuild\n'
'buildLabel localhost@rpl:1-devel\n'
'installLabelPath localhost@rpl:1-devel\n')
self.assertEquals(file(self.workDir+'/foo-1/stable/conaryrc').read(),
'# This file may be automatically overwritten by rbuild\n'
'buildLabel localhost@rpl:1\n'
'installLabelPath localhost@rpl:1\n')
err = self.assertRaises(errors.PluginError, co.createProductDirectory,
'/localhost@rpl:1/1.0-1')
assert(str(err) == "Directory foo-1 already exists.")
co.createProductDirectory('/localhost@rpl:1/1.0-1', productDir='foo2')
assert(os.path.exists(self.workDir + '/foo2/devel/.stage'))
assert(os.path.exists(self.workDir + '/foo-1/devel/.stage'))
def testGetJobBasedOnProductGroups(self):
handle = self.getRbuildHandle()
self.rbuildCfg.serverUrl = None
from rbuild_plugins.build import groups
handle.productStore = mock.MockObject()
handle.product = mock.MockObject()
groupFlavors = [('group-dist', 'is: x86'),
('group-dist', 'is: x86_64')]
handle.productStore.getGroupFlavors._mock.setReturn(groupFlavors)
handle.productStore.getRmakeConfigPath._mock.setReturn(
self.workDir + '/rmakerc')
label = 'localhost@rpl:linux'
handle.productStore.getActiveStageLabel._mock.setReturn(label)
handle.product.getLabelForStage._mock.setReturn(label)
handle.product.getBaseFlavor._mock.setReturn('')
mock.mockMethod(handle.facade.conary._findTroves)
groupSpec = ('group-dist:source', None, None)
groupTup = self.makeTroveTuple('group-dist:source=@rpl:linux/1.0-1')
handle.facade.conary._findTroves._mock.setReturn(
{groupSpec : [groupTup]},
[groupSpec],
label, allowMissing=True)
groupsToBuild = ['group-dist{x86}', 'group-dist{x86_64}']
mock.mockMethod(handle.facade.rmake.createBuildJobForStage)
handle.facade.rmake.createBuildJobForStage._mock.setReturn('r1',
groupsToBuild, recurse=True)
# test1
job = groups._getJobBasedOnProductGroups(handle, {}, recurse=True)
assert(job == 'r1')
# test2: test to see what it does when there are no groups.
handle.facade.conary._findTroves._mock.setReturn({},
[groupSpec],
label, allowMissing=True)
job = groups._getJobBasedOnProductGroups(handle, {}, recurse=True)
assert(job is None)
# test3: when there is a replacement group recipe, we should use
# the one on disk and not search the repository for it.
groupRecipe = self.workDir + '/group-dist.recipe'
groupsToBuild = [ groupRecipe + '{x86}', groupRecipe + '{x86_64}']
handle.facade.rmake.createBuildJobForStage._mock.setReturn('r2',
groupsToBuild, recurse=True)
handle.facade.conary._findTroves._mock.setReturn({},
[], label,
allowMissing=True)
job = groups._getJobBasedOnProductGroups(handle,
{'group-dist' : groupRecipe},
recurse=True)
assert(job == 'r2')
# test 3 - no groups.
handle.productStore.getGroupFlavors._mock.setReturn([])
job = groups._getJobBasedOnProductGroups(handle, {}, recurse=True)
assert(job is None)
