def test_process_schema(
self,
mock_parse_schema,
mock_process_included,
mock_generate_classes,
mock_logger_info,
):
include = Include.create()
override = Override.create()
schema = Schema.create(target_namespace="thug")
schema.includes.append(include)
schema.overrides.append(override)
mock_process_included.side_effect = [
ClassFactory.list(2), ClassFactory.list(3)
]
mock_generate_classes.return_value = ClassFactory.list(4)
mock_parse_schema.return_value = schema
path = Path(__file__)
result = self.transformer.process_schema(path,
package="foo.bar",
target_namespace="foo-bar")
self.assertEqual(9, len(result))
self.assertTrue(path in self.transformer.processed)
mock_parse_schema.assert_called_once_with(path, "foo-bar")
mock_process_included.assert_has_calls([
mock.call(include, "foo.bar", schema.target_namespace),
mock.call(override, "foo.bar", schema.target_namespace),
])
self.transformer.process_schema(path, None, None)
mock_logger_info.assert_called_once_with("Parsing schema...")
def test_process_with_print_false(
self,
mock_process_schema,
mock_assign_packages,
mock_analyze_classes,
mock_writer_designate,
mock_writer_write,
mock_logger_into,
):
urls = ["http://xsdata/foo.xsd", "http://xsdata/bar.xsd"]
package = "test"
schema_classes = ClassFactory.list(3)
analyzer_classes = ClassFactory.list(2)
mock_analyze_classes.return_value = analyzer_classes
self.transformer.print = False
self.transformer.class_map = {
"http://xsdata/foo.xsd": schema_classes[:1],
"http://xsdata/bar.xsd": schema_classes[1:],
}
self.transformer.process(urls, package)
mock_process_schema.assert_has_calls(list(map(mock.call, urls)))
mock_assign_packages.assert_called_once_with(package)
mock_analyze_classes.assert_called_once_with(schema_classes)
mock_writer_designate.assert_called_once_with(analyzer_classes, "pydata")
mock_writer_write.assert_called_once_with(analyzer_classes, "pydata")
mock_logger_into.assert_has_calls(
[
mock.call("Analyzer input: %d main and %d inner classes", 3, 0),
mock.call("Analyzer output: %d main and %d inner classes", 2, 0),
]
)
def test_process_with_print_false(
self,
mock_process_schemas,
mock_analyze_classes,
mock_count_classes,
mock_writer_designate,
mock_writer_write,
mock_logger_into,
):
path = Path(__file__)
package = "test"
schema_classes = ClassFactory.list(2)
analyzer_classes = ClassFactory.list(2)
mock_count_classes.return_value = 1, 2
mock_process_schemas.return_value = schema_classes
mock_analyze_classes.return_value = analyzer_classes
self.transformer.print = False
self.transformer.process(path, package)
mock_process_schemas.assert_called_once_with(path, package)
mock_analyze_classes.assert_called_once_with(schema_classes)
mock_count_classes.assert_called_once_with(analyzer_classes)
mock_writer_designate.assert_called_once_with(analyzer_classes,
"pydata")
mock_writer_write.assert_called_once_with(analyzer_classes, "pydata")
mock_logger_into.assert_called_once_with(
"Analyzer: %d main and %d inner classes", 1, 2)
def test_process_classes_with_print_true(
self,
mock_assign_packages,
mock_analyze_classes,
mock_writer_print,
mock_logger_into,
):
package = "test"
schema_classes = ClassFactory.list(3)
analyzer_classes = ClassFactory.list(2)
mock_analyze_classes.return_value = analyzer_classes
self.transformer.class_map = {
"http://xsdata/foo.xsd": schema_classes[:1],
"http://xsdata/bar.xsd": schema_classes[1:],
}
self.transformer.process_classes()
mock_assign_packages.assert_called_once_with()
mock_analyze_classes.assert_called_once_with(schema_classes)
mock_writer_print.assert_called_once_with(analyzer_classes)
mock_logger_into.assert_has_calls(
[
mock.call("Analyzer input: %d main and %d inner classes", 3, 0),
mock.call("Analyzer output: %d main and %d inner classes", 2, 0),
]
)
def test_render_classes(self, mock_process_class, mock_render_class):
renders = [" does it matter?", " white space "]
classes = ClassFactory.list(2)
mock_process_class.side_effect = ClassFactory.list(2)
mock_render_class.side_effect = renders
output = "\n".join(renders).strip()
actual = DataclassGenerator().render_classes(classes)
self.assertEqual(f"\n\n{output}\n", actual)
def test_map_binding(
self, mock_attributes, mock_find_operation, mock_map_binding_operation
):
definitions = Definitions()
port_type = PortType(name="Calc")
binding = Binding(
type="zaa:zoo",
operations=[BindingOperation(name="ADD"), BindingOperation(name="SUB")],
)
port_type_add = PortTypeOperation(name="PortAdd")
port_type_sub = PortTypeOperation(name="PortSub")
classes = [
ClassFactory.list(2),
ClassFactory.list(2),
]
mock_map_binding_operation.side_effect = classes
mock_find_operation.side_effect = [port_type_add, port_type_sub]
mock_attributes.side_effect = [
{"soapAction": "add"},
{"soapAction": "sub"},
]
config = {"foo": "bar"}
result = DefinitionsMapper.map_binding(definitions, binding, port_type, config)
self.assertIsInstance(result, Generator)
self.assertEqual(classes[0] + classes[1], list(result))
mock_find_operation.assert_has_calls([mock.call("ADD"), mock.call("SUB")])
self.assertEqual(2, mock_attributes.call_count)
config_add = {"soapAction": "add", **config}
config_sub = {"soapAction": "sub", **config}
mock_map_binding_operation.assert_has_calls(
[
mock.call(
definitions,
binding.operations[0],
port_type_add,
config_add,
"Calc",
),
mock.call(
definitions,
binding.operations[1],
port_type_sub,
config_sub,
"Calc",
),
]
)
def test_map_port(
self, mock_find_binding, mock_find_port_type, mock_attributes, mock_map_binding
):
definitions = Definitions()
service_port = ServicePort(binding="zaa:port", extended=[AnyElement()])
port_type = PortType(name="Calc")
binding = Binding(
type="zaa:zoo",
extended=[AnyElement()],
operations=[BindingOperation(name="ADD"), BindingOperation(name="SUB")],
)
classes = ClassFactory.list(2)
cfg = {
"style": "document",
"location": "http://endpoint.stub/action",
"transport": "public",
}
mock_find_binding.return_value = binding
mock_find_port_type.return_value = port_type
mock_map_binding.return_value = classes
mock_attributes.return_value = cfg
result = DefinitionsMapper.map_port(definitions, service_port)
self.assertIsInstance(result, Generator)
self.assertEqual(classes, list(result))
mock_find_binding.assert_called_once_with("port")
mock_find_port_type.assert_called_once_with("zoo")
self.assertEqual(2, len(list(mock_attributes.call_args[0][0])))
self.assertEqual(1, mock_attributes.call_count)
mock_map_binding.assert_called_once_with(definitions, binding, port_type, cfg)
def test_build_inner_classes(self, mock_build_class):
inner_classes = ClassFactory.list(2)
mock_build_class.side_effect = inner_classes
simple_type = SimpleType()
complex_type = ComplexType()
enumeration = SimpleType(restriction=Restriction(
enumerations=[Enumeration(value="a")]))
element = Element(alternatives=[
Alternative(complex_type=complex_type, id="a"),
Alternative(simple_type=simple_type, id="b"),
Alternative(simple_type=enumeration, id="c"),
])
result = SchemaMapper.build_inner_classes(element, "module",
"target_ns")
self.assertIsInstance(result, Iterator)
self.assertEqual(inner_classes, list(result))
self.assertEqual("a", complex_type.name)
self.assertEqual("c", enumeration.name)
mock_build_class.assert_has_calls([
mock.call(complex_type, Tag.ALTERNATIVE, "module", "target_ns"),
mock.call(enumeration, Tag.ALTERNATIVE, "module", "target_ns"),
])
def test_copy_inner_classes(self):
source = ClassFactory.create(
inner=ClassFactory.list(2, package="a", module="b"))
target = ClassFactory.create()
ClassUtils.copy_inner_classes(source, target) # All good copy all
self.assertEqual(2, len(target.inner))
ClassUtils.copy_inner_classes(source,
target) # Inner classes exist skip
self.assertEqual(2, len(target.inner))
source.inner.append(target)
attr = AttrFactory.create(types=[
AttrTypeFactory.create(name=target.name, forward=True),
AttrTypeFactory.create(name=target.name, forward=False),
AttrTypeFactory.create(name="foobar"),
])
target.attrs.append(attr)
ClassUtils.copy_inner_classes(source,
target) # Inner class matches target
self.assertEqual(2, len(target.inner))
for inner in target.inner:
self.assertEqual(target.package, inner.package)
self.assertEqual(target.module, inner.module)
self.assertTrue(attr.types[0].circular)
self.assertFalse(attr.types[1].circular)
self.assertFalse(attr.types[2].circular)
def test_process(self, mock_process_class):
classes = ClassFactory.list(2)
self.sanitizer.container.extend(classes)
ClassSanitizer.process(self.container)
mock_process_class.assert_has_calls(list(map(mock.call, classes)))
def test_print(self, mock_print):
classes = ClassFactory.list(2)
writer.register_format(self.FAKE_NAME, FakeGenerator())
writer.print(classes, "fake")
mock_print.assert_has_calls(
[mock.call(obj.name, end="") for obj in classes])
def test_build_inner_classes(self, mock_build_class):
inner_classes = ClassFactory.list(2)
mock_build_class.side_effect = inner_classes
simple_type = SimpleType.create()
complex_type = ComplexType.create()
enumeration = SimpleType.create(
restriction=Restriction.create(enumerations=[Enumeration.create(value="a")])
)
element = Element.create(
alternatives=[
Alternative.create(complex_type=complex_type, id="a"),
Alternative.create(simple_type=simple_type, id="b"),
Alternative.create(simple_type=enumeration, id="c"),
]
)
result = self.builder.build_inner_classes(element)
self.assertIsInstance(result, Iterator)
self.assertEqual(inner_classes, list(result))
self.assertEqual("a", complex_type.name)
self.assertEqual("c", enumeration.name)
mock_build_class.assert_has_calls(
[mock.call(complex_type), mock.call(enumeration)]
)
def test_analyze_classes(self, mock_process):
classes = ClassFactory.list(2)
mock_process.return_value = classes[1:]
result = self.transformer.analyze_classes(classes)
self.assertEqual(1, len(result))
mock_process.assert_called_once_with(classes, self.transformer.config)
def test_render(
self, mock_render_module, mock_render_package,
):
classes = ClassFactory.list(3)
mock_render_module.return_value = "module"
mock_render_package.return_value = "package"
iterator = DataclassGenerator().render(classes)
actual = [out for out in iterator]
self.assertEqual(2, len(actual))
self.assertEqual(3, len(actual[0]))
self.assertEqual("init", actual[0][1])
self.assertEqual("foo/__init__.py", str(actual[0][0].relative_to(Path.cwd())))
self.assertEqual(mock_render_package.return_value, actual[0][2])
mock_render_package.assert_called_once_with(classes)
self.assertEqual(3, len(actual[1]))
self.assertIsInstance(actual[1][0], Path)
self.assertTrue(actual[1][0].is_absolute())
self.assertEqual("foo.tests", actual[1][1])
self.assertEqual("foo/tests.py", str(actual[1][0].relative_to(Path.cwd())))
self.assertEqual(mock_render_module.return_value, actual[1][2])
mock_render_module.assert_called_once_with(mock.ANY, classes)
def test_convert_definitions(self, mock_definitions_map):
classes = ClassFactory.list(2)
mock_definitions_map.return_value = classes
definitions = Definitions(location="foo")
self.transformer.convert_definitions(definitions)
self.assertEqual(classes, self.transformer.class_map[definitions.location])
def test_render(
self,
mock_prepare_imports,
mock_render_classes,
mock_render_module,
mock_resolver_process,
):
classes = ClassFactory.list(3)
mock_render_module.return_value = "module"
mock_prepare_imports.return_value = [
PackageFactory.create(name="foo", source="bar")
]
mock_render_classes.return_value = "classes"
iterator = DataclassGenerator().render(classes)
actual = [out for out in iterator]
self.assertEqual(1, len(actual))
self.assertEqual(3, len(actual[0]))
self.assertIsInstance(actual[0][0], Path)
self.assertTrue(actual[0][0].is_absolute())
self.assertEqual("foo.tests", actual[0][1])
self.assertEqual("foo/tests.py",
str(actual[0][0].relative_to(Path.cwd())))
self.assertEqual(mock_render_module.return_value, actual[0][2])
mock_resolver_process.assert_called_once_with(classes)
mock_prepare_imports.assert_called_once()
mock_prepare_imports.render_classes()
mock_render_module.assert_called_once_with(
imports=mock_prepare_imports.return_value,
output=mock_render_classes.return_value,
)
def test_process(self):
target = ClassFactory.create(inner=ClassFactory.list(2))
self.container.add(target)
self.container.process_class(target)
self.assertEqual(Status.PROCESSED, target.status)
self.assertEqual(Status.PROCESSED, target.inner[0].status)
self.assertEqual(Status.PROCESSED, target.inner[1].status)
def test_map(self, mock_map_port):
classes = [
ClassFactory.list(2),
ClassFactory.list(3),
]
mock_map_port.side_effect = classes
definitions = Definitions()
service = Service(ports=[ServicePort() for _ in range(2)])
definitions.services.append(service)
result = DefinitionsMapper.map(definitions)
self.assertEqual(classes[0] + classes[1], result)
mock_map_port.assert_has_calls(
[mock.call(definitions, port) for port in service.ports]
)
def test_process(self, mock_process_class, mock_resolve_conflicts):
classes = ClassFactory.list(2)
self.sanitizer.container.extend(classes)
ClassSanitizer.process(self.container, self.config)
mock_process_class.assert_has_calls(list(map(mock.call, classes)))
mock_resolve_conflicts.assert_called_once_with()
def test_assign_packages(self):
core = "file://HL7V3/NE2008/coreschemas/voc.xsd"
multi_one = "file://HL7V3/NE2008/multicacheschemas/PRPA_MT201307UV02.xsd"
multi_two = "file://HL7V3/NE2008/multicacheschemas/COCT_MT080000UV.xsd"
http_one = "http://xsdata/foo/bar/schema.xsd"
http_two = "http://xsdata/foo/common.xsd"
local_one = Namespace.XSI.location
local_two = Namespace.XLINK.location
class_map = {
core: ClassFactory.list(1, inner=[ClassFactory.create()]),
multi_one: ClassFactory.list(2),
multi_two: ClassFactory.list(1),
http_one: ClassFactory.list(1),
http_two: ClassFactory.list(1),
local_one: ClassFactory.list(1),
local_two: ClassFactory.list(1),
}
self.transformer.class_map = class_map
self.transformer.config.output.package = "foo.bar"
self.transformer.assign_packages()
self.assertEqual("foo.bar.coreschemas", class_map[core][0].package)
self.assertEqual("foo.bar.coreschemas", class_map[core][0].inner[0].package)
self.assertEqual("foo.bar.multicacheschemas", class_map[multi_one][0].package)
self.assertEqual("foo.bar.multicacheschemas", class_map[multi_one][1].package)
self.assertEqual("foo.bar.multicacheschemas", class_map[multi_two][0].package)
self.assertEqual("foo.bar.bar", class_map[http_one][0].package)
self.assertEqual("foo.bar", class_map[http_two][0].package)
self.assertEqual("foo.bar", class_map[local_one][0].package)
self.assertEqual("foo.bar", class_map[local_two][0].package)
def test_write(self):
classes = ClassFactory.list(2)
with TemporaryDirectory() as tmpdir:
writer.register_format(self.FAKE_NAME, FakeGenerator(tmpdir))
writer.write(classes, "fake")
for obj in classes:
self.assertEqual(obj.name,
Path(f"{tmpdir}/{obj.name}.txt").read_text())
def test_fetch_classes_for_generation_return_simple_when_no_complex_types(
self, mock_sanitize_attributes
):
classes = ClassFactory.list(2, type=SimpleType)
self.analyzer.create_class_index(classes)
actual = self.analyzer.fetch_classes_for_generation()
self.assertEqual(classes, actual)
mock_sanitize_attributes.assert_has_calls([mock.call(x) for x in classes])
def test_process(
self,
mock_create_class_index,
mock_handle_duplicates,
mock_create_substitutions_index,
mock_flatten_classes,
mock_fetch_classes_for_generation,
):
gen_classes = ClassFactory.list(2)
mock_fetch_classes_for_generation.return_value = gen_classes
classes = ClassFactory.list(3, type=Element)
self.assertEqual(gen_classes, self.analyzer.process(classes))
mock_create_class_index.assert_called_once_with(classes)
mock_handle_duplicates.assert_called_once()
mock_create_substitutions_index.assert_called_once_with()
mock_flatten_classes.assert_called_once_with()
mock_fetch_classes_for_generation.assert_called_once_with()
def test_select_winner(self):
classes = ClassFactory.list(2)
self.assertEqual(-1, self.validator.select_winner(classes))
classes[0].container = Tag.OVERRIDE
self.assertEqual(0, self.validator.select_winner(classes))
classes[0].container = Tag.SCHEMA
classes[1].container = Tag.REDEFINE
self.assertEqual(1, self.validator.select_winner(classes))
def test_designate_with_filename_structure(self):
classes = ClassFactory.list(3, package="foo", module="tests")
self.generator.designate(classes)
self.assertEqual("foo", classes[0].package)
self.assertEqual("foo", classes[1].package)
self.assertEqual("foo", classes[2].package)
self.assertEqual("tests", classes[0].module)
self.assertEqual("tests", classes[1].module)
self.assertEqual("tests", classes[2].module)
classes = ClassFactory.list(1, package=None)
with self.assertRaises(CodeGenerationError) as cm:
self.generator.designate(classes)
self.assertEqual("Class `class_E` has not been assign to a package.",
str(cm.exception))
def test_process(self, mock_pre_process, mock_process, mock_post_process,
mock_select_classes):
classes = ClassFactory.list(1)
mock_select_classes.return_value = classes
analyzer = ClassAnalyzer()
self.assertEqual(classes, analyzer.process())
mock_pre_process.assert_called_once_with()
mock_process.assert_called_once_with()
mock_post_process.assert_called_once_with()
mock_select_classes.assert_called_once_with()
def test_process(
self,
mock_validator_process,
mock_container_process,
mock_sanitizer_process,
mock_select_classes,
):
original_classes = ClassFactory.list(2)
container = ClassContainer.from_list(original_classes)
result_classes = ClassFactory.list(1)
mock_select_classes.return_value = result_classes
result = ClassAnalyzer.process(original_classes)
self.assertEqual(result_classes, result)
mock_validator_process.assert_called_once_with(container)
mock_container_process.assert_called_once_with()
mock_sanitizer_process.assert_called_once_with(container)
mock_select_classes.assert_called_once_with(container)
def test_build(
self, mock_build_class, mock_override_children, mock_redefine_children
):
for _ in range(2):
self.schema.simple_types.append(SimpleType.create())
self.schema.attribute_groups.append(AttributeGroup.create())
self.schema.groups.append(Group.create())
self.schema.attributes.append(Attribute.create())
self.schema.complex_types.append(ComplexType.create())
self.schema.elements.append(Element.create())
self.schema.redefines.append(Redefine.create())
self.schema.overrides.append(Override.create())
override_element = Element.create()
override_attribute = Attribute.create()
override_complex_type = ComplexType.create()
redefine_simple_type = SimpleType.create()
redefine_group = Group.create()
redefine_attribute_group = AttributeGroup.create()
mock_redefine_children.side_effect = [
[redefine_simple_type, redefine_group],
[redefine_attribute_group],
]
mock_override_children.side_effect = [
[override_element, override_attribute],
[override_complex_type],
]
mock_build_class.side_effect = classes = ClassFactory.list(18)
self.assertEqual(classes, self.builder.build())
mock_build_class.assert_has_calls(
[
mock.call(override_element),
mock.call(override_attribute),
mock.call(override_complex_type),
mock.call(redefine_simple_type),
mock.call(redefine_group),
mock.call(redefine_attribute_group),
mock.call(self.schema.simple_types[0]),
mock.call(self.schema.simple_types[1]),
mock.call(self.schema.attribute_groups[0]),
mock.call(self.schema.attribute_groups[1]),
mock.call(self.schema.groups[0]),
mock.call(self.schema.groups[1]),
mock.call(self.schema.attributes[0]),
mock.call(self.schema.attributes[1]),
mock.call(self.schema.complex_types[0]),
mock.call(self.schema.complex_types[1]),
mock.call(self.schema.elements[0]),
mock.call(self.schema.elements[1]),
]
)
def test_process_schemas(self, mock_process_schema):
classes = ClassFactory.list(5)
mock_process_schema.side_effect = [classes[:2], classes[2:]]
schemas = [Path(), Path()]
result = self.transformer.process_schemas(schemas, "foo")
self.assertEqual(classes, result)
mock_process_schema.assert_has_calls([
mock.call(schemas[0], "foo"),
mock.call(schemas[1], "foo"),
])
def test_filter_classes(self, mock_class_should_generate):
mock_class_should_generate.side_effect = [True, False, False, True, False]
classes = ClassFactory.list(5)
container = ClassContainer.from_list(classes)
expected = [
classes[0],
classes[3],
]
container.filter_classes()
self.assertEqual(expected, container.class_list)
