def test_process_classes_with_print_false(
self,
mock_assign_packages,
mock_analyze_classes,
mock_writer_write,
mock_logger_into,
):
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_classes()
mock_assign_packages.assert_called_once_with()
mock_analyze_classes.assert_called_once_with(schema_classes)
mock_writer_write.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_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(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_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_process(self, mock_process_class, mock_resolve_conflicts):
classes = ClassFactory.list(2)
self.container.extend(classes)
self.sanitizer.process()
mock_process_class.assert_has_calls(list(map(mock.call, classes)))
mock_resolve_conflicts.assert_called_once_with()
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_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_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_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))
actual = mock_process.call_args[0][0]
self.assertIsInstance(actual, ClassContainer)
self.assertEqual(2, len(actual.data))
self.assertEqual(self.transformer.config, actual.config)
def test_print(self, mock_print, mock_designate, mock_render):
classes = ClassFactory.list(2)
mock_render.return_value = [
GeneratorResult(Path("foo/a.py"), "file", "aAa"),
GeneratorResult(Path("bar/b.py"), "file", "bBb"),
GeneratorResult(Path("c.py"), "file", ""),
]
self.writer.print(classes)
mock_designate.assert_called_once_with(classes)
mock_print.assert_has_calls(
[mock.call("aAa", end=""),
mock.call("bBb", end="")])
def test_map(self, mock_build_class, mock_flatten):
element = AnyElement(qname="{xsdata}root")
root_class = ClassFactory.create()
flat_classes = ClassFactory.list(5)
iter_flat_classes = iter(flat_classes)
mock_build_class.return_value = root_class
mock_flatten.return_value = iter_flat_classes
actual = ElementMapper.map(element)
self.assertEqual(flat_classes, actual)
mock_build_class.assert_called_once_with(element, "xsdata")
mock_flatten.assert_called_once_with(root_class, "root")
def test_process_json_documents(self, mock_load_resource, mock_map,
mock_reduce):
uris = ["foo/a.json", "foo/b.json", "foo/c.json"]
resources = [b'{"foo": 1}', None, b'{"foo": true}']
classes_a = ClassFactory.list(2)
classes_c = ClassFactory.list(3)
mock_load_resource.side_effect = resources
mock_map.side_effect = [classes_a, classes_c]
mock_reduce.return_value = classes_a + classes_c
self.transformer.config.output.package = "some.books"
self.transformer.process_json_documents(uris)
self.assertIn("foo", self.transformer.class_map)
self.assertEqual(5, len(self.transformer.class_map["foo"]))
mock_map.assert_has_calls([
mock.call({"foo": 1}, "books"),
mock.call({"foo": True}, "books"),
])
mock_reduce.assert_called_once_with(classes_a + classes_c)
def test_map(self, mock_build_class, mock_flatten):
data = {"value": 1}
root_class = ClassFactory.create()
flat_classes = ClassFactory.list(5)
iter_flat_classes = iter(flat_classes)
mock_build_class.return_value = root_class
mock_flatten.return_value = iter_flat_classes
actual = DictMapper.map(data, "root")
self.assertEqual(flat_classes, actual)
mock_build_class.assert_called_once_with(data, "root")
mock_flatten.assert_called_once_with(root_class, "root")
def test_write(self, mock_designate, mock_render):
classes = ClassFactory.list(2)
with TemporaryDirectory() as tmpdir:
mock_render.return_value = [
GeneratorResult(Path(f"{tmpdir}/foo/a.py"), "file", "aAa"),
GeneratorResult(Path(f"{tmpdir}/bar/b.py"), "file", "bBb"),
GeneratorResult(Path(f"{tmpdir}/c.py"), "file", " "),
]
self.writer.write(classes)
self.assertEqual("aAa", Path(f"{tmpdir}/foo/a.py").read_text())
self.assertEqual("bBb", Path(f"{tmpdir}/bar/b.py").read_text())
self.assertFalse(Path(f"{tmpdir}/c.py").exists())
mock_designate.assert_called_once_with(classes)
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_xml_documents(self, mock_load_resource, mock_from_bytes,
mock_map, mock_reduce):
uris = ["foo/a.xml", "foo/b.xml", "foo/c.xml"]
resources = [b"a", None, b"c"]
elements = [AnyElement(), AnyElement()]
classes_a = ClassFactory.list(2)
classes_c = ClassFactory.list(3)
mock_load_resource.side_effect = resources
mock_from_bytes.side_effect = elements
mock_map.side_effect = [classes_a, classes_c]
mock_reduce.return_value = classes_a + classes_c
self.transformer.process_xml_documents(uris)
self.assertIn("foo", self.transformer.class_map)
self.assertEqual(5, len(self.transformer.class_map["foo"]))
mock_from_bytes.assert_has_calls(
[mock.call(resources[0]),
mock.call(resources[2])])
mock_map.assert_has_calls([mock.call(x) for x in elements])
mock_reduce.assert_called_once_with(classes_a + classes_c)
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()
container.extend(classes)
expected = [
classes[0],
classes[3],
]
container.filter_classes()
self.assertEqual(expected, container.class_list)
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_class_references(self):
target = ClassFactory.elements(
2,
inner=ClassFactory.list(2, attrs=AttrFactory.list(1)),
extensions=ExtensionFactory.list(1),
)
actual = ClassAnalyzer.class_references(target)
# +1 target
# +2 attrs
# +2 attr types
# +1 extension
# +1 extension type
# +2 inner classes
# +2 inner classes attrs
# +2 inner classes attr types
self.assertEqual(13, len(actual))
self.assertEqual(id(target), actual[0])
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_create_class_list(self, mock_dependencies):
classes = ClassFactory.list(3)
mock_dependencies.side_effect = [
{build_qname("xsdata", "class_C"), "b"},
{"c", "d"},
{"e", "d"},
]
actual = self.resolver.create_class_list(classes)
expected = [
"b",
"c",
"d",
"e",
"{xsdata}class_C",
"{xsdata}class_D",
"{xsdata}class_B",
]
self.assertEqual(expected, list(map(str, actual)))
def test_process(self, mock_create_class_map, create_class_list,
mock_resolve_imports):
classes = ClassFactory.list(3)
mock_create_class_map.return_value = {"b": classes[0]}
create_class_list.return_value = classes[::-1]
self.resolver.imports.append(
PackageFactory.create(name="foo", source="bar"))
self.resolver.aliases = {"a": "a"}
self.resolver.process(classes)
self.assertEqual([], self.resolver.imports)
self.assertEqual({}, self.resolver.aliases)
self.assertEqual(mock_create_class_map.return_value,
self.resolver.class_map)
self.assertEqual(create_class_list.return_value,
self.resolver.class_list)
mock_resolve_imports.assert_called_once_with()
def test_process(
self,
mock_validator_process,
mock_container_process,
mock_container_filter_classes,
mock_sanitizer_process,
mock_validate_references,
):
config = GeneratorConfig()
classes = ClassFactory.list(2)
container = ClassContainer(config=config)
container.extend(classes)
result = ClassAnalyzer.process(container)
self.assertEqual(classes, result)
mock_validator_process.assert_called_once_with()
mock_container_process.assert_called_once_with()
mock_container_filter_classes.assert_called_once_with()
mock_sanitizer_process.assert_called_once_with()
mock_validate_references.assert_called_once_with(classes)
def test_flatten(self):
target = ClassFactory.create(
qname="{xsdata}root", attrs=AttrFactory.list(3), inner=ClassFactory.list(2)
)
for attr in target.attrs:
attr.types.extend([x.clone() for x in attr.types])
for tp in attr.types:
tp.forward = True
result = ClassUtils.flatten(target, "xsdata")
actual = list(result)
self.assertIsInstance(result, Generator)
self.assertEqual(3, len(actual))
for obj in actual:
self.assertEqual("xsdata", obj.module)
for attr in target.attrs:
self.assertEqual(1, len(attr.types))
self.assertFalse(attr.types[0].forward)
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_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_count_classes(self):
classes = ClassFactory.list(2,
inner=ClassFactory.list(
2, inner=ClassFactory.list(3)))
self.assertEqual((2, 16), self.transformer.count_classes(classes))
def test_create_class_map_for_duplicate_classes(self):
classes = ClassFactory.list(2, qname="a")
with self.assertRaises(ResolverValueError) as cm:
self.resolver.create_class_map(classes)
self.assertEqual("Duplicate class: `a`", str(cm.exception))
