add interface unit test

Author: kguzek

README.md

@@ -90,4 +90,21 @@ Planned available languages:
 - [ ] erlang
 - [ ] elixir
 
+## Contributing
+
+Know any of the above langauges and want to help out? Your contributions will be greatly appreciated!
+
+For more information on how to implement the language interface, refer to [this issue](https://github.com/kguzek/leetcode-project-generator/issues/1).
+Then, fork this repository, make your changes and [submit them as a pull request](https://github.com/kguzek/leetcode-project-generator/compare).
+
+### Testing
+
+You can test all registered language interfaces (including your implementation) by running the test file found at [src/lpg/interfaces/lang_test.py](src/lpg/interfaces/lang_test.py):
+
+```sh
+python -m unittest src.lpg.interfaces.lang_test
+```
+
+This uses the builtin `unittest` module and executes project generation for each language against an arbitrary list of LeetCode problems in a temporary directory, which is then cleaned up.
+
 Thanks for reading!

pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "leetcode-project-generator"
-version = "1.2.1"
+version = "1.3.0"
 authors = [
   { name = "Konrad Guzek", email = "[email protected]" },
 ]

src/lpg/constants.py

@@ -0,0 +1,3 @@
+"""Constants used throughout modules."""
+
+OUTPUT_RESULT_PREFIX = "result:"

src/lpg/interfaces/file.py

@@ -1,12 +1,14 @@
 """API for accessing various OS and filesystem functions."""
 
 import os
+
 from click import ClickException
 
+from .lang.base import BaseLanguageInterface
 from .lang.c import CLanguageInterface
 from .lang.python3 import Python3LanguageInterface
 
-LANGUAGE_INTERFACES = {
+LANGUAGE_INTERFACES: dict[str, BaseLanguageInterface] = {
     "c": CLanguageInterface(),
     "python3": Python3LanguageInterface(),
 }
@@ -27,7 +29,10 @@ def create_project_directory(project_path: str, force: bool):
 
 
 def create_project(
-    project_name: str, project_directory: str, template_data: dict, force: bool
+    project_name: str,
+    project_directory: str,
+    template_data: dict[str, str],
+    force: bool,
 ):
     """Creates the entire project. Returns the path that it was created in."""
 

src/lpg/interfaces/lang/base.py

@@ -1,10 +1,18 @@
 """This file contains the base class for language interfaces."""
 
-from abc import abstractmethod
-from typing import Any, Pattern, Match
+import re
+from abc import ABCMeta, abstractmethod
+from typing import Any, Match, Pattern
 
+from ...constants import OUTPUT_RESULT_PREFIX
 
-class BaseLanguageInterface:
+SUPPLEMENTAL_CODE_PATTERN = re.compile(
+    r"Definition for .+\n(?:(?:# | \* |// ).+\n)+", re.MULTILINE
+)
+COMMENT_PATTERN = re.compile(r"^(?:# | \* |// )(.+)$")
+
+
+class BaseLanguageInterface(metaclass=ABCMeta):
     """Base class for language interfaces."""
 
     def __init__(self):
@@ -14,7 +22,22 @@ def __init__(self):
     @property
     @abstractmethod
     def function_signature_pattern(self) -> Pattern[str]:
-        """Returns the function signature regular expression pattern."""
+        """The regular expression pattern which extracts data from the function definition."""
+
+    @property
+    @abstractmethod
+    def compile_command(self) -> list[str] | None:
+        """The command to compile the project, for testing. Can be set to None if not needed."""
+
+    @property
+    @abstractmethod
+    def test_command(self) -> list[str]:
+        """The command to run the project test."""
+
+    @property
+    @abstractmethod
+    def default_output(self) -> str:
+        """The default output when running the barebones project test."""
 
     @abstractmethod
     def prepare_project_files(self, template: str) -> dict[str, str]:
@@ -28,7 +51,22 @@ def create_project(self, template: str) -> None:
                 f"Fatal error: project template doesn't match regex:\n\n{template}"
             )
         self.groups = self.match.groupdict()
+        self.groups["OUTPUT_RESULT_PREFIX"] = OUTPUT_RESULT_PREFIX
 
         for filename, content in self.prepare_project_files(template).items():
             with open(filename, "w", encoding="utf-8") as file:
                 file.write(content)
+
+    def get_supplemental_code(self, template: str) -> str | None:
+        """Returns the implicit template code, such as a linked list node implementation."""
+        match = SUPPLEMENTAL_CODE_PATTERN.search(template)
+        if match is None:
+            return None
+        commented_code = match.group(0).split("\n")
+        # the first line does not contain code
+        commented_code.pop(0)
+        return "\n".join(
+            match.group(1)
+            for match in (COMMENT_PATTERN.match(line) for line in commented_code)
+            if match is not None
+        )

src/lpg/interfaces/lang/c.py

@@ -1,8 +1,10 @@
 """Project generator for the C language."""
 
 import re
+
 from .base import BaseLanguageInterface
 
+STDBOOL_HEADER = "#include <stdbool.h>\n"
 HEADER_FILE_TEMPLATE = "{returnType} {name}({params});"
 
 TEST_FILE_TEMPLATE = """\
@@ -11,22 +13,31 @@
 
 int main() {{
     {param_declarations};
-    {returnType} result = {name}({params_call});
-    printf("result: %d\\n", result);
+    {result_var_declaration}{name}({params_call});
+    printf("{OUTPUT_RESULT_PREFIX} %d\\n", {result_var});
     return 0;
 }}
 """
 
 FUNCTION_SIGNATURE_PATTERN = re.compile(
-    r"^(?P<returnType>(?:struct )?\w+(?:\[\]|\*\*?)?) (?P<name>\w+)\((?P<params>(?:(?:struct )?\w+(?:\[\]|\*\*?)? \w+(?:, )?)+)\)\s?{$",
-    flags=re.MULTILINE,
+    r"""
+    ^(?P<returnType>(?:struct\s)?\w+(?:\[\]|\s?\*+)?)\s(?P<name>\w+)
+    \((?P<params>(?:(?:struct\s)?\w+(?:\[\]|\s?\*+)?\s\w+(?:,\s)?)+)\)\s?{$
+    """,
+    flags=re.MULTILINE | re.VERBOSE,
 )
 
+SOLUTION_REPLACEMENT_PATTERN = re.compile(r"\n}")
+SOLUTION_REPLACEMENT_TEMPLATE = "return 0;\n}"
+
 
 class CLanguageInterface(BaseLanguageInterface):
     """Implementation of the C language project template interface."""
 
     function_signature_pattern = FUNCTION_SIGNATURE_PATTERN
+    compile_command = ["gcc", "solution.c", "test.c", "-o", "test"]
+    test_command = ["./test"]
+    default_output = "0"
 
     def prepare_project_files(self, template: str):
 
@@ -35,10 +46,29 @@ def prepare_project_files(self, template: str):
             ", ", ";\n    "
         )
         self.groups["params_call"] = ", ".join(param.split()[-1] for param in params)
-        formatted = TEST_FILE_TEMPLATE.format(**self.groups)
+
+        headers = ""
+        if "bool" in template:
+            headers += STDBOOL_HEADER
+        # ... additional header checks can be added here
+        if headers != "":
+            headers += "\n"
+
+        if self.groups["returnType"] == "void":
+            self.groups["result_var_declaration"] = ""
+            self.groups["result_var"] = "0"
+            formatted_template = template
+        else:
+            self.groups["result_var_declaration"] = (
+                f"{self.groups['returnType']} result = "
+            )
+            self.groups["result_var"] = "result"
+            formatted_template = re.sub(
+                SOLUTION_REPLACEMENT_PATTERN, SOLUTION_REPLACEMENT_TEMPLATE, template
+            )
 
         return {
-            "solution.c": f"{template}\n",
-            "solution.h": HEADER_FILE_TEMPLATE.format(**self.groups),
-            "test.c": formatted,
+            "solution.c": f"{headers}{formatted_template}\n",
+            "solution.h": f"{headers}{HEADER_FILE_TEMPLATE.format(**self.groups)}",
+            "test.c": TEST_FILE_TEMPLATE.format(**self.groups),
         }

src/lpg/interfaces/lang/python3.py

@@ -1,6 +1,7 @@
 """Project generator for the Python 3 language."""
 
 import re
+
 from .base import BaseLanguageInterface
 
 FUNCTION_SIGNATURE_PATTERN = re.compile(
@@ -15,17 +16,20 @@
 from solution import Solution
 
 
-if __name__ == "__main__":
+{supplemental_code}if __name__ == "__main__":
     {params_setup}
     result = Solution().{name}({params_call})
-    print("result:", result)
+    print("{OUTPUT_RESULT_PREFIX}", result)
 """
 
 
 class Python3LanguageInterface(BaseLanguageInterface):
     """Implementation of the Python 3 language project template interface."""
 
     function_signature_pattern = FUNCTION_SIGNATURE_PATTERN
+    compile_command = None
+    test_command = ["python", "test.py"]
+    default_output = "None"
 
     def prepare_project_files(self, template: str):
         params = (
@@ -44,7 +48,12 @@ def prepare_project_files(self, template: str):
             param.split("=")[0].split(":")[0].strip() for param in params
         )
 
+        supplemental_code = self.get_supplemental_code(template)
+        supplemental_code = (
+            "" if supplemental_code is None else f"{supplemental_code}\n\n\n"
+        )
+        self.groups["supplemental_code"] = supplemental_code
         return {
-            "solution.py": f"{TYPING_IMPORT_TEMPLATE}\n{template}pass\n",
+            "solution.py": f"{TYPING_IMPORT_TEMPLATE}\n{supplemental_code}{template}pass\n",
             "test.py": f"{TYPING_IMPORT_TEMPLATE}{TEST_FILE_TEMPLATE.format(**self.groups)}",
         }

src/lpg/interfaces/lang_test.py

@@ -0,0 +1,92 @@
+"""Unit test for all language interfaces."""
+
+import os
+import subprocess
+import tempfile
+import unittest
+
+from ..constants import OUTPUT_RESULT_PREFIX
+from .file import LANGUAGE_INTERFACES
+from .web import get_code_snippets
+
+TEST_CASES = [
+    "add-binary",
+    "add-two-numbers",
+    "add-two-promises",
+    "build-array-from-permutation",
+    "climbing-stairs",
+    "concatenation-of-array",
+    "defanging-an-ip-address",
+    "display-the-first-three-rows",
+    "divide-two-integers",
+    "final-value-of-variable-after-performing-operations",
+    "find-the-index-of-the-first-occurrence-in-a-string",
+    "hand-of-straights",
+    "integer-to-roman",
+    "length-of-last-word",
+    "longest-palindromic-substring",
+    "longest-substring-without-repeating-characters",
+    "merge-sorted-array",
+    "merge-two-sorted-lists",
+    "n-queens",
+    "minimize-maximum-pair-sum-in-array",
+    "modify-columns",
+    "number-of-good-pairs",
+    "plus-one",
+    "remove-duplicates-from-sorted-list",
+    "return-length-of-arguments-passed",
+    "reverse-string",
+    "score-of-a-string",
+    "search-insert-position",
+    "string-to-integer-atoi",
+    "two-sum",
+]
+
+
+class TestProjectGeneration(unittest.TestCase):
+    """Test case for the project generation process."""
+
+    def conduct_tests(self, code_snippets: list[dict[str, str]]):
+        """Generates, compiles and runs the solution code for each supported language."""
+        for template_data in code_snippets:
+            language = template_data["langSlug"]
+            interface = LANGUAGE_INTERFACES.get(language)
+            if interface is None:
+                continue
+
+            # print(f"Testing {language} interface...")
+            interface.create_project(template_data["code"])
+            if interface.compile_command is not None:
+                subprocess.run(interface.compile_command, check=True)
+            result = subprocess.run(
+                interface.test_command, check=True, capture_output=True
+            )
+            self.assertMultiLineEqual(
+                result.stdout.decode().strip(),
+                f"{OUTPUT_RESULT_PREFIX} {interface.default_output}",
+            )
+
+
+def generate_test(test_case: str):
+    """Generates a test function for a specific LeetCode problem."""
+
+    def test(self: TestProjectGeneration):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # print(f"\nGenerating {test_case} in directory {temp_dir}...")
+            os.chdir(temp_dir)
+            self.conduct_tests(get_code_snippets(test_case))
+
+    return test
+
+
+def register_tests():
+    """Registers all LeetCode problems as separate test cases."""
+    for test_case in TEST_CASES:
+        test_name = f"test_{test_case.replace('-', '_')}"
+        setattr(TestProjectGeneration, test_name, generate_test(test_case))
+
+
+register_tests()
+
+if __name__ == "__main__":
+    unittest.main()

src/lpg/interfaces/web.py

@@ -76,29 +76,36 @@ def _get_body_from_request(request: urllib.request.Request) -> dict:
     return data
 
 
-def _get_template_data_from_body(body: dict, lang: str) -> dict[str, any]:
+def get_code_snippets(title_slug: str) -> list[dict[str, str]]:
+    """Fetches all code snippets for the given LeetCode problem."""
+    request = _create_graphql_request(title_slug)
+    body = _get_body_from_request(request)
     question = body["data"]["question"]
     try:
         code_snippets = question["codeSnippets"]
     except TypeError as type_error:
         raise ClickException("Invalid title slug.") from type_error
+    return code_snippets
+
+
+def _get_template_data(title_slug, language: str):
+    code_snippets = get_code_snippets(title_slug)
+
     for lang_data in code_snippets:
-        if lang_data["langSlug"] != lang:
+        if lang_data["langSlug"] != language:
             continue
         return lang_data
-    raise ClickException(f"Invalid code language '{lang}'.")
+    raise ClickException(f"Invalid programming language '{language}'.")
 
 
 def get_leetcode_template(
-    lang: str, title_slug: str | None = None, url: str | None = None
+    language: str, title_slug: str | None = None, url: str | None = None
 ):
     """Fetches the LeetCode problem code template for the given language."""
     if url is None:
         if title_slug is None:
             raise ClickException("Either url or title slug must be specified.")
     else:
         title_slug = _get_title_slug(url)
-    request = _create_graphql_request(title_slug)
-    body = _get_body_from_request(request)
-    template_data = _get_template_data_from_body(body, lang)
+    template_data = _get_template_data(title_slug, language)
     return title_slug, template_data