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)