def test_valid(self):
complex = complex_factory()
opener = ModelOpener(ComplexModel)
valid, log = opener.validate_instance(complex)
self.assertTrue(valid)
self.assertEquals(len(log), 0)
def test_sequence_always_the_same(self):
mo = ModelOpener(ManySimpleElements)
# Testing that the output for the schema is *always the same*
#NOTE:the following line is only meant for allowing the testcase to pass
mo.get_schema_xml()
out = mo.get_schema_xml()
for x in xrange(1000):
self.assertEquals(out, mo.get_schema_xml())
def test_baz_xsd_order(self):
expected_children_order = ['b' , 'a', 'z']
baz = ModelOpener(Baz)
for i in xrange(1000):
baz_xsd = baz.get_schema_xml()
baz_schema = lxml.etree.fromstring(baz_xsd)
baz_xsd_children = baz_schema.xpath('/xs:schema/xs:complexType\
[@name="Baz"]/xs:sequence/xs:element',
namespaces={'xs':'http://www.w3.org/2001/XMLSchema'})
self.assertTrue(baz_xsd_children)
self.assertEquals(expected_children_order, [child.get('name') for child in baz_xsd_children])
def test_foo_xsd_order(self):
expected_children_order = ['f' , 'o', 'o_', 'faz']
foo = ModelOpener(Foo)
for i in xrange(1000):
foo_xsd = foo.get_schema_xml()
foo_schema = lxml.etree.fromstring(foo_xsd)
foo_xsd_children = foo_schema.xpath('/xs:schema/xs:complexType\
[@name="Foo"]/xs:sequence/xs:element',
namespaces={'xs':'http://www.w3.org/2001/XMLSchema'})
self.assertTrue(foo_xsd_children)
self.assertEquals(expected_children_order, [child.get('name') for child in foo_xsd_children])
def test_invalid(self):
# Created two validation errors here
# 1) a is not nillable
# 2) i must be type xs:integer
n = NoNillable()
n.i = "A"
opener = ModelOpener(NoNillable)
valid, log = opener.validate_instance(n)
self.assertFalse(valid)
self.assertEquals(len(log), 2)
def test_get_instance_etree(self):
opener = ModelOpener(ComplexModel)
element = opener.get_instance_etree(complex_factory())
chidren = [child for child in element]
self.assertEqual(len(chidren), 4)
tag_contains = "complexmodel" in element.tag
#TODO: Clean up this test, it seems a bit magical
#TODO: Search the sub tags.
#TODO: Search the sub values
self.assertTrue(tag_contains)
def test_get_instance_xml(self):
opener = ModelOpener(ComplexModel)
xml_string = opener.get_instance_xml(complex_factory())
self.assertNotEquals(xml_string, None)
self.assertNotEquals(xml_string,"")
element = etree.fromstring(xml_string)
chidren = [child for child in element]
self.assertEqual(len(chidren), 4)
tag_contains = "complexmodel" in element.tag
#TODO: Clean up this test, it seems a bit magical
#TODO: Search the sub tags.
#TODO: Search the sub values
self.assertTrue(tag_contains)
class CustomizedInstanceTestCase(unittest.TestCase):
def setUp(self):
self.instance = bar_factory()
self.mo = ModelOpener(Bar)
self.xml = self.mo.get_instance_etree(self.instance)
def test_children_tag_order(self):
expected = [
"{bar}b", "{bar}a", "{bar}r", "{bar}f", "{bar}o", "{bar}o_",
"{bar}b1", "{bar}a2", "{bar}r2", "{bar}baz"
]
self.assertEquals(
expected,
[n.tag for n in self.xml.iterchildren()]
)
def setUp(self):
self.instance = bar_factory()
self.mo = ModelOpener(Bar)
self.xml = self.mo.get_instance_etree(self.instance)
def test_root_tag(self):
mo = ModelOpener(Bar)
xsd_doc = mo.get_schema_xml()
schema = lxml.etree.fromstring(xsd_doc)
root = schema.tag
self.assertEquals(NS_SCHEMA, root)
