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_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_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 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_parse_definitions(
self,
mock_load_resource,
mock_definitions_parser,
mock_definitions_merge,
mock_process_schema,
):
def_one = Definitions(imports=[
Import(),
Import(location="file://sub.wsdl"),
Import(location="file://sub.wsdl"),
Import(location="file://types.xsd"),
])
def_two = Definitions()
mock_load_resource.side_effect = ["a", "b", None]
mock_definitions_parser.side_effect = [def_one, def_two]
actual = self.transformer.parse_definitions("main.wsdl", "fooNS")
self.assertEqual(def_one, actual)
mock_definitions_merge.assert_called_once_with(def_two)
mock_process_schema.assert_called_once_with("file://types.xsd")
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"),
])