def test_set_namespace_map(self): schema = Schema() ns_map = {} self.parser.set_namespace_map(schema, ns_map) expected = { "xlink": "http://www.w3.org/1999/xlink", "xml": "http://www.w3.org/XML/1998/namespace", "xs": "http://www.w3.org/2001/XMLSchema", "xsi": "http://www.w3.org/2001/XMLSchema-instance", } self.assertEqual(expected, schema.ns_map) self.parser.set_namespace_map(schema, None) self.assertEqual(expected, schema.ns_map) ns_map = {"foo": "bar", "not": "http://www.w3.org/2001/XMLSchema"} schema = Schema() expected = { "foo": "bar", "xlink": "http://www.w3.org/1999/xlink", "xml": "http://www.w3.org/XML/1998/namespace", "not": "http://www.w3.org/2001/XMLSchema", "xsi": "http://www.w3.org/2001/XMLSchema-instance", } self.parser.set_namespace_map(schema, ns_map) self.assertEqual(expected, schema.ns_map) foo = [] self.parser.set_namespace_map(foo, ns_map) self.assertFalse(hasattr(foo, "ns_map"))
def test_set_namespace_map(self): schema = Schema() element = etree.Element("schema") self.parser.set_namespace_map(element, schema) expected = { "xlink": "http://www.w3.org/1999/xlink", "xml": "http://www.w3.org/XML/1998/namespace", "xs": "http://www.w3.org/2001/XMLSchema", "xsi": "http://www.w3.org/2001/XMLSchema-instance", } self.assertEqual(expected, schema.ns_map) element = etree.Element("schema", nsmap={ "foo": "bar", "not": "http://www.w3.org/2001/XMLSchema" }) schema = Schema() expected = { "foo": "bar", "xlink": "http://www.w3.org/1999/xlink", "xml": "http://www.w3.org/XML/1998/namespace", "not": "http://www.w3.org/2001/XMLSchema", "xsi": "http://www.w3.org/2001/XMLSchema-instance", } self.parser.set_namespace_map(element, schema) self.assertEqual(expected, schema.ns_map)
def test_add_default_imports(self): schema = Schema() schema.imports.append(Import(namespace="foo")) self.parser.add_default_imports(schema) self.assertEqual(1, len(schema.imports)) xsi = Namespace.XSI.uri schema.ns_map["foo"] = xsi self.parser.add_default_imports(schema) self.assertEqual(2, len(schema.imports)) self.assertEqual(Import(namespace=xsi), schema.imports[0])
def test_set_schema_namespaces(self): schema = Schema() self.parser.set_schema_namespaces(schema) self.assertIsNone(schema.target_namespace) self.parser.target_namespace = "bar" self.parser.set_schema_namespaces(schema) self.assertEqual("bar", schema.target_namespace) schema.target_namespace = "foo" self.parser.set_schema_namespaces(schema) self.assertEqual("foo", schema.target_namespace)
def test_end_schema( self, mock_set_schema_forms, mock_set_schema_namespaces, mock_add_default_imports, mock_resolve_schemas_locations, ): schema = Schema() schema.elements.append(Element()) schema.elements.append(Element()) schema.elements.append(Element()) for el in schema.elements: self.assertEqual(1, el.min_occurs) self.assertEqual(1, el.max_occurs) self.parser.end_schema(schema) for el in schema.elements: self.assertIsNone(el.min_occurs) self.assertIsNone(el.max_occurs) self.parser.end_schema(ComplexType()) mock_set_schema_forms.assert_called_once_with(schema) mock_set_schema_namespaces.assert_called_once_with(schema) mock_add_default_imports.assert_called_once_with(schema) mock_resolve_schemas_locations.assert_called_once_with(schema)
def test_merge(self): target = Definitions() source = Definitions() source.types = Types() source.messages.append(Message()) source.port_types.append(PortType()) source.bindings.append(Binding()) source.services.append(Service()) source.extended.append(AnyElement()) source_two = copy.deepcopy(source) source_two.types.schemas.append(Schema()) target.merge(source) self.assertEqual(source.types, target.types) self.assertEqual(0, len(target.types.schemas)) self.assertEqual(1, len(target.messages)) self.assertEqual(1, len(target.port_types)) self.assertEqual(1, len(target.bindings)) self.assertEqual(1, len(target.services)) self.assertEqual(1, len(target.extended)) target.merge(source_two) target.merge(Definitions()) self.assertEqual(1, len(target.types.schemas)) self.assertEqual(2, len(target.messages)) self.assertEqual(2, len(target.port_types)) self.assertEqual(2, len(target.bindings)) self.assertEqual(2, len(target.services)) self.assertEqual(2, len(target.extended))
def test_root_elements(self): override = Override() redefine = Redefine() redefine.annotation = Annotation() redefine.complex_types.append(ComplexType()) override.annotation = Annotation() override.groups.append(Group()) override.simple_types.append(SimpleType()) schema = Schema() schema.simple_types.append(SimpleType()) schema.attribute_groups.append(AttributeGroup()) schema.groups.append(Group()) schema.attributes.append(Attribute()) schema.complex_types.append(ComplexType()) schema.elements.append(Element()) schema.redefines.append(redefine) schema.overrides.append(override) iterator = SchemaMapper.root_elements(schema) expected = [ ("Override", override.simple_types[0]), ("Override", override.groups[0]), ("Redefine", redefine.complex_types[0]), ("Schema", schema.simple_types[0]), ("Schema", schema.complex_types[0]), ("Schema", schema.groups[0]), ("Schema", schema.attribute_groups[0]), ("Schema", schema.elements[0]), ("Schema", schema.attributes[0]), ] self.assertEqual(expected, list(iterator))
def test_module(self): schema = Schema(location="foo/bar.xsd", target_namespace="http://xsdata/foo") self.assertEqual("bar", schema.module) schema.location = "foo/bar.noext" self.assertEqual("bar.noext", schema.module) schema.location = None self.assertEqual("foo", schema.module) schema.target_namespace = None with self.assertRaises(SchemaValueError) as cm: schema.module self.assertEqual("Unknown schema module.", str(cm.exception))
def set_schema_forms(self, obj: xsd.Schema): """ Set the default form type for elements and attributes. Global elements and attributes are by default qualified. """ if self.element_form: obj.element_form_default = FormType(self.element_form) if self.attribute_form: obj.attribute_form_default = FormType(self.attribute_form) for child_element in obj.elements: child_element.form = FormType.QUALIFIED for child_attribute in obj.attributes: child_attribute.form = FormType.QUALIFIED
def convert_schema(self, schema: Schema): """Convert a schema instance to codegen classes and process imports to other schemas.""" for sub in schema.included(): if sub.location: self.process_schema(sub.location, schema.target_namespace) assert schema.location is not None self.class_map[schema.location] = self.generate_classes(schema)
def test_set_schema_namespaces(self, mock_set_namespace_map): schema = Schema() element = etree.Element("schema") self.parser.set_schema_namespaces(schema, element) self.assertIsNone(schema.target_namespace) self.parser.target_namespace = "bar" self.parser.set_schema_namespaces(schema, element) self.assertEqual("bar", schema.target_namespace) schema.target_namespace = "foo" self.parser.set_schema_namespaces(schema, element) self.assertEqual("foo", schema.target_namespace) mock_set_namespace_map.assert_has_calls([ mock.call(element, schema), mock.call(element, schema), mock.call(element, schema), ])
def test_process_definitions( self, mock_parse_definitions, mock_convert_definitions, mock_convert_schema, mock_process_classes, ): uri = "http://xsdata/services.xsd" definitions = Definitions(types=Types(schemas=[Schema(), Schema()])) mock_parse_definitions.return_value = definitions self.transformer.process_definitions(uri) mock_convert_schema.assert_has_calls( [mock.call(x) for x in definitions.schemas] ) mock_parse_definitions.assert_called_once_with(uri, namespace=None) mock_convert_definitions.assert_called_once_with(definitions) mock_process_classes.assert_called_once_with()
def test_sub_schemas(self): imports = [ Import(schema_location="../foo.xsd"), Import(schema_location="../bar.xsd"), ] includes = [ Include(schema_location="common.xsd"), Include(schema_location="uncommon.xsd"), ] redefines = [ Redefine(schema_location="a.xsd"), Redefine(schema_location="b.xsd"), ] overrides = [ Override(schema_location="a.xsd"), Override(schema_location="b.xsd"), ] schema = Schema(imports=imports, includes=includes, redefines=redefines, overrides=overrides) actual = schema.included() expected = imports + includes + redefines + overrides self.assertIsInstance(actual, Iterator) self.assertEqual(expected, list(actual)) schema = Schema() self.assertEqual([], list(schema.included()))
def test_resolve_schemas_locations( self, mock_resolve_path, mock_resolve_local_path ): schema = Schema() self.parser.resolve_schemas_locations(schema) self.parser.location = Path.cwd() mock_resolve_path.side_effect = lambda x: Path.cwd().joinpath(x) mock_resolve_local_path.side_effect = lambda x, y: Path.cwd().joinpath(x) schema.overrides.append(Override(schema_location="o1")) schema.overrides.append(Override(schema_location="o2")) schema.redefines.append(Redefine(schema_location="r1")) schema.redefines.append(Redefine(schema_location="r2")) schema.includes.append(Include(schema_location="i1")) schema.includes.append(Include(schema_location="i2")) schema.imports.append(Import(schema_location="i3", namespace="ns_i3")) schema.imports.append(Import(schema_location="i4", namespace="ns_i4")) self.parser.resolve_schemas_locations(schema) mock_resolve_path.assert_has_calls( [ mock.call("o1"), mock.call("o2"), mock.call("r1"), mock.call("r2"), mock.call("i1"), mock.call("i2"), ] ) mock_resolve_local_path.assert_has_calls( [mock.call("i3", "ns_i3"), mock.call("i4", "ns_i4")] ) for sub in schema.included(): self.assertEqual(Path.cwd().joinpath(sub.location), sub.location)
def test_property_schemas(self): obj = Definitions() self.assertIsInstance(obj.schemas, Generator) self.assertEqual([], list(obj.schemas)) obj.types = Types() self.assertEqual([], list(obj.schemas)) schemas = [Schema(), Schema] obj.types.schemas.extend(schemas) self.assertEqual(schemas, list(obj.schemas))
def test_process_schema( self, mock_parse_schema, mock_convert_schema, ): schema = Schema() mock_parse_schema.return_value = schema uri = "http://xsdata/services.xsd" namespace = "fooNS" self.transformer.process_schema(uri, namespace) mock_convert_schema.assert_called_once_with(schema)
def test_process_schema( self, mock_parse_schema, mock_generate_classes, mock_logger_info, ): schema = Schema(target_namespace="thug") schema.includes.append(Include(location="foo")) schema.overrides.append(Override()) schema.imports.append(Import(location="bar")) schema.imports.append(Import(location="fails")) schema_foo = Schema() schema_bar = Schema() mock_generate_classes.side_effect = [ ClassFactory.list(1), ClassFactory.list(2), ClassFactory.list(3), ] mock_parse_schema.side_effect = [schema, schema_bar, None, schema_foo] self.transformer.process_schema("main", "foo-bar") self.assertEqual(["main", "bar", "fails", "foo"], self.transformer.processed) self.assertEqual(3, len(self.transformer.class_map)) self.assertEqual(3, len(self.transformer.class_map["main"])) self.assertEqual(2, len(self.transformer.class_map["foo"])) self.assertEqual(1, len(self.transformer.class_map["bar"])) mock_logger_info.assert_has_calls([ mock.call("Parsing schema %s", "main"), mock.call("Parsing schema %s", "bar"), mock.call("Parsing schema %s", "fails"), mock.call("Parsing schema %s", "foo"), ])
def test_generate_classes(self, mock_mapper_map, mock_count_classes, mock_logger_info): schema = Schema(location="edo.xsd") classes = ClassFactory.list(2) mock_mapper_map.return_value = classes mock_count_classes.return_value = 2, 4 self.transformer.generate_classes(schema) mock_mapper_map.assert_called_once_with(schema) mock_logger_info.assert_has_calls([ mock.call("Compiling schema %s", schema.location), mock.call("Builder: %d main and %d inner classes", 2, 4), ])
def test_process_definitions( self, mock_parse_definitions, mock_convert_definitions, mock_convert_schema, ): uris = [ "http://xsdata/services.wsdl", "http://xsdata/abstractServices.wsdl", "http://xsdata/notfound.wsdl", ] fist_def = Definitions(types=Types(schemas=[Schema(), Schema()])) second_def = Definitions(bindings=[Binding()]) mock_parse_definitions.side_effect = [fist_def, second_def, None] self.transformer.process_definitions(uris) mock_convert_schema.assert_has_calls( [mock.call(x) for x in fist_def.schemas]) mock_parse_definitions.assert_has_calls([ mock.call(uris[0], namespace=None), mock.call(uris[1], namespace=None) ]) mock_convert_definitions.assert_called_once_with(fist_def)
def root_elements(cls, schema: Schema): """Return all valid schema elements that can be converted to classes.""" for override in schema.overrides: for child in override.children(condition=cls.is_class): yield Tag.OVERRIDE, child for redefine in schema.redefines: for child in redefine.children(condition=cls.is_class): yield Tag.REDEFINE, child for child in schema.children(condition=cls.is_class): yield Tag.SCHEMA, child
def test_end_schema( self, mock_set_schema_forms, mock_set_schema_namespaces, mock_add_default_imports, mock_resolve_schemas_locations, ): schema = Schema() element = Element("schema") self.parser.end_schema(schema, element) mock_set_schema_forms.assert_called_once_with(schema) mock_set_schema_namespaces.assert_called_once_with(schema, element) mock_add_default_imports.assert_called_once_with(schema) mock_resolve_schemas_locations.assert_called_once_with(schema)
def test_set_schema_forms_default(self): schema = Schema() schema.elements.append(Element()) schema.elements.append(Element()) schema.attributes.append(Element()) schema.attributes.append(Element()) self.parser.set_schema_forms(schema) self.assertEqual(FormType.UNQUALIFIED, schema.element_form_default) self.assertEqual(FormType.UNQUALIFIED, schema.attribute_form_default) for child_element in schema.elements: self.assertEqual(FormType.QUALIFIED, child_element.form) for child_attribute in schema.attributes: self.assertEqual(FormType.QUALIFIED, child_attribute.form)
def test_map(self, mock_root_elements, mock_build_class): simple_type = ComplexType() complex_type = ComplexType() schema = Schema(target_namespace="fooNS", location="foo.xsd") mock_build_class.side_effect = ClassFactory.list(3) mock_root_elements.return_value = [ (Tag.SCHEMA, Group), (Tag.OVERRIDE, simple_type), (Tag.REDEFINE, complex_type), ] actual = SchemaMapper.map(schema) self.assertEqual(3, len(actual)) self.assertIsInstance(actual[0], Class) mock_root_elements.assert_called_once_with(schema)
def test_wget_included(self, mock_wget): schema = Schema( imports=[ Import(location="foo.xsd"), Import(), Import(location="foo.xsd", schema_location="../foo.xsd"), ] ) self.downloader.wget_included(schema) mock_wget.assert_has_calls( [ mock.call(schema.imports[0].location, None), mock.call( schema.imports[2].location, schema.imports[2].schema_location ), ] )
def test_convert_schema(self, mock_process_schema, mock_generate_classes): schema = Schema(target_namespace="thug", location="main") schema.includes.append(Include(location="foo")) schema.overrides.append(Override()) schema.imports.append(Import(location="bar")) schema.imports.append(Import(location="fails")) mock_generate_classes.return_value = ClassFactory.list(2) self.transformer.convert_schema(schema) self.assertEqual(1, len(self.transformer.class_map)) self.assertEqual(2, len(self.transformer.class_map["main"])) mock_process_schema.assert_has_calls([ mock.call("bar", "thug"), mock.call("fails", "thug"), mock.call("foo", "thug"), ])
def resolve_schemas_locations(self, obj: xsd.Schema): """Resolve the locations of the schema overrides, redefines, includes and imports relatively to the schema location.""" if not self.location: return obj.location = self.location for over in obj.overrides: over.location = self.resolve_path(over.schema_location) for red in obj.redefines: red.location = self.resolve_path(red.schema_location) for inc in obj.includes: inc.location = self.resolve_path(inc.schema_location) for imp in obj.imports: imp.location = self.resolve_local_path(imp.schema_location, imp.namespace)
def test_process_schema( self, mock_parse_schema, mock_convert_schema, mock_logger_info, mock_logger_debug, ): schema = Schema() mock_parse_schema.return_value = schema uri = "http://xsdata/services.xsd" namespace = "fooNS" self.transformer.process_schema(uri, namespace) self.transformer.process_schema(uri, namespace) self.assertEqual([uri], self.transformer.processed) mock_convert_schema.assert_called_once_with(schema) mock_logger_info.assert_called_once_with("Parsing schema %s", "services.xsd") mock_logger_debug.assert_called_once_with( "Skipping already processed: %s", "services.xsd" )
def set_schema_namespaces(self, obj: xsd.Schema): """Set the given schema's target namespace and add the default namespaces if the are missing xsi, xlink, xml, xs.""" obj.target_namespace = obj.target_namespace or self.target_namespace
def test_meta(self): schema = Schema() self.assertEqual("schema", schema.Meta.name) self.assertEqual(Namespace.XS.uri, schema.Meta.namespace)
def setUp(self): super().setUp() self.schema = Schema(location="file://foo.xsd") self.builder = ClassBuilder(schema=self.schema)