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 testCreateProject(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
class response:
project_id = 42
client._api.projects.append._mock.setDefaultReturn(response)
projectId = client.createProject('title', 'shortname', 'hostname',
'domain.name')
self.assertEqual(projectId, 42)
proj = client._api.projects.append._mock.popCall()[0][0].project
self.assertEqual(proj.name, 'title')
self.assertEqual(proj.hostname, 'hostname')
self.assertEqual(proj.short_name, 'shortname')
self.assertEqual(proj.domain_name, 'domain.name')
self.assertEqual(proj.external, 'false')
client._api.projects.append._mock.raiseErrorOnAccess(
robj.errors.HTTPConflictError(uri=None,
status=None,
reason=None,
response=None))
err = self.assertRaises(errors.RbuildError, client.createProject,
'title', 'shortname', 'hostname',
'domain.name')
self.assertIn('conflicting', str(err))
def testAPI(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
self.failUnlessEqual(client._api, None)
mock.mock(robj, 'connect')
class v1:
name = 'v1'
class v2:
name = 'v2'
class top:
api_versions = [v2]
robj.connect._mock.setReturn(top, 'http://*****:*****@localhost/api')
err = self.assertRaises(errors.RbuildError, getattr, client, 'api')
self.assertEqual(
str(err), "No compatible REST API found on rBuilder "
"'http://*****:*****@localhost/api'")
self.assertEqual(client._api, None)
top.api_versions.append(v1)
robj.connect._mock.setReturn(top, 'http://*****:*****@localhost/api')
api = client.api
self.failIfEqual(client._api, None)
self.failUnlessEqual(api, v1)
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 testGetTargetTypes(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
TargetType = namedtuple('TargetType', 'name value')
client._api._mock.set(_uri='http://localhost')
client._api._client._mock.set(do_GET=lambda x: [
TargetType('vmware', 'VMWare'),
TargetType('ec2', 'Amazon EC2'),
])
results = client.getTargetTypes()
self.assertEqual(
results,
{
'vmware': TargetType('vmware', 'VMWare'),
'ec2': TargetType('ec2', 'Amazon EC2'),
},
)
def f(x):
raise robj.errors.HTTPNotFoundError(
uri='https://localhost/target_types',
status='404',
reason='Not Found',
response=None,
)
client._api._client._mock.set(do_GET=f)
self.assertRaises(errors.RbuildError, client.getTargetTypes)
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 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 testGetTarget(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(
['target'], "http://localhost/targets;filter_by=[name,EQUAL,foo]")
client._api._client.do_GET._mock.setReturn(
[], "http://localhost/targets;filter_by=[name,EQUAL,bar]")
self.assertEqual(client.getTarget('foo'), 'target')
err = self.assertRaises(errors.RbuildError, client.getTarget, 'bar')
self.assertIn('not found', str(err))
def testGetTargetDescriptor(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
TargetType = namedtuple('TargetType', 'name descriptor_create_target')
client._api._mock.set(_uri='http://localhost')
client._api._client._mock.set(do_GET=lambda x: [
TargetType('vmware', StringIO('descriptor data')),
])
results = client.getTargetDescriptor('vmware')
self.assertEqual(results, 'descriptor data')
results = client.getTargetDescriptor('foo')
self.assertEqual(results, None)
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 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 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 testConfigureTargetCredentials(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
job = mock.MockObject()
job.job_state._mock.set(name='Completed')
_jobs = []
def _append(x):
_jobs.append(x)
return job
target = mock.MockObject()
target.jobs._mock.set(append=_append)
ddata = mock.MockObject()
ddata._mock.set(toxml=lambda: '<descriptor_data/>')
results = client.configureTargetCredentials(target, ddata)
self.assertEqual(results, target)
self.assertTrue(len(_jobs) == 1)
job.job_state._mock.set(name='Failed')
self.assertRaises(errors.RbuildError, client.configureTarget, target,
ddata)
self.assertTrue(len(_jobs) == 2)
def testGetImages(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
client._api._mock.set(_uri='http://localhost')
err = self.assertRaises(errors.RbuildError,
client.getImages,
'foo',
stage='bar')
self.assertIn('Must provide', str(err))
_project = mock.MockObject()
_project._mock.set(id='http://localhost/projects/bar')
client._api._client.do_GET._mock.setReturn(
_project, 'http://localhost/projects/bar')
client._api._client.do_GET._mock.setReturn(
'image', "http://localhost/images;filter_by=AND(EQUAL(name,foo))"
";order_by=-time_created")
client._api._client.do_GET._mock.setReturn(
'image_version',
"http://localhost/images;filter_by=AND(EQUAL(name,foo)"
",EQUAL(trailing_version,1-1-1))"
";order_by=-time_created")
client._api._client.do_GET._mock.setReturn(
'project', "http://localhost/images;filter_by=AND(EQUAL(name,foo)"
",EQUAL(project.short_name,bar))"
";order_by=-time_created")
client._api._client.do_GET._mock.setReturn(
'project_stage',
"http://localhost/images;filter_by=AND(EQUAL(name,foo)"
",EQUAL(project.short_name,bar)"
",EQUAL(project_branch.label,baz)"
",EQUAL(stage_name,Release))"
";order_by=-time_created")
client._api._client.do_GET._mock.setReturn(
'project_stage_version',
"http://localhost/images;filter_by=AND(EQUAL(name,foo)"
",EQUAL(project.short_name,bar)"
",EQUAL(project_branch.label,baz)"
",EQUAL(stage_name,Release)"
",EQUAL(trailing_version,1-1-1))"
";order_by=-time_created")
client._api._client.do_GET._mock.setReturn(
[], "http://localhost/images;filter_by=AND(EQUAL(name,bar))"
";order_by=-time_created")
self.assertEqual(client.getImages('foo'), 'image')
self.assertEqual(client.getImages('foo', trailingVersion='1-1-1'),
'image_version')
self.assertEqual(client.getImages('foo', project='bar'), 'project')
self.assertEqual(
client.getImages('foo',
project='bar',
branch='baz',
stage='Release'), 'project_stage')
self.assertEqual(
client.getImages(
'foo',
project='bar',
branch='baz',
stage='Release',
trailingVersion='1-1-1',
), 'project_stage_version')
self.assertEqual(client.getImages('bar'), [])
def testGetTargets(self):
client = rbuilderfacade.RbuilderRESTClient('http://localhost', 'foo',
'bar', mock.MockObject())
mock.mock(client, '_api')
client._api._mock.set(targets=['foo', 'bar'])
self.assertEqual(client.getTargets(), ['foo', 'bar'])
