def test_select_results(self):
token = self.parser.parse('.')
elem = ElementTree.Element('A', attrib={'max': '30'})
elem.text = '10'
xsd_type = DummyXsdType()
context = XPathContext(elem)
self.assertListEqual(list(token.select_results(context)), [elem])
context = XPathContext(elem, item=TypedElement(elem, xsd_type, 10))
self.assertListEqual(list(token.select_results(context)), [elem])
context = XPathContext(elem, item=AttributeNode('max', '30'))
self.assertListEqual(list(token.select_results(context)), ['30'])
item = TypedAttribute(AttributeNode('max', '30'), xsd_type, 30)
context = XPathContext(elem, item=item)
self.assertListEqual(list(token.select_results(context)), [30])
attribute = namedtuple('XsdAttribute',
'name local_name type')('max', 'max', xsd_type)
item = TypedAttribute(AttributeNode('max', attribute), xsd_type, 30)
context = XPathContext(elem, item=item)
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_match_attribute_node_function(self):
attr = AttributeNode('a1', '10', parent=None)
self.assertTrue(match_attribute_node(attr, '*'))
self.assertTrue(match_attribute_node(TypedAttribute(attr, None, 10), 'a1'))
with self.assertRaises(ValueError):
match_attribute_node(attr, '**')
with self.assertRaises(ValueError):
match_attribute_node(attr, '*:*:*')
with self.assertRaises(ValueError):
match_attribute_node(attr, 'foo:*')
self.assertTrue(match_attribute_node(attr, '*:a1'))
self.assertFalse(match_attribute_node(attr, '{foo}*'))
self.assertTrue(match_attribute_node(AttributeNode('{foo}a1', '10'), '{foo}*'))
attr = AttributeNode('{http://xpath.test/ns}a1', '10', parent=None)
self.assertTrue(match_attribute_node(attr, '*:a1'))
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_attribute_nodes(self):
parent = ElementTree.Element('element')
attribute = AttributeNode('id', '0212349350')
self.assertEqual(repr(attribute),
"AttributeNode(name='id', value='0212349350')")
self.assertEqual(attribute, AttributeNode('id', '0212349350'))
self.assertEqual(attribute.as_item(), ('id', '0212349350'))
self.assertNotEqual(attribute.as_item(), AttributeNode('id', '0212349350'))
self.assertNotEqual(attribute, AttributeNode('id', '0212349350', parent))
attribute = AttributeNode('id', '0212349350', parent)
self.assertEqual(attribute, AttributeNode('id', '0212349350', parent))
self.assertEqual(attribute.as_item(), ('id', '0212349350'))
self.assertNotEqual(attribute, AttributeNode('id', '0212349350'))
self.assertNotEqual(attribute, AttributeNode('id', '0212349350',
parent=ElementTree.Element('element')))
attribute = AttributeNode('value', '10', parent)
self.assertEqual(repr(attribute)[:65],
"AttributeNode(name='value', value='10', parent=<Element 'element'")
with patch.multiple(DummyXsdType, is_simple=lambda x: True):
xsd_type = DummyXsdType()
typed_attribute = TypedAttribute(attribute, xsd_type, 10)
self.assertEqual(repr(typed_attribute), "TypedAttribute(name='value')")
self.assertEqual(typed_attribute.as_item(), ('value', 10))
self.assertEqual(typed_attribute, TypedAttribute(attribute, DummyXsdType(), 10))
self.assertEqual(typed_attribute, TypedAttribute(attribute, None, 10))
self.assertEqual(typed_attribute,
TypedAttribute(AttributeNode('value', '10', parent), xsd_type, 10))
self.assertNotEqual(typed_attribute, TypedAttribute(attribute, xsd_type, '10'))
self.assertNotEqual(typed_attribute,
TypedAttribute(AttributeNode('value', '10'), xsd_type, 10))