def test_string_value_function(self):
token = self.parser.parse('true()')
document = ElementTree.parse(
io.StringIO(u'<A>123<B1>456</B1><B2>789</B2></A>'))
element = ElementTree.Element('schema')
attribute = AttributeNode('id', '0212349350')
namespace = NamespaceNode('xs', 'http://www.w3.org/2001/XMLSchema')
comment = ElementTree.Comment('nothing important')
pi = ElementTree.ProcessingInstruction('action', 'nothing to do')
text = 'betelgeuse'
self.assertEqual(token.string_value(document), '123456789')
self.assertEqual(token.string_value(element), '')
self.assertEqual(token.string_value(attribute), '0212349350')
self.assertEqual(token.string_value(namespace),
'http://www.w3.org/2001/XMLSchema')
self.assertEqual(token.string_value(comment), 'nothing important')
self.assertEqual(token.string_value(pi), 'action nothing to do')
self.assertEqual(token.string_value(text), 'betelgeuse')
self.assertEqual(token.string_value(None), '')
self.assertEqual(token.string_value(Decimal(+1999)), '1999')
self.assertEqual(token.string_value(Decimal('+1999')), '1999')
self.assertEqual(token.string_value(Decimal('+19.0010')), '19.001')
self.assertEqual(token.string_value(10), '10')
self.assertEqual(token.string_value(1e99), '1E99')
self.assertEqual(token.string_value(1e-05), '1E-05')
self.assertEqual(token.string_value(1.00), '1')
self.assertEqual(token.string_value(+19.0010), '19.001')
self.assertEqual(token.string_value(float('nan')), 'NaN')
self.assertEqual(token.string_value(float('inf')), 'INF')
self.assertEqual(token.string_value(float('-inf')), '-INF')
self.assertEqual(token.string_value(()), '()')
tagged_object = Tagged()
self.assertEqual(token.string_value(tagged_object),
"Tagged(tag='root')")
with patch.multiple(DummyXsdType, is_simple=lambda x: True):
xsd_type = DummyXsdType()
typed_elem = TypedElement(elem=element,
xsd_type=xsd_type,
value=10)
self.assertEqual(token.string_value(typed_elem), '10')
typed_elem = TypedElement(elem=element,
xsd_type=xsd_type,
value=None)
self.assertEqual(token.string_value(typed_elem), '')
def test_select_results(self):
token = self.parser.parse('.')
elem = ElementTree.Element('A', attrib={'max': '30'})
elem.text = '10'
context = XPathContext(elem)
self.assertListEqual(list(token.select_results(context)), [elem])
context = XPathContext(elem, item=TypedElement(elem, 10))
self.assertListEqual(list(token.select_results(context)), [elem])
context = XPathContext(elem, item=AttributeNode('max', '30'))
self.assertListEqual(list(token.select_results(context)), ['30'])
context = XPathContext(elem,
item=TypedAttribute(AttributeNode('max', '30'),
30))
self.assertListEqual(list(token.select_results(context)), [30])
attribute = namedtuple('XsdAttribute', 'name type')('max', 'xs:string')
context = XPathContext(elem,
item=TypedAttribute(
AttributeNode('max', attribute), 30))
self.assertListEqual(list(token.select_results(context)), [attribute])
context = XPathContext(elem, item=10)
self.assertListEqual(list(token.select_results(context)), [10])
context = XPathContext(elem, item='10')
self.assertListEqual(list(token.select_results(context)), ['10'])
def test_node_kind_function(self):
document = ElementTree.parse(io.StringIO(u'<A/>'))
element = ElementTree.Element('schema')
attribute = AttributeNode('id', '0212349350')
namespace = NamespaceNode('xs', 'http://www.w3.org/2001/XMLSchema')
comment = ElementTree.Comment('nothing important')
pi = ElementTree.ProcessingInstruction('action', 'nothing to do')
text = TextNode('betelgeuse')
self.assertEqual(node_kind(document), 'document-node')
self.assertEqual(node_kind(element), 'element')
self.assertEqual(node_kind(attribute), 'attribute')
self.assertEqual(node_kind(namespace), 'namespace')
self.assertEqual(node_kind(comment), 'comment')
self.assertEqual(node_kind(pi), 'processing-instruction')
self.assertEqual(node_kind(text), 'text')
self.assertIsNone(node_kind(()))
self.assertIsNone(node_kind(None))
self.assertIsNone(node_kind(10))
with patch.multiple(DummyXsdType, is_simple=lambda x: True):
xsd_type = DummyXsdType()
typed_attribute = TypedAttribute(attribute, xsd_type, '0212349350')
self.assertEqual(node_kind(typed_attribute), 'attribute')
typed_element = TypedElement(element, xsd_type, None)
self.assertEqual(node_kind(typed_element), 'element')
def test_add_xsd_type_alternatives(self):
schema = xmlschema.XMLSchema("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root" type="xs:int"/>
<xs:attribute name="a" type="xs:string"/>
</xs:schema>""")
root_token = self.parser.parse('root')
self.assertIsNone(
root_token.add_xsd_type('xs:string')) # ignore non-schema items
self.assertIsNone(root_token.xsd_types)
xsd_type = root_token.add_xsd_type(schema.elements['root'])
self.assertEqual(root_token.xsd_types,
{'root': schema.meta_schema.types['int']})
self.assertIs(xsd_type, schema.meta_schema.types['int'])
root_token.xsd_types = None
typed_element = TypedElement(schema.elements['root'], xsd_type, 1)
xsd_type = root_token.add_xsd_type(typed_element)
self.assertEqual(root_token.xsd_types,
{'root': schema.meta_schema.types['int']})
self.assertIs(xsd_type, schema.meta_schema.types['int'])
attribute = AttributeNode('a', schema.attributes['a'])
typed_attribute = TypedAttribute(attribute,
schema.meta_schema.types['string'],
'alpha')
xsd_type = root_token.add_xsd_type(typed_attribute)
self.assertEqual(
root_token.xsd_types, {
'a': schema.meta_schema.types['string'],
'root': schema.meta_schema.types['int']
})
self.assertIs(xsd_type, schema.meta_schema.types['string'])
def test_typed_element_nodes(self):
element = ElementTree.Element('schema')
with patch.multiple(DummyXsdType, is_simple=lambda x: True):
xsd_type = DummyXsdType()
typed_element = TypedElement(element, xsd_type, None)
self.assertEqual(repr(typed_element), "TypedElement(tag='schema')")
def test_elem_iter_strings_function(self):
root = ElementTree.XML('<A>text1\n<B1>text2</B1>tail1<B2/><B3><C1>text3</C1></B3>tail2</A>')
result = ['text1\n', 'text2', 'tail1', 'tail2', 'text3']
self.assertListEqual(list(etree_iter_strings(root)), result)
with patch.multiple(DummyXsdType, has_mixed_content=lambda x: True):
xsd_type = DummyXsdType()
typed_root = TypedElement(elem=root, xsd_type=xsd_type, value='text1')
self.assertListEqual(list(etree_iter_strings(typed_root)), result)
norm_result = ['text1', 'text2', 'tail1', 'tail2', 'text3']
with patch.multiple(DummyXsdType, is_element_only=lambda x: True):
xsd_type = DummyXsdType()
typed_root = TypedElement(elem=root, xsd_type=xsd_type, value='text1')
self.assertListEqual(list(etree_iter_strings(typed_root)), norm_result)
comment = ElementTree.Comment('foo')
root[1].append(comment)
self.assertListEqual(list(etree_iter_strings(typed_root)), norm_result)
self.assertListEqual(list(etree_iter_strings(root)), result)
def test_node_name_function(self):
elem = ElementTree.Element('root')
attr = AttributeNode('a1', '20')
namespace = NamespaceNode('xs', 'http://www.w3.org/2001/XMLSchema')
self.assertEqual(node_name(elem), 'root')
self.assertEqual(node_name(attr), 'a1')
self.assertEqual(node_name(namespace), 'xs')
self.assertIsNone(node_name(()))
self.assertIsNone(node_name(None))
with patch.multiple(DummyXsdType, is_simple=lambda x: True):
xsd_type = DummyXsdType()
typed_elem = TypedElement(elem=elem, xsd_type=xsd_type, value=10)
self.assertEqual(node_name(typed_elem), 'root')
typed_attr = TypedAttribute(attribute=attr, xsd_type=xsd_type, value=20)
self.assertEqual(node_name(typed_attr), 'a1')
def test_match_element_node_function(self):
elem = ElementTree.Element('alpha')
empty_tag_elem = ElementTree.Element('')
self.assertTrue(match_element_node(elem))
self.assertTrue(match_element_node(elem, '*'))
self.assertFalse(match_element_node(empty_tag_elem, '*'))
with self.assertRaises(ValueError):
match_element_node(elem, '**')
with self.assertRaises(ValueError):
match_element_node(elem, '*:*:*')
with self.assertRaises(ValueError):
match_element_node(elem, 'foo:*')
self.assertFalse(match_element_node(empty_tag_elem, 'foo:*'))
self.assertFalse(match_element_node(elem, '{foo}*'))
with patch.multiple(DummyXsdType, has_mixed_content=lambda x: True):
xsd_type = DummyXsdType()
typed_elem = TypedElement(elem=elem, xsd_type=xsd_type, value='text1')
self.assertTrue(match_element_node(typed_elem, '*'))
def test_elem_iter_nodes_function(self):
root = ElementTree.XML('<A>text1\n<B1 a="10">text2</B1><B2/><B3><C1>text3</C1></B3></A>')
result = [root, TextNode('text1\n', root),
root[0], TextNode('text2', root[0]), root[1],
root[2], root[2][0], TextNode('text3', root[2][0])]
self.assertListEqual(list(etree_iter_nodes(root)), result)
self.assertListEqual(list(etree_iter_nodes(root, with_root=False)), result[1:])
with patch.multiple(DummyXsdType, has_mixed_content=lambda x: True):
xsd_type = DummyXsdType()
typed_root = TypedElement(root, xsd_type, 'text1')
self.assertListEqual(list(etree_iter_nodes(typed_root)), result)
result = result[:4] + [AttributeNode('a', '10', root[0])] + result[4:]
self.assertListEqual(list(etree_iter_nodes(root, with_attributes=True)), result)
comment = ElementTree.Comment('foo')
root[1].append(comment)
self.assertListEqual(list(etree_iter_nodes(root, with_attributes=True)), result)
def test_data_value_function(self):
token = self.parser.parse('true()')
if self.parser.version != '1.0':
with patch.multiple(DummyXsdType(),
is_simple=lambda x: False,
has_simple_content=lambda x: True) as xsd_type:
obj = TypedElement(ElementTree.XML('<age>19</age>'), xsd_type,
19)
self.assertEqual(token.data_value(obj), 19)
obj = AttributeNode('age', '19')
self.assertEqual(token.data_value(obj), UntypedAtomic('19'))
obj = NamespaceNode('tns', 'http://xpath.test/ns')
self.assertEqual(token.data_value(obj), 'http://xpath.test/ns')
obj = TextNode('19')
self.assertEqual(token.data_value(obj), UntypedAtomic('19'))
obj = ElementTree.XML('<root>a<e1>b</e1>c<e2>d</e2>e</root>')
self.assertEqual(token.data_value(obj), UntypedAtomic('abcde'))
obj = ElementTree.parse(
io.StringIO('<root>a<e1>b</e1>c<e2>d</e2>e</root>'))
self.assertEqual(token.data_value(obj), UntypedAtomic('abcde'))
obj = ElementTree.Comment("foo bar")
self.assertEqual(token.data_value(obj), 'foo bar')
obj = ElementTree.ProcessingInstruction('action', 'nothing to do')
self.assertEqual(token.data_value(obj), 'action nothing to do')
self.assertIsNone(token.data_value(None))
self.assertEqual(token.data_value(19), 19)
self.assertEqual(token.data_value('19'), '19')
self.assertFalse(token.data_value(False))
tagged_object = Tagged()
self.assertIsNone(token.data_value(tagged_object))
def test_get_xsd_type(self):
schema = xmlschema.XMLSchema("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="root" type="xs:int"/>
<xs:attribute name="a" type="xs:string"/>
</xs:schema>""")
root_token = self.parser.parse('root')
self.assertIsNone(root_token.xsd_types)
self.assertIsNone(root_token.get_xsd_type('root'))
self.parser.schema = xmlschema.xpath.XMLSchemaProxy(schema)
try:
root_token = self.parser.parse('root')
self.assertEqual(root_token.xsd_types,
{'root': schema.meta_schema.types['int']})
xsd_type = root_token.get_xsd_type('root')
self.assertEqual(xsd_type, schema.meta_schema.types['int'])
self.assertIsNone(root_token.get_xsd_type('node'))
TestElement = namedtuple('XsdElement', 'name local_name type')
root_token.add_xsd_type(
TestElement('node', 'node', schema.meta_schema.types['float']))
root_token.add_xsd_type(
TestElement('node', 'node',
schema.meta_schema.types['boolean']))
root_token.add_xsd_type(
TestElement('node', 'node',
schema.meta_schema.types['decimal']))
xsd_type = root_token.get_xsd_type('node')
self.assertEqual(xsd_type, schema.meta_schema.types['float'])
xsd_type = root_token.get_xsd_type(AttributeNode('node', 'false'))
self.assertEqual(xsd_type, schema.meta_schema.types['boolean'])
xsd_type = root_token.get_xsd_type(AttributeNode('node', 'alpha'))
self.assertEqual(xsd_type, schema.meta_schema.types['float'])
elem = ElementTree.Element('node')
elem.text = 'false'
xsd_type = root_token.get_xsd_type(elem)
self.assertEqual(xsd_type, schema.meta_schema.types['boolean'])
typed_element = TypedElement(elem, xsd_type, False)
self.assertIs(xsd_type, root_token.get_xsd_type(typed_element))
elem.text = 'alpha'
xsd_type = root_token.get_xsd_type(elem)
self.assertEqual(xsd_type, schema.meta_schema.types['float'])
finally:
self.parser.schema = None
schema = xmlschema.XMLSchema("""
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="a" type="aType"/>
<xs:complexType name="aType">
<xs:sequence>
<xs:element name="b1" type="xs:int"/>
<xs:element name="b2" type="xs:boolean"/>
</xs:sequence>
</xs:complexType>
</xs:schema>""")
self.parser.schema = xmlschema.xpath.XMLSchemaProxy(schema)
try:
root_token = self.parser.parse('a')
elem = ElementTree.Element('a')
elem.append(ElementTree.Element('b1'))
elem.append(ElementTree.Element('b2'))
elem[0].text = 14
elem[1].text = 'true'
self.assertEqual(root_token.get_xsd_type(elem),
schema.types['aType'])
TestElement = namedtuple('XsdElement', 'name local_name type')
root_token.add_xsd_type(
TestElement('a', 'a', schema.meta_schema.types['float']))
self.assertEqual(root_token.get_xsd_type(elem),
schema.types['aType'])
root_token.xsd_types['a'].insert(
0, schema.meta_schema.types['boolean'])
self.assertEqual(root_token.get_xsd_type(elem),
schema.types['aType'])
del elem[1]
self.assertEqual(root_token.get_xsd_type(elem),
schema.meta_schema.types['boolean'])
finally:
self.parser.schema = None