def construct(self):
root = xmlutil.TemplateElement('flavors')
elem = xmlutil.SubTemplateElement(root, 'flavor', selector='flavors')
make_flavor(elem)
alias = FlavorAccess.alias
namespace = FlavorAccess.namespace
return xmlutil.SubordinateTemplate(root, 1, nsmap={alias: namespace})
def construct(self):
root = xmlutil.TemplateElement('servers')
elem = xmlutil.SubTemplateElement(root, 'server', selector='servers')
make_server(elem)
return xmlutil.SubordinateTemplate(root, 1, nsmap={
Extended_server_attributes.alias: \
Extended_server_attributes.namespace})
def construct(self):
root = xmlutil.TemplateElement('server', selector='server')
make_server(root)
return xmlutil.SubordinateTemplate(
root,
1,
nsmap={Extended_volumes.alias: Extended_volumes.namespace})
def test__serialize_with_empty_datum_selector(self):
# Our test object to serialize
obj = {
'test': {
'name': 'foobar',
'image': ''
},
}
root = xmlutil.TemplateElement('test', selector='test', name='name')
main = xmlutil.MainTemplate(root, 1)
root_subordinate = xmlutil.TemplateElement('test', selector='test')
image = xmlutil.SubTemplateElement(root_subordinate,
'image',
selector='image')
image.set('id')
xmlutil.make_links(image, 'links')
subordinate = xmlutil.SubordinateTemplate(root_subordinate, 1)
main.attach(subordinate)
siblings = main._siblings()
result = main._serialize(None, obj, siblings)
self.assertEqual(result.tag, 'test')
self.assertEqual(result[0].tag, 'image')
self.assertEqual(result[0].get('id'), str(obj['test']['image']))
def test_subordinate_apply(self):
# Construct a main template
elem = xmlutil.TemplateElement('test')
main = xmlutil.MainTemplate(elem, 3)
# Construct a subordinate template with applicable minimum version
subordinate = xmlutil.SubordinateTemplate(elem, 2)
self.assertEqual(subordinate.apply(main), True)
# Construct a subordinate template with equal minimum version
subordinate = xmlutil.SubordinateTemplate(elem, 3)
self.assertEqual(subordinate.apply(main), True)
# Construct a subordinate template with inapplicable minimum version
subordinate = xmlutil.SubordinateTemplate(elem, 4)
self.assertEqual(subordinate.apply(main), False)
# Construct a subordinate template with applicable version range
subordinate = xmlutil.SubordinateTemplate(elem, 2, 4)
self.assertEqual(subordinate.apply(main), True)
# Construct a subordinate template with low version range
subordinate = xmlutil.SubordinateTemplate(elem, 1, 2)
self.assertEqual(subordinate.apply(main), False)
# Construct a subordinate template with high version range
subordinate = xmlutil.SubordinateTemplate(elem, 4, 5)
self.assertEqual(subordinate.apply(main), False)
# Construct a subordinate template with matching version range
subordinate = xmlutil.SubordinateTemplate(elem, 3, 3)
self.assertEqual(subordinate.apply(main), True)
def construct(self):
root = xmlutil.TemplateElement('virtual_interfaces',
selector='virtual_interfaces')
elem = xmlutil.SubTemplateElement(root,
'virtual_interface',
selector='virtual_interfaces')
make_vif(elem)
return xmlutil.SubordinateTemplate(
root,
1,
nsmap={
Extended_virtual_interfaces_net.alias:
Extended_virtual_interfaces_net.namespace
})
def construct(self):
root = xmlutil.TemplateElement('server')
root.set('adminPass')
return xmlutil.SubordinateTemplate(root, 1, nsmap=server_nsmap)
def construct(self):
root = xmlutil.TemplateElement('servers')
elem = xmlutil.SubTemplateElement(root, 'server', selector='servers')
make_server(elem)
return xmlutil.SubordinateTemplate(
root, 1, nsmap={Server_usage.alias: Server_usage.namespace})
def construct(self):
elem = xmlutil.TemplateElement('test')
return xmlutil.SubordinateTemplate(elem, 1)
def test__serialize(self):
# Our test object to serialize
obj = {
'test': {
'name': 'foobar',
'values': [1, 2, 3, 4],
'attrs': {
'a': 1,
'b': 2,
'c': 3,
'd': 4,
},
'image': {
'name': 'image_foobar',
'id': 42,
},
},
}
# Set up our main template
root = xmlutil.TemplateElement('test', selector='test', name='name')
value = xmlutil.SubTemplateElement(root, 'value', selector='values')
value.text = xmlutil.Selector()
attrs = xmlutil.SubTemplateElement(root, 'attrs', selector='attrs')
xmlutil.SubTemplateElement(attrs,
'attr',
selector=xmlutil.get_items,
key=0,
value=1)
main = xmlutil.MainTemplate(root, 1, nsmap=dict(f='foo'))
# Set up our subordinate template
root_subordinate = xmlutil.TemplateElement('test', selector='test')
image = xmlutil.SubTemplateElement(root_subordinate,
'image',
selector='image',
id='id')
image.text = xmlutil.Selector('name')
subordinate = xmlutil.SubordinateTemplate(root_subordinate,
1,
nsmap=dict(b='bar'))
# Attach the subordinate to the main...
main.attach(subordinate)
# Try serializing our object
siblings = main._siblings()
nsmap = main._nsmap()
result = main._serialize(None, obj, siblings, nsmap)
# Now we get to manually walk the element tree...
self.assertEqual(result.tag, 'test')
self.assertEqual(len(result.nsmap), 2)
self.assertEqual(result.nsmap['f'], 'foo')
self.assertEqual(result.nsmap['b'], 'bar')
self.assertEqual(result.get('name'), obj['test']['name'])
for idx, val in enumerate(obj['test']['values']):
self.assertEqual(result[idx].tag, 'value')
self.assertEqual(result[idx].text, str(val))
idx += 1
self.assertEqual(result[idx].tag, 'attrs')
for attr in result[idx]:
self.assertEqual(attr.tag, 'attr')
self.assertEqual(attr.get('value'),
str(obj['test']['attrs'][attr.get('key')]))
idx += 1
self.assertEqual(result[idx].tag, 'image')
self.assertEqual(result[idx].get('id'),
str(obj['test']['image']['id']))
self.assertEqual(result[idx].text, obj['test']['image']['name'])
def construct(self):
root = xmlutil.TemplateElement('server', selector='server')
make_server(root)
alias = Extended_server_attributes.alias
namespace = Extended_server_attributes.namespace
return xmlutil.SubordinateTemplate(root, 1, nsmap={alias: namespace})
def construct(self):
root = xmlutil.TemplateElement('image', selector='image')
make_image(root)
return xmlutil.SubordinateTemplate(
root, 1, nsmap={Image_size.alias: Image_size.namespace})
def construct(self):
root = xmlutil.TemplateElement('flavors')
elem = xmlutil.SubTemplateElement(root, 'flavor', selector='flavors')
make_flavor(elem)
return xmlutil.SubordinateTemplate(
root, 1, nsmap={Flavorextradata.alias: Flavorextradata.namespace})
