def test_complex_elements(self):
schema = self.get_schema("""
<xs:element name="A" type="A_type" />
<xs:complexType name="A_type" mixed="true">
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="a1" type="xs:short" use="required"/>
<xs:attribute name="a2" type="xs:negativeInteger"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
""")
self.check_encode(
schema.elements['A'], data={'@a1': 10, '@a2': -1, '$': 'simple '},
expected='<A a1="10" a2="-1">simple </A>',
)
self.check_encode(
schema.elements['A'], {'@a1': 10, '@a2': -1, '$': 'simple '},
ElementTree.fromstring('<A a1="10" a2="-1">simple </A>'),
)
self.check_encode(
schema.elements['A'], {'@a1': 10, '@a2': -1},
ElementTree.fromstring('<A a1="10" a2="-1"/>')
)
self.check_encode(
schema.elements['A'], {'@a1': 10, '$': 'simple '},
ElementTree.fromstring('<A a1="10">simple </A>')
)
self.check_encode(schema.elements['A'], {'@a2': -1, '$': 'simple '},
XMLSchemaValidationError)
schema = self.get_schema("""
<xs:element name="A" type="A_type" />
<xs:complexType name="A_type">
<xs:sequence>
<xs:element name="B1" type="xs:string"/>
<xs:element name="B2" type="xs:integer"/>
<xs:element name="B3" type="xs:boolean"/>
</xs:sequence>
</xs:complexType>
""")
self.check_encode(
xsd_component=schema.elements['A'],
data=dict([('B1', 'abc'), ('B2', 10), ('B3', False)]),
expected=u'<A>\n<B1>abc</B1>\n<B2>10</B2>\n<B3>false</B3>\n</A>',
indent=0,
)
self.check_encode(schema.elements['A'], {'B1': 'abc', 'B2': 10, 'B4': False},
XMLSchemaValidationError)
def test_nillable(self):
# Issue #76
xsd_string = """<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
<xs:element name="foo" type="Foo" />
<xs:complexType name="Foo">
<xs:sequence minOccurs="1" maxOccurs="1">
<xs:element name="bar" type="xs:integer" nillable="true" />
</xs:sequence>
</xs:complexType>
</xs:schema>
"""
xsd_schema = xmlschema.XMLSchema(xsd_string)
xml_string_1 = "<foo><bar>0</bar></foo>"
xml_string_2 = """<?xml version="1.0" encoding="UTF-8"?>
<foo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<bar xsi:nil="true"></bar>
</foo>
"""
self.assertTrue(
xsd_schema.is_valid(source=xml_string_1, use_defaults=False))
self.assertTrue(
xsd_schema.is_valid(source=xml_string_2, use_defaults=False))
obj = xsd_schema.decode(xml_string_2, use_defaults=False)
self.check_etree_elements(ElementTree.fromstring(xml_string_2),
xsd_schema.encode(obj))
def test_any_type(self):
any_type = xmlschema.XMLSchema.meta_schema.types['anyType']
xml_data_1 = ElementTree.Element('dummy')
self.assertIsNone(any_type.decode(xml_data_1))
xml_data_2 = ElementTree.fromstring(
'<root>\n <child_1/>\n <child_2/>\n</root>')
self.assertIsNone(
any_type.decode(xml_data_2)) # Currently no decoding yet
def parse_cp_raw_output(stdout,
output_xml=None,
xml_counter_file=None,
print_counter_xml=True):
parser_warnings = []
# analyze the xml
if output_xml is not None:
xml_parsed = ElementTree.ElementTree(
element=ElementTree.fromstring(output_xml))
xml_file_version = get_xml_file_version(xml_parsed)
if xml_file_version == QeXmlVersion.POST_6_2:
xml_data, logs = parse_xml_post_6_2(xml_parsed)
elif xml_file_version == QeXmlVersion.PRE_6_2:
xml_data = parse_cp_xml_output(output_xml)
else:
parser_warnings.append('Skipping the parsing of the xml file.')
xml_data = {}
# analyze the counter file, which keeps info on the steps
if xml_counter_file is not None:
if print_counter_xml:
xml_counter_data = parse_cp_xml_counter_output(xml_counter_file)
else:
xml_counter_data = parse_cp_counter_output(xml_counter_file)
else:
xml_counter_data = {}
stdout = stdout.split('\n')
# understand if the job ended smoothly
job_successful = any('JOB DONE' in line for line in reversed(stdout))
out_data = parse_cp_text_output(stdout, xml_data)
for key in out_data.keys():
if key in list(xml_data.keys()):
raise AssertionError(f'{key} found in both dictionaries')
if key in list(xml_counter_data.keys()):
raise AssertionError(f'{key} found in both dictionaries')
# out_data keys take precedence and overwrite xml_data keys,
# if the same key name is shared by both (but this should not happen!)
final_data = {
**xml_data,
**out_data,
**xml_counter_data,
}
if parser_warnings:
final_data['parser_warnings'] = parser_warnings
# TODO: parse the trajectory and save them in a reasonable format
return final_data, job_successful