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 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_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)