def test_get_element_method(self): schema_proxy = XMLSchemaProxy(self.xs1) qname = '{%s}cars' % self.xs1.target_namespace self.assertIs(schema_proxy.get_element(qname), self.xs1.elements['cars']) qname = '{%s}unknown' % self.xs1.target_namespace self.assertIsNone(schema_proxy.get_element(qname))
class XMLSchemaProxyTest(xpath_test_class.XPathTestCase): @classmethod def setUpClass(cls): cls.schema = xmlschema.XMLSchema(''' <!-- Dummy schema for testing proxy API --> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://xpath.test/ns"> <xs:element name="test_element" type="xs:string"/> <xs:attribute name="test_attribute" type="xs:string"/> <xs:element name="A"> <xs:complexType> <xs:sequence> <xs:element name="B1"/> <xs:element name="B2"/> <xs:element name="B3"/> </xs:sequence> </xs:complexType> </xs:element> </xs:schema>''') def setUp(self): self.schema_proxy = XMLSchemaProxy(self.schema) self.parser = XPath2Parser(namespaces=self.namespaces, schema=self.schema_proxy) def test_abstract_xsd_schema(self): class GlobalMaps: types = {} attributes = {} elements = {} substitution_groups = {} class XsdSchema: tag = '{%s}schema' % XSD_NAMESPACE xsd_version = '1.1' maps = GlobalMaps() text = None @property def attrib(self): return {} def __iter__(self): return iter(()) def find(self, path, namespaces=None): return schema = XsdSchema() self.assertEqual(schema.tag, '{http://www.w3.org/2001/XMLSchema}schema') self.assertIsNone(schema.text) def test_schema_proxy_init(self): schema_src = """<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="test_element" type="xs:string"/> </xs:schema>""" schema_tree = ElementTree.parse(io.StringIO(schema_src)) self.assertIsInstance(XMLSchemaProxy(), XMLSchemaProxy) self.assertIsInstance(XMLSchemaProxy(xmlschema.XMLSchema(schema_src)), XMLSchemaProxy) with self.assertRaises(TypeError): XMLSchemaProxy(schema=schema_tree) with self.assertRaises(TypeError): XMLSchemaProxy(schema=xmlschema.XMLSchema(schema_src), base_element=schema_tree) with self.assertRaises(TypeError): XMLSchemaProxy(schema=xmlschema.XMLSchema(schema_src), base_element=schema_tree.getroot()) schema = xmlschema.XMLSchema(schema_src) with self.assertRaises(ValueError): XMLSchemaProxy(base_element=schema.elements['test_element']) def test_xmlschema_proxy(self): context = XPathContext(root=self.etree.XML( '<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"/>')) self.wrong_syntax("schema-element(*)") self.wrong_name("schema-element(nil)") self.wrong_name("schema-element(xs:string)") self.check_value("schema-element(xs:complexType)", MissingContextError) self.check_value("self::schema-element(xs:complexType)", NameError, context) self.check_value("self::schema-element(xs:schema)", [context.item], context) self.check_tree("schema-element(xs:group)", '(schema-element (: (xs) (group)))') attribute = context.item = AttributeNode(XML_LANG, 'en') self.wrong_syntax("schema-attribute(*)") self.wrong_name("schema-attribute(nil)") self.wrong_name("schema-attribute(xs:string)") self.check_value("schema-attribute(xml:lang)", MissingContextError) self.check_value("schema-attribute(xml:lang)", NameError, context) self.check_value("self::schema-attribute(xml:lang)", [context.item], context) self.check_tree("schema-attribute(xsi:schemaLocation)", '(schema-attribute (: (xsi) (schemaLocation)))') token = self.parser.parse("self::schema-attribute(xml:lang)") context.item = attribute context.axis = 'attribute' self.assertEqual(list(token.select(context)), [context.item]) def test_bind_parser_method(self): schema_src = dedent(""" <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:simpleType name="stringType"> <xs:restriction base="xs:string"/> </xs:simpleType> </xs:schema>""") schema = xmlschema.XMLSchema(schema_src) schema_proxy = XMLSchemaProxy(schema=schema) parser = XPath2Parser(namespaces=self.namespaces) self.assertFalse(parser.is_schema_bound()) schema_proxy.bind_parser(parser) self.assertTrue(parser.is_schema_bound()) self.assertIs(schema_proxy, parser.schema) # To test AbstractSchemaProxy.bind_parser() parser = XPath2Parser(namespaces=self.namespaces) super(XMLSchemaProxy, schema_proxy).bind_parser(parser) self.assertIs(schema_proxy, parser.schema) super(XMLSchemaProxy, schema_proxy).bind_parser(parser) self.assertIs(schema_proxy, parser.schema) def test_schema_constructors(self): schema_src = dedent(""" <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:simpleType name="stringType"> <xs:restriction base="xs:string"/> </xs:simpleType> <xs:simpleType name="intType"> <xs:restriction base="xs:int"/> </xs:simpleType> </xs:schema>""") schema = xmlschema.XMLSchema(schema_src) schema_proxy = XMLSchemaProxy(schema=schema) parser = XPath2Parser(namespaces=self.namespaces, schema=schema_proxy) with self.assertRaises(NameError) as ctx: parser.schema_constructor(XSD_ANY_ATOMIC_TYPE) self.assertIn('XPST0080', str(ctx.exception)) with self.assertRaises(NameError) as ctx: parser.schema_constructor(XSD_NOTATION) self.assertIn('XPST0080', str(ctx.exception)) token = parser.parse('stringType("apple")') self.assertEqual(token.symbol, 'stringType') self.assertEqual(token.label, 'constructor function') self.assertEqual(token.evaluate(), 'apple') token = parser.parse('stringType(())') self.assertEqual(token.symbol, 'stringType') self.assertEqual(token.label, 'constructor function') self.assertEqual(token.evaluate(), []) token = parser.parse('stringType(10)') self.assertEqual(token.symbol, 'stringType') self.assertEqual(token.label, 'constructor function') self.assertEqual(token.evaluate(), '10') token = parser.parse('stringType(.)') self.assertEqual(token.symbol, 'stringType') self.assertEqual(token.label, 'constructor function') token = parser.parse('intType(10)') self.assertEqual(token.symbol, 'intType') self.assertEqual(token.label, 'constructor function') self.assertEqual(token.evaluate(), 10) with self.assertRaises(ValueError) as ctx: parser.parse('intType(true())') self.assertIn('FORG0001', str(ctx.exception)) def test_get_context_method(self): schema_proxy = XMLSchemaProxy() self.assertIsInstance(schema_proxy.get_context(), XPathContext) self.assertIsInstance( super(XMLSchemaProxy, schema_proxy).get_context(), XPathContext) def test_get_type_api(self): schema_proxy = XMLSchemaProxy() self.assertIsNone(schema_proxy.get_type('unknown')) self.assertEqual(schema_proxy.get_type('{%s}string' % XSD_NAMESPACE), xmlschema.XMLSchema.builtin_types()['string']) def test_xsd_version_api(self): self.assertEqual(self.schema_proxy.xsd_version, '1.0') def test_find_api(self): schema_src = """<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="test_element" type="xs:string"/> </xs:schema>""" schema = xmlschema.XMLSchema(schema_src) schema_proxy = XMLSchemaProxy(schema=schema) self.assertEqual(schema_proxy.find('/test_element'), schema.elements['test_element']) def test_get_attribute_api(self): self.assertIs( self.schema_proxy.get_attribute( "{http://xpath.test/ns}test_attribute"), self.schema_proxy. _schema.maps.attributes["{http://xpath.test/ns}test_attribute"]) def test_get_element_api(self): self.assertIs( self.schema_proxy.get_element( "{http://xpath.test/ns}test_element"), self.schema_proxy. _schema.maps.elements["{http://xpath.test/ns}test_element"]) def test_get_substitution_group_api(self): self.assertIsNone(self.schema_proxy.get_substitution_group('x')) def test_is_instance_api(self): self.assertFalse( self.schema_proxy.is_instance(True, '{%s}integer' % XSD_NAMESPACE)) self.assertTrue( self.schema_proxy.is_instance(5, '{%s}integer' % XSD_NAMESPACE)) self.assertFalse( self.schema_proxy.is_instance('alpha', '{%s}integer' % XSD_NAMESPACE)) self.assertTrue( self.schema_proxy.is_instance('alpha', '{%s}string' % XSD_NAMESPACE)) self.assertTrue( self.schema_proxy.is_instance('alpha beta', '{%s}token' % XSD_NAMESPACE)) self.assertTrue( self.schema_proxy.is_instance('alpha', '{%s}Name' % XSD_NAMESPACE)) self.assertFalse( self.schema_proxy.is_instance('alpha beta', '{%s}Name' % XSD_NAMESPACE)) self.assertFalse( self.schema_proxy.is_instance('1alpha', '{%s}Name' % XSD_NAMESPACE)) self.assertTrue( self.schema_proxy.is_instance('alpha', '{%s}NCName' % XSD_NAMESPACE)) self.assertFalse( self.schema_proxy.is_instance('eg:alpha', '{%s}NCName' % XSD_NAMESPACE)) def test_cast_as_api(self): schema_proxy = XMLSchemaProxy() self.assertEqual( schema_proxy.cast_as('19', '{%s}short' % XSD_NAMESPACE), 19) def test_attributes_type(self): parser = XPath2Parser(namespaces=self.namespaces) token = parser.parse("@min le @max") context = XPathContext(self.etree.XML('<root min="10" max="20" />')) self.assertTrue(token.evaluate(context)) context = XPathContext(self.etree.XML('<root min="10" max="2" />')) self.assertTrue(token.evaluate(context)) schema = xmlschema.XMLSchema(''' <xs:schema xmlns="http://xpath.test/ns" xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://xpath.test/ns"> <xs:element name="range" type="intRange"/> <xs:complexType name="intRange"> <xs:attribute name="min" type="xs:int"/> <xs:attribute name="max" type="xs:int"/> </xs:complexType> </xs:schema>''') parser = XPath2Parser(namespaces=self.namespaces, schema=XMLSchemaProxy(schema, schema.elements['range'])) token = parser.parse("@min le @max") context = XPathContext(self.etree.XML('<root min="10" max="20" />')) self.assertTrue(token.evaluate(context)) context = XPathContext(self.etree.XML('<root min="10" max="2" />')) self.assertFalse(token.evaluate(context)) schema = xmlschema.XMLSchema(''' <xs:schema xmlns="http://xpath.test/ns" xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://xpath.test/ns"> <xs:element name="range" type="intRange"/> <xs:complexType name="intRange"> <xs:attribute name="min" type="xs:int"/> <xs:attribute name="max" type="xs:string"/> </xs:complexType> </xs:schema>''') parser = XPath2Parser(namespaces=self.namespaces, schema=XMLSchemaProxy(schema, schema.elements['range'])) self.assertRaises(TypeError, parser.parse, '@min le @max') def test_elements_type(self): schema = xmlschema.XMLSchema(''' <xs:schema xmlns="http://xpath.test/ns" xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://xpath.test/ns"> <xs:element name="values"> <xs:complexType> <xs:sequence> <xs:element name="a" type="xs:string"/> <xs:element name="b" type="xs:integer"/> <xs:element name="c" type="xs:boolean"/> <xs:element name="d" type="xs:float"/> </xs:sequence> </xs:complexType> </xs:element> </xs:schema>''') parser = XPath2Parser(namespaces={ '': "http://xpath.test/ns", 'xs': XSD_NAMESPACE }, schema=XMLSchemaProxy(schema)) token = parser.parse("//a") self.assertEqual(token[0].xsd_types['a'], schema.maps.types['{%s}string' % XSD_NAMESPACE]) token = parser.parse("//b") self.assertEqual(token[0].xsd_types['b'], schema.maps.types['{%s}integer' % XSD_NAMESPACE]) token = parser.parse("//values/c") self.assertEqual(token[0][0].xsd_types["{http://xpath.test/ns}values"], schema.elements['values'].type) self.assertEqual(token[1].xsd_types['c'], schema.maps.types['{%s}boolean' % XSD_NAMESPACE]) token = parser.parse("values/c") self.assertEqual(token[0].xsd_types['{http://xpath.test/ns}values'], schema.elements['values'].type) self.assertEqual(token[1].xsd_types['c'], schema.maps.types['{%s}boolean' % XSD_NAMESPACE]) token = parser.parse("values/*") self.assertEqual( token[1].xsd_types, { 'a': schema.maps.types['{%s}string' % XSD_NAMESPACE], 'b': schema.maps.types['{%s}integer' % XSD_NAMESPACE], 'c': schema.maps.types['{%s}boolean' % XSD_NAMESPACE], 'd': schema.maps.types['{%s}float' % XSD_NAMESPACE], }) def test_elements_and_attributes_type(self): schema = xmlschema.XMLSchema(''' <xs:schema xmlns="http://xpath.test/ns" xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://xpath.test/ns"> <xs:element name="values"> <xs:complexType> <xs:sequence> <xs:element name="a" type="xs:string"/> <xs:element name="b" type="rangeType"/> <xs:element name="c" type="xs:boolean"/> <xs:element name="d" type="xs:float"/> </xs:sequence> </xs:complexType> </xs:element> <xs:complexType name="rangeType"> <xs:simpleContent> <xs:extension base="xs:integer"> <xs:attribute name="min" type="xs:integer"/> <xs:attribute name="max" type="xs:integer"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:schema>''') parser = XPath2Parser(namespaces={ '': "http://xpath.test/ns", 'xs': XSD_NAMESPACE }, schema=XMLSchemaProxy(schema)) token = parser.parse("//a") self.assertEqual(token[0].xsd_types['a'], schema.maps.types['{%s}string' % XSD_NAMESPACE]) token = parser.parse("//b") self.assertEqual(token[0].xsd_types['b'], schema.types['rangeType']) token = parser.parse("values/c") self.assertEqual(token[0].xsd_types['{http://xpath.test/ns}values'], schema.elements['values'].type) self.assertEqual(token[1].xsd_types['c'], schema.maps.types['{%s}boolean' % XSD_NAMESPACE]) token = parser.parse("//b/@min") self.assertEqual(token[0][0].xsd_types['b'], schema.types['rangeType']) self.assertEqual(token[1][0].xsd_types['min'], schema.maps.types['{%s}integer' % XSD_NAMESPACE]) token = parser.parse("values/b/@min") self.assertEqual(token[0][0].xsd_types['{http://xpath.test/ns}values'], schema.elements['values'].type) self.assertEqual(token[0][1].xsd_types['b'], schema.types['rangeType']) self.assertEqual(token[1][0].xsd_types['min'], schema.maps.types['{%s}integer' % XSD_NAMESPACE]) token = parser.parse("//b/@min lt //b/@max") self.assertEqual(token[0][0][0].xsd_types['b'], schema.types['rangeType']) self.assertEqual(token[0][1][0].xsd_types['min'], schema.maps.types['{%s}integer' % XSD_NAMESPACE]) self.assertEqual(token[1][0][0].xsd_types['b'], schema.types['rangeType']) self.assertEqual(token[1][1][0].xsd_types['max'], schema.maps.types['{%s}integer' % XSD_NAMESPACE]) root = self.etree.XML( '<values xmlns="http://xpath.test/ns"><b min="19"/></values>') context = XPathContext(root, namespaces={'': "http://xpath.test/ns"}) self.assertIsNone(token.evaluate(context)) root = self.etree.XML( '<values xmlns="http://xpath.test/ns"><b min="19">30</b></values>') context = XPathContext(root, namespaces={'': "http://xpath.test/ns"}) self.assertIsNone(token.evaluate(context)) root = self.etree.XML( '<values xmlns="http://xpath.test/ns"><b min="19" max="40">30</b></values>' ) context = XPathContext(root, namespaces={'': "http://xpath.test/ns"}) self.assertTrue(token.evaluate(context)) root = self.etree.XML( '<values xmlns="http://xpath.test/ns"><b min="19" max="10">30</b></values>' ) context = XPathContext(root, namespaces={'': "http://xpath.test/ns"}) self.assertFalse(token.evaluate(context)) def test_issue_10(self): schema = xmlschema.XMLSchema(''' <xs:schema xmlns="http://xpath.test/ns#" xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://xpath.test/ns#"> <xs:element name="root" type="rootType" /> <xs:simpleType name="rootType"> <xs:restriction base="xs:string"/> </xs:simpleType> </xs:schema>''') # TODO: test fail with xmlschema-1.0.17+, added namespaces as temporary fix for test. # A fix for xmlschema.xpath.ElementPathMixin._get_xpath_namespaces() is required. root = schema.find('root', namespaces={'': 'http://xpath.test/ns#'}) self.assertEqual(getattr(root, 'tag', None), '{http://xpath.test/ns#}root')