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