✅ Test README updates

Author: nikolaik

build_versions/dockerfiles.py

@@ -40,5 +40,6 @@ def render_dockerfile_with_context(config_json: str, dry_run: bool = False) -> N
     if not dry_run:
         if not DOCKERFILES_PATH.exists():
             DOCKERFILES_PATH.mkdir()
-        with (DOCKERFILES_PATH / filename).open("w") as fp:
-            fp.write(dockerfile)
+
+        dockerfile_path = DOCKERFILES_PATH / filename
+        dockerfile_path.write_text(dockerfile)

build_versions/readme.py

@@ -19,7 +19,7 @@ def _replace(name: str, replacement: str, document: str) -> str:
     start = f"<!-- {name}_START -->\n"
     end = f"\n<!-- {name}_END -->"
     repl = f"{start}\n{replacement}\n{end}"
-    return re.sub(f"{start}(.+?){end}", repl, document, flags=re.MULTILINE | re.DOTALL)
+    return re.sub(f"{start}(.*?){end}", repl, document, flags=re.MULTILINE | re.DOTALL)
 
 
 def update_dynamic_readme(
@@ -30,17 +30,15 @@ def update_dynamic_readme(
 ) -> None:
     """Read out current README, format fresh README, write back possible changes"""
     readme_path = Path("README.md")
-    with readme_path.open() as fp:
-        readme = fp.read()
+    readme = readme_path.read_text()
 
     readme_new = format_readme(versions, python_versions, node_versions, readme)
     if readme == readme_new:
         logger.debug("Regenerated readme matches existing")
         return
 
     if not dry_run:
-        with readme_path.open("w+") as fp:
-            fp.write(readme_new)
+        readme_path.write_text(readme_new)
     else:
         print(readme_new)
 

tests/test_all.py

@@ -1,22 +1,23 @@
 import dataclasses
 import json
+from pathlib import Path
+from unittest import mock
 
-from build_versions.dockerfiles import render_dockerfile_with_context
-from build_versions.settings import DOCKERFILES_PATH
-from build_versions.versions import BuildVersion, scrape_supported_python_versions
-
+import pytest
 
-def test_scrape_supported_python_versions() -> None:
-    versions = scrape_supported_python_versions()
-    assert len(versions) > 0
-    first_version = versions[0]
-    assert first_version.version
-    assert first_version.start
-    assert first_version.end
+from build_versions.dockerfiles import render_dockerfile_with_context
+from build_versions.readme import update_dynamic_readme
+from build_versions.settings import BASE_PATH, DOCKERFILES_PATH
+from build_versions.versions import (
+    BuildVersion,
+    SupportedVersion,
+    scrape_supported_python_versions,
+)
 
 
-def test_render_dockerfile_with_context() -> None:
-    build_config = BuildVersion(
+@pytest.fixture(name="build_version")
+def build_version_fixture() -> BuildVersion:
+    return BuildVersion(
         key="python3.11-nodejs20",
         python="3.11",
         python_canonical="3.11.3",
@@ -29,11 +30,73 @@ def test_render_dockerfile_with_context() -> None:
             "linux/arm64",
         ],
     )
-    file_path = DOCKERFILES_PATH / f"{build_config.key}.Dockerfile"
-    render_dockerfile_with_context(json.dumps(dataclasses.asdict(build_config)))
+
+
+def test_scrape_supported_python_versions() -> None:
+    versions = scrape_supported_python_versions()
+    assert len(versions) > 0
+    first_version = versions[0]
+    assert first_version.version
+    assert first_version.start
+    assert first_version.end
+
+
+def test_render_dockerfile_with_context(build_version: BuildVersion) -> None:
+    file_path = DOCKERFILES_PATH / f"{build_version.key}.Dockerfile"
+    render_dockerfile_with_context(json.dumps(dataclasses.asdict(build_version)))
     assert file_path.exists()
     with file_path.open() as fp:
         dockerfile = fp.read()
 
-    assert f"# python: {build_config.python_canonical}" in dockerfile
-    assert f"# nodejs: {build_config.nodejs_canonical}" in dockerfile
+    assert f"# python: {build_version.python_canonical}" in dockerfile
+    assert f"# nodejs: {build_version.nodejs_canonical}" in dockerfile
+
+
+class MockPath:
+    content: str = ""
+
+    def __init__(self: "MockPath", content: str) -> None:
+        self.content = content
+
+    def write_text(self: "MockPath", text: str) -> None:
+        self.content = text
+
+    def read_text(self: "MockPath") -> str:
+        return self.content
+
+
+def test_update_dynamic_readme(build_version: BuildVersion) -> None:
+    ver = build_version
+    python_version = SupportedVersion(start="2022-10-24", end="2027-10", version="3.11")
+    node_version = SupportedVersion(start="2023-04-18", end="2026-04-30", version="v20")
+    initial_content = """
+## Tags
+
+<!-- TAGS_START -->
+
+<!-- TAGS_END -->
+
+## Supported Versions
+
+<!-- SUPPORTED_VERSIONS_START -->
+
+<!-- SUPPORTED_VERSIONS_END -->
+    """
+    mock_path = MockPath(initial_content)
+
+    with mock.patch.multiple(
+        Path,
+        read_text=mock_path.read_text,
+        write_text=mock_path.write_text,
+    ):
+        update_dynamic_readme([ver], [python_version], [node_version])
+
+        file_path = BASE_PATH / "README.md"
+        assert file_path.exists()
+        readme = file_path.read_text()
+    assert (
+        f"`{ver.key}` | {ver.python_canonical} | {ver.nodejs_canonical} | {ver.distro} | {', '.join(ver.platforms)}"
+        in readme
+    )
+    assert f"{python_version.version} | {python_version.start} | {python_version.end}" in readme
+    assert f"{node_version.version} | {node_version.start} | {node_version.end}" in readme