Split project building into multiple functions, added some tests

#3 progress

Author: dbanty

openapi_python_client/__init__.py

@@ -13,7 +13,8 @@ def main(*, url: Optional[str], path: Optional[str]) -> None:
     """ Generate the client library """
     data_dict = _get_json(url=url, path=path)
     openapi = OpenAPI.from_dict(data_dict)
-    _build_project(openapi=openapi)
+    project = _Project(openapi=openapi)
+    project.build()
 
 
 def _get_json(*, url: Optional[str], path: Optional[str]) -> Dict[str, Any]:
@@ -30,66 +31,81 @@ def _get_json(*, url: Optional[str], path: Optional[str]) -> Dict[str, Any]:
     return json.loads(json_bytes)
 
 
-def _build_project(*, openapi: OpenAPI) -> None:
-    env = Environment(loader=PackageLoader(__package__), trim_blocks=True, lstrip_blocks=True)
-
-    # Create output directories
-    project_name = f"{openapi.title.replace(' ', '-').lower()}-client"
-    print(f"Generating {project_name}")
-    package_name = f"{openapi.title.replace(' ', '_').lower()}_client"
-    project_dir = Path.cwd() / project_name
-    project_dir.mkdir()
-    package_dir = project_dir / package_name
-    package_dir.mkdir()
-    package_init = package_dir / "__init__.py"
-    package_description = f"A client library for accessing {openapi.title}"
-    package_init_template = env.get_template("package_init.pyi")
-    package_init.write_text(package_init_template.render(description=package_description))
-
-    # Create a pyproject.toml file
-    pyproject_template = env.get_template("pyproject.toml")
-    pyproject_path = project_dir / "pyproject.toml"
-    pyproject_path.write_text(
-        pyproject_template.render(project_name=project_name, package_name=package_name, description=package_description)
-    )
-
-    readme = project_dir / "README.md"
-    readme_template = env.get_template("README.md")
-    readme.write_text(readme_template.render(description=package_description))
-
-    # Generate models
-    models_dir = package_dir / "models"
-    models_dir.mkdir()
-    models_init = models_dir / "__init__.py"
-    imports = []
-
-    model_template = env.get_template("model.pyi")
-    for schema in openapi.schemas.values():
-        module_path = models_dir / f"{schema.reference.module_name}.py"
-        module_path.write_text(model_template.render(schema=schema))
-        imports.append(import_string_from_reference(schema.reference))
-
-    # Generate enums
-    enum_template = env.get_template("enum.pyi")
-    for enum in openapi.enums.values():
-        module_path = models_dir / f"{enum.name}.py"
-        module_path.write_text(enum_template.render(enum=enum))
-        imports.append(import_string_from_reference(enum.reference))
-
-    models_init_template = env.get_template("models_init.pyi")
-    models_init.write_text(models_init_template.render(imports=imports))
-
-    # Generate Client
-    client_path = package_dir / "client.py"
-    client_template = env.get_template("client.pyi")
-    client_path.write_text(client_template.render())
-
-    # Generate endpoints
-    api_dir = package_dir / "api"
-    api_dir.mkdir()
-    api_init = api_dir / "__init__.py"
-    api_init.write_text('""" Contains all methods for accessing the API """')
-    endpoint_template = env.get_template("endpoint_module.pyi")
-    for tag, collection in openapi.endpoint_collections_by_tag.items():
-        module_path = api_dir / f"{tag}.py"
-        module_path.write_text(endpoint_template.render(collection=collection))
+class _Project:
+    def __init__(self, *, openapi: OpenAPI):
+        self.openapi: OpenAPI = openapi
+        self.env: Environment = Environment(loader=PackageLoader(__package__), trim_blocks=True, lstrip_blocks=True)
+
+        self.project_name: str = f"{openapi.title.replace(' ', '-').lower()}-client"
+        self.project_dir: Path = Path.cwd() / self.project_name
+
+        self.package_name: str = self.project_name.replace("-", "_")
+        self.package_dir: Path = self.project_dir / self.package_name
+
+    def build(self):
+        """ Create the project from templates """
+        print(f"Generating {self.project_name}")
+        self.project_dir.mkdir()
+        self.package_dir.mkdir()
+        self._build_metadata()
+        self._build_models()
+        self._build_api()
+
+    def _build_metadata(self):
+        # Package __init__.py
+        package_init = self.package_dir / "__init__.py"
+        package_description = f"A client library for accessing {self.openapi.title}"
+        package_init_template = self.env.get_template("package_init.pyi")
+        package_init.write_text(package_init_template.render(description=package_description))
+
+        # Create a pyproject.toml file
+        pyproject_template = self.env.get_template("pyproject.toml")
+        pyproject_path = self.project_dir / "pyproject.toml"
+        pyproject_path.write_text(
+            pyproject_template.render(project_name=self.project_name, package_name=self.package_name,
+                                      description=package_description)
+        )
+
+        # README.md
+        readme = self.project_dir / "README.md"
+        readme_template = self.env.get_template("README.md")
+        readme.write_text(readme_template.render(description=package_description))
+
+    def _build_models(self):
+        # Generate models
+        models_dir = self.package_dir / "models"
+        models_dir.mkdir()
+        models_init = models_dir / "__init__.py"
+        imports = []
+
+        model_template = self.env.get_template("model.pyi")
+        for schema in self.openapi.schemas.values():
+            module_path = models_dir / f"{schema.reference.module_name}.py"
+            module_path.write_text(model_template.render(schema=schema))
+            imports.append(import_string_from_reference(schema.reference))
+
+        # Generate enums
+        enum_template = self.env.get_template("enum.pyi")
+        for enum in self.openapi.enums.values():
+            module_path = models_dir / f"{enum.name}.py"
+            module_path.write_text(enum_template.render(enum=enum))
+            imports.append(import_string_from_reference(enum.reference))
+
+        models_init_template = self.env.get_template("models_init.pyi")
+        models_init.write_text(models_init_template.render(imports=imports))
+
+    def _build_api(self):
+        # Generate Client
+        client_path = self.package_dir / "client.py"
+        client_template = self.env.get_template("client.pyi")
+        client_path.write_text(client_template.render())
+
+        # Generate endpoints
+        api_dir = self.package_dir / "api"
+        api_dir.mkdir()
+        api_init = api_dir / "__init__.py"
+        api_init.write_text('""" Contains all methods for accessing the API """')
+        endpoint_template = self.env.get_template("endpoint_module.pyi")
+        for tag, collection in self.openapi.endpoint_collections_by_tag.items():
+            module_path = api_dir / f"{tag}.py"
+            module_path.write_text(endpoint_template.render(collection=collection))

tests/test___init__.py

@@ -6,7 +6,7 @@ def test_main(mocker):
     _get_json = mocker.patch("openapi_python_client._get_json", return_value=data_dict)
     openapi = mocker.MagicMock()
     from_dict = mocker.patch("openapi_python_client.openapi_parser.OpenAPI.from_dict", return_value=openapi)
-    _build_project = mocker.patch("openapi_python_client._build_project")
+    _Project = mocker.patch("openapi_python_client._Project")
     url = mocker.MagicMock()
     path = mocker.MagicMock()
 
@@ -16,7 +16,8 @@ def test_main(mocker):
 
     _get_json.assert_called_once_with(url=url, path=path)
     from_dict.assert_called_once_with(data_dict)
-    _build_project.assert_called_once_with(openapi=openapi)
+    _Project.assert_called_once_with(openapi=openapi)
+    _Project().build.assert_called_once()
 
 
 class TestGetJson:
@@ -75,3 +76,71 @@ def test__get_json_path_no_url(self, mocker):
         get.assert_not_called()
         Path.assert_called_once_with(path)
         loads.assert_called_once_with(Path().read_bytes())
+
+
+class TestProject:
+    def test___init__(self, mocker):
+        openapi = mocker.MagicMock(title="My Test API")
+
+        from openapi_python_client import _Project
+
+        project = _Project(openapi=openapi)
+
+        assert project.openapi == openapi
+        assert project.project_name == "my-test-api-client"
+        assert project.package_name == "my_test_api_client"
+
+    def test_build(self, mocker):
+        from openapi_python_client import _Project
+
+        project = _Project(openapi=mocker.MagicMock(title="My Test API"))
+        project.project_dir = mocker.MagicMock()
+        project.package_dir = mocker.MagicMock()
+        project._build_metadata = mocker.MagicMock()
+        project._build_models = mocker.MagicMock()
+        project._build_api = mocker.MagicMock()
+
+        project.build()
+
+        project.project_dir.mkdir.assert_called_once()
+        project.package_dir.mkdir.assert_called_once()
+        project._build_metadata.assert_called_once()
+        project._build_models.assert_called_once()
+        project._build_api.assert_called_once()
+
+    def test__build_metadata(self, mocker):
+        from openapi_python_client import _Project
+
+        project = _Project(openapi=mocker.MagicMock(title="My Test API"))
+        project.project_dir = mocker.MagicMock()
+        pyproject_path = mocker.MagicMock()
+        readme_path = mocker.MagicMock()
+        project.project_dir.__truediv__.side_effect = [pyproject_path, readme_path]
+        project.package_dir = mocker.MagicMock()
+        package_init_template = mocker.MagicMock()
+        pyproject_template = mocker.MagicMock()
+        readme_template = mocker.MagicMock()
+        project.env = mocker.MagicMock()
+        project.env.get_template.side_effect = [package_init_template, pyproject_template, readme_template]
+
+        project._build_metadata()
+
+        project.env.get_template.assert_has_calls(
+            [mocker.call("package_init.pyi"), mocker.call("pyproject.toml"), mocker.call("README.md"),]
+        )
+        description = f"A client library for accessing {project.openapi.title}"
+        package_init = project.package_dir / "__init__.py"
+        package_init_template.render.assert_called_once_with(description=description)
+        package_init.write_text.assert_called_once_with(package_init_template.render())
+        pyproject_template.render.assert_called_once_with(
+            project_name=project.project_name, package_name=project.package_name, description=description
+        )
+        pyproject_path.write_text.assert_called_once_with(pyproject_template.render())
+        readme_template.render.assert_called_once_with(description=description)
+        readme_path.write_text.assert_called_once_with(readme_template.render())
+
+    def test__build_models(self):
+        assert False
+
+    def test__build_api(self):
+        assert False