def test_module_name(self):
self.assertEqual("foo_bar", DataclassGenerator.module_name("fooBar"))
self.assertEqual("foo_bar_wtf",
DataclassGenerator.module_name("fooBar.wtf"))
self.assertEqual("mod_1111", DataclassGenerator.module_name("1111"))
self.assertEqual("xs_string",
DataclassGenerator.module_name("xs:string"))
self.assertEqual("foo_bar_bam",
DataclassGenerator.module_name("foo:bar_bam"))
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_render(
self,
mock_render_module,
mock_render_package,
):
classes = [
ClassFactory.create(package="foo.bar"),
ClassFactory.create(package="bar.foo"),
ClassFactory.create(package="thug.life"),
]
mock_render_module.return_value = "module"
mock_render_package.return_value = "package"
iterator = DataclassGenerator().render(classes)
cwd = Path.cwd()
actual = [(out.path, out.title, out.source) for out in iterator]
expected = [
(cwd.joinpath("foo/bar/__init__.py"), "init", "package"),
(cwd.joinpath("foo/__init__.py"), "init", "# nothing here\n"),
(cwd.joinpath("bar/foo/__init__.py"), "init", "package"),
(cwd.joinpath("bar/__init__.py"), "init", "# nothing here\n"),
(cwd.joinpath("thug/life/__init__.py"), "init", "package"),
(cwd.joinpath("thug/__init__.py"), "init", "# nothing here\n"),
(cwd.joinpath("foo/bar/tests.py"), "foo.bar.tests", "module"),
(cwd.joinpath("bar/foo/tests.py"), "bar.foo.tests", "module"),
(cwd.joinpath("thug/life/tests.py"), "thug.life.tests", "module"),
]
self.assertEqual(expected, actual)
mock_render_package.assert_has_calls([mock.call([x]) for x in classes])
mock_render_module.assert_has_calls(
[mock.call(mock.ANY, [x]) for x in classes])
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_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_render_package(self):
classes = ClassFactory.list(3)
random.shuffle(classes)
actual = DataclassGenerator().render_package(classes)
expected = "\n".join([
"from foo.tests import ClassB",
"from foo.tests import ClassC",
"from foo.tests import ClassD",
"",
])
self.assertEqual(expected, actual)
def test_prepare_imports(self, mock_process_import):
packages = [
PackageFactory.create(name="foo", source="omg"),
PackageFactory.create(name="bar", source="omg"),
PackageFactory.create(name="thug", source="life"),
]
processed = [
PackageFactory.create(name="aaa", source="a"),
PackageFactory.create(name="bbb", source="b"),
PackageFactory.create(name="ccc", source="c"),
]
mock_process_import.side_effect = processed
expected = {"omg": processed[:2], "life": processed[2:]}
actual = DataclassGenerator().prepare_imports(packages)
self.assertEqual(expected, actual)
def test_render_module(self):
classes = [ClassFactory.enumeration(2), ClassFactory.elements(2)]
resolver = DependenciesResolver()
actual = DataclassGenerator().render_module(resolver, classes)
expected = (
"from enum import Enum\n"
"from dataclasses import dataclass, field\n"
"from typing import Optional\n\n"
'__NAMESPACE__ = "xsdata"\n\n\n'
"class ClassB(Enum):\n"
' """\n'
" :cvar NONE_VALUE:\n"
' """\n'
" NONE_VALUE = None\n\n\n"
"@dataclass\n"
"class ClassC:\n"
' """\n'
" :ivar attr_d:\n"
" :ivar attr_e:\n"
' """\n'
" class Meta:\n"
' name = "class_C"\n\n'
" attr_d: Optional[str] = field(\n"
" default=None,\n"
" metadata=dict(\n"
' name="attr_D",\n'
' type="Element"\n'
" )\n"
" )\n"
" attr_e: Optional[str] = field(\n"
" default=None,\n"
" metadata=dict(\n"
' name="attr_E",\n'
' type="Element"\n'
" )\n"
" )\n"
)
self.assertEqual(expected, actual)
def from_config(cls, config: GeneratorConfig) -> "CodeWriter":
if config.output.format == OutputFormat.PLANTUML:
return cls(generator=PlantUmlGenerator(config))
return cls(generator=DataclassGenerator(config))
def setUp(self):
super().setUp()
self.maxDiff = None
config = GeneratorConfig()
self.generator = DataclassGenerator(config)
class DataclassGeneratorTests(FactoryTestCase):
def setUp(self):
super().setUp()
self.maxDiff = None
config = GeneratorConfig()
self.generator = DataclassGenerator(config)
@mock.patch.object(DataclassGenerator, "render_package")
@mock.patch.object(DataclassGenerator, "render_module")
def test_render(self, mock_render_module, mock_render_package):
classes = [
ClassFactory.create(package="foo.bar"),
ClassFactory.create(package="bar.foo"),
ClassFactory.create(package="thug.life"),
]
mock_render_module.return_value = "module"
mock_render_package.return_value = "package"
iterator = self.generator.render(classes)
cwd = Path.cwd()
actual = [(out.path, out.title, out.source) for out in iterator]
expected = [
(cwd.joinpath("foo/bar/__init__.py"), "init", "package"),
(cwd.joinpath("foo/__init__.py"), "init", "# nothing here\n"),
(cwd.joinpath("bar/foo/__init__.py"), "init", "package"),
(cwd.joinpath("bar/__init__.py"), "init", "# nothing here\n"),
(cwd.joinpath("thug/life/__init__.py"), "init", "package"),
(cwd.joinpath("thug/__init__.py"), "init", "# nothing here\n"),
(cwd.joinpath("foo/bar/tests.py"), "foo.bar.tests", "module"),
(cwd.joinpath("bar/foo/tests.py"), "bar.foo.tests", "module"),
(cwd.joinpath("thug/life/tests.py"), "thug.life.tests", "module"),
]
self.assertEqual(expected, actual)
mock_render_package.assert_has_calls([mock.call([x]) for x in classes])
mock_render_module.assert_has_calls(
[mock.call(mock.ANY, [x]) for x in classes])
def test_render_package(self):
classes = [
ClassFactory.create(qname="a", package="foo"),
ClassFactory.create(qname="b", package="foo"),
ClassFactory.create(qname="c", package="foo"),
ClassFactory.create(qname="a", package="foo", module="bar"),
]
random.shuffle(classes)
actual = self.generator.render_package(classes)
expected = "\n".join([
"from foo.bar import A as BarA",
"from foo.tests import (",
" A as TestsA,",
" B,",
" C,",
")",
"",
"__all__ = [",
' "BarA",',
' "TestsA",',
' "B",',
' "C",',
"]",
"",
])
self.assertEqual(expected, actual)
def test_render_module(self):
classes = [
ClassFactory.enumeration(2, help="\n\nI am enum "),
ClassFactory.elements(2),
ClassFactory.service(2),
]
classes[0].attrs[0].help = "I am a member"
classes[1].attrs[0].help = "I am a field"
resolver = DependenciesResolver()
actual = self.generator.render_module(resolver, classes)
expected = ("from dataclasses import dataclass, field\n"
"from enum import Enum\n"
"from typing import Optional\n"
"\n"
'__NAMESPACE__ = "xsdata"\n'
"\n"
"\n"
"class ClassB(Enum):\n"
' """\n'
" I am enum.\n"
"\n"
" :cvar ATTR_B: I am a member\n"
" :cvar ATTR_C:\n"
' """\n'
" ATTR_B = None\n"
" ATTR_C = None\n"
"\n"
"\n"
"@dataclass\n"
"class ClassC:\n"
' """\n'
" :ivar attr_d: I am a field\n"
" :ivar attr_e:\n"
' """\n'
" class Meta:\n"
' name = "class_C"\n'
"\n"
" attr_d: Optional[str] = field(\n"
" default=None,\n"
" metadata={\n"
' "name": "attr_D",\n'
' "type": "Element",\n'
" }\n"
" )\n"
" attr_e: Optional[str] = field(\n"
" default=None,\n"
" metadata={\n"
' "name": "attr_E",\n'
' "type": "Element",\n'
" }\n"
" )\n"
"\n"
"\n"
"class ClassD:\n"
' attr_f = "None"\n'
' attr_g = "None"\n')
self.assertEqual(expected, actual)
def test_module_name(self):
self.assertEqual("foo_bar", self.generator.module_name("fooBar"))
self.assertEqual("foo_bar_wtf",
self.generator.module_name("fooBar.wtf"))
self.assertEqual("mod_1111", self.generator.module_name("1111"))
self.assertEqual("xs_string", self.generator.module_name("xs:string"))
self.assertEqual("foo_bar_bam",
self.generator.module_name("foo:bar_bam"))
self.assertEqual("bar_bam", self.generator.module_name("urn:bar_bam"))
def test_package_name(self):
self.assertEqual("foo.bar_bar.pkg_1",
self.generator.package_name("Foo.BAR_bar.1"))
def test_module_name(self):
generator = DataclassGenerator()
self.assertEqual("foo_bar", generator.module_name("fooBar"))
self.assertEqual("foo_bar_wtf", generator.module_name("fooBar.wtf"))
self.assertEqual("mod_1111", generator.module_name("1111"))
for _, _, buffer in engine.render(classes):
print(buffer, end="")
def designate(self, classes: List[Class], output: str):
modules = dict()
packages = dict()
for obj in classes:
if obj.module not in modules:
modules[obj.module] = self.module_name(obj.module, output)
if obj.package not in packages:
packages[obj.package] = self.package_name(obj.package, output)
obj.module = modules[obj.module]
obj.package = packages[obj.package]
def module_name(self, module: str, output: str) -> str:
engine = self.get_format(output)
name = module[:-4] if module.endswith(".xsd") else module
return engine.module_name(name)
def package_name(self, package: str, output: str) -> str:
engine = self.get_format(output)
return engine.package_name(package)
writer = CodeWriter()
writer.register_format("pydata", DataclassGenerator())
writer.register_format("plantuml", PlantUmlGenerator())
def test_package_name(self):
self.assertEqual("foo.bar_bar.pkg_1",
DataclassGenerator.package_name("Foo.BAR_bar.1"))
