def construct(self):
root = xmlutil.TemplateElement('flavor_access')
elem = xmlutil.SubTemplateElement(root,
'access',
selector='flavor_access')
make_flavor_access(elem)
return xmlutil.MainTemplate(root, 1)
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 test_make_flat_dict(self):
expected_xml = ("<?xml version='1.0' encoding='UTF-8'?>\n"
'<wrapper><a>foo</a><b>bar</b></wrapper>')
root = xmlutil.make_flat_dict('wrapper')
tmpl = xmlutil.MainTemplate(root, 1)
result = tmpl.serialize(dict(wrapper=dict(a='foo', b='bar')))
self.assertEqual(result, expected_xml)
def test_main_attach(self):
# Set up a main template
elem = xmlutil.TemplateElement('test')
tmpl = xmlutil.MainTemplate(elem, 1)
# Make sure it has a root but no subordinates
self.assertEqual(tmpl.root, elem)
self.assertEqual(len(tmpl.subordinates), 0)
# Try to attach an invalid subordinate
bad_elem = xmlutil.TemplateElement('test2')
self.assertRaises(ValueError, tmpl.attach, bad_elem)
self.assertEqual(len(tmpl.subordinates), 0)
# Try to attach an invalid and a valid subordinate
good_elem = xmlutil.TemplateElement('test')
self.assertRaises(ValueError, tmpl.attach, good_elem, bad_elem)
self.assertEqual(len(tmpl.subordinates), 0)
# Try to attach an inapplicable template
class InapplicableTemplate(xmlutil.Template):
def apply(self, main):
return False
inapp_tmpl = InapplicableTemplate(good_elem)
tmpl.attach(inapp_tmpl)
self.assertEqual(len(tmpl.subordinates), 0)
# Now try attaching an applicable template
tmpl.attach(good_elem)
self.assertEqual(len(tmpl.subordinates), 1)
self.assertEqual(tmpl.subordinates[0].root, good_elem)
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_make_flat_dict_with_colon_tagname_support(self):
# Our test object to serialize
obj = {'extra_specs': {'foo:bar': '999'}}
expected_xml = (("<?xml version='1.0' encoding='UTF-8'?>\n"
'<extra_specs><foo:bar xmlns:foo="foo">999</foo:bar>'
'</extra_specs>'))
# Set up our main template
root = xmlutil.make_flat_dict('extra_specs', colon_ns=True)
main = xmlutil.MainTemplate(root, 1)
result = main.serialize(obj)
self.assertEqual(expected_xml, result)
def test_main_copy(self):
# Construct a main template
elem = xmlutil.TemplateElement('test')
tmpl = xmlutil.MainTemplate(elem, 1, nsmap=dict(a='foo'))
# Give it a subordinate
subordinate = xmlutil.TemplateElement('test')
tmpl.attach(subordinate)
# Construct a copy
copy = tmpl.copy()
# Check to see if we actually managed a copy
self.assertNotEqual(tmpl, copy)
self.assertEqual(tmpl.root, copy.root)
self.assertEqual(tmpl.version, copy.version)
self.assertEqual(id(tmpl.nsmap), id(copy.nsmap))
self.assertNotEqual(id(tmpl.subordinates), id(copy.subordinates))
self.assertEqual(len(tmpl.subordinates), len(copy.subordinates))
self.assertEqual(tmpl.subordinates[0], copy.subordinates[0])
def test_make_flat_dict_with_parent(self):
# Our test object to serialize
obj = {
"device": {
"id": 1,
"extra_info": {
"key1": "value1",
"key2": "value2"
}
}
}
expected_xml = (("<?xml version='1.0' encoding='UTF-8'?>\n"
'<device id="1"><extra_info><key2>value2</key2>'
'<key1>value1</key1></extra_info></device>'))
root = xmlutil.TemplateElement('device', selector='device')
root.set('id')
extra = xmlutil.make_flat_dict('extra_info', root=root)
root.append(extra)
main = xmlutil.MainTemplate(root, 1)
result = main.serialize(obj)
self.assertEqual(expected_xml, result)
def construct(self):
root = xmlutil.TemplateElement('servers')
elem = xmlutil.SubTemplateElement(root, 'server', selector='servers')
make_server(elem, detailed=True)
return xmlutil.MainTemplate(root, 1, nsmap=server_nsmap)
def construct(self):
root = xmlutil.TemplateElement('servers')
elem = xmlutil.SubTemplateElement(root, 'server', selector='servers')
make_server(elem)
xmlutil.make_links(root, 'servers_links')
return xmlutil.MainTemplate(root, 1, nsmap=server_nsmap)
def construct(self):
elem = xmlutil.TemplateElement('test')
return xmlutil.MainTemplate(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'])
