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_add_import(self): self.assertEqual(0, len(self.resolver.imports)) package = "here.there" foo_qname = "foo" bar_qname = "bar" self.resolver.add_import(foo_qname, package, False) self.resolver.add_import(bar_qname, package, True) first = PackageFactory.create(name="foo", source=package, alias=None) second = PackageFactory.create(name="bar", source=package, alias="there:bar") self.assertEqual(2, len(self.resolver.imports)) self.assertEqual(first, self.resolver.imports[0]) self.assertEqual(second, self.resolver.imports[1]) self.assertEqual({bar_qname: "there:bar"}, self.resolver.aliases)
def test_process_import(self): package = PackageFactory.create(name="bar", alias="foo:bar", source="some.foo.bar") actual = generator.process_import(package) self.assertIs(actual, package) self.assertEqual("Bar", package.name) self.assertEqual("FooBar", package.alias) self.assertEqual("some.foo.bar", package.source)
def test_sorted_imports(self): packages = [ PackageFactory.create(name=x, alias=None, source="foo") for x in "cab" ] self.resolver.imports = packages result = self.resolver.sorted_imports() self.assertIsNot(packages, result) self.assertEqual(packages[1], result[0]) self.assertEqual(packages[2], result[1]) self.assertEqual(packages[0], result[2])
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_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)