Merge pull request #76 from smkent/manage-release

Implement manage-cookie release for releasing new patch versions

Author: smkent

cookie_python/manage/main.py

@@ -4,6 +4,7 @@
 from enum import Enum
 from typing import Callable, Optional
 
+from .release import release_action
 from .update import update_action
 
 
@@ -13,6 +14,11 @@ class Action(str, Enum):
         update_action,
         "Update repository cruft and dependencies",
     )
+    RELEASE = (
+        "release",
+        release_action,
+        "Release a new patch version",
+    )
 
     def __new__(
         cls,
@@ -31,8 +37,14 @@ def main() -> None:
     ap = argparse.ArgumentParser()
     ap.add_argument(
         "action",
-        type=lambda value: Action(str(value)),
+        type=Action,
         choices=list(Action),
+        metavar="|".join([a.value for a in Action]),
+        help="Action to perform ("
+        + ", ".join(
+            [f"{a.value}: {a.description}" for a in Action]  # type: ignore
+        )
+        + ")",
     )
     ap.add_argument("repo", nargs="+", help="Repository URL")
     ap.add_argument(

cookie_python/manage/release.py

@@ -0,0 +1,51 @@
+from argparse import Namespace
+
+import semver
+
+from .repo import RepoSandbox
+
+
+def release_patch_version(repo: RepoSandbox) -> None:
+    releases = (
+        repo.run(
+            ["gh", "release", "list"],
+            capture_output=True,
+            check=True,
+        )
+        .stdout.decode("utf-8")
+        .splitlines()
+    )
+    latest_tag = None
+    for line in releases:
+        tag, status, *_ = line.split()
+        if status.lower() == "latest":
+            latest_tag = tag
+            break
+    if not latest_tag:
+        print("Unable to find latest version")
+        return None
+    check_refs = ["origin/main", latest_tag]
+    refs = []
+    for ref in check_refs:
+        refs.append(
+            repo.run(["git", "rev-parse", ref], capture_output=True)
+            .stdout.decode("utf-8")
+            .strip()
+        )
+    if len(refs) == len(check_refs) and len(set(refs)) == 1:
+        print(f"No new changes since latest release {latest_tag}")
+        return None
+    sv = semver.VersionInfo.parse(latest_tag.lstrip("v"))
+    next_patch_ver = sv.bump_patch()
+    new_tag = f"v{next_patch_ver}"
+    if repo.dry_run:
+        print(f"Would release new version {new_tag}")
+        return None
+    repo.run(["gh", "release", "create", new_tag, "--generate-notes"])
+    return None
+
+
+def release_action(args: Namespace) -> None:
+    for repo_url in args.repo:
+        with RepoSandbox(repo_url, args.dry_run) as repo:
+            release_patch_version(repo)

poetry.lock

@@ -25,6 +25,7 @@ packages = [
 python = "^3.8"
 poetry-dynamic-versioning = "*"
 pyyaml = "*"
+semver = "*"
 
 [tool.poetry.dev-dependencies]
 bandit = {extras = ["toml"], version = "*"}

pyproject.toml

@@ -2,8 +2,10 @@
 import os
 import subprocess
 import sys
+import textwrap
 from pathlib import Path
-from typing import Iterator
+from types import SimpleNamespace
+from typing import Any, Dict, Iterable, Iterator, Tuple
 from unittest.mock import patch
 
 import pytest
@@ -13,6 +15,7 @@
 
 AUTHOR_NAME = "Ness"
 AUTHOR_EMAIL = "ness@onett.example"
+PROJECT_NAME = "unit-test-1"
 
 
 @pytest.fixture
@@ -34,7 +37,6 @@ def environ() -> Iterator[None]:
 def new_cookie(
     request: pytest.FixtureRequest, environ: None, temp_dir: str
 ) -> Iterator[Path]:
-    project_name = "unit-test-1"
     testargs = [
         "new-cookie",
         "--local",
@@ -49,22 +51,51 @@ def new_cookie(
                 "author_name": AUTHOR_NAME,
                 "github_user": "ness.unittest.example",
                 "project_description": "Unit test project",
-                "project_name": project_name,
+                "project_name": PROJECT_NAME,
             }
         ),
         "-c",
         request.param,
     ]
     with patch.object(sys, "argv", testargs):
         new_cookie_main()
-    project_dir = Path(temp_dir) / project_name
+    yield Path(temp_dir) / PROJECT_NAME
+
+
+@pytest.fixture
+def new_cookie_with_lock(new_cookie: Path, temp_dir: str) -> Iterator[Path]:
     for cmd in (
         ["poetry", "lock", "--no-update"],
         ["git", "add", "poetry.lock"],
         ["git", "commit", "-m", "Create `poetry.lock`"],
     ):
-        subprocess.run(cmd, cwd=project_dir, check=True)
-    yield project_dir
+        subprocess.run(cmd, cwd=new_cookie, check=True)
+    yield new_cookie
+
+
+@pytest.fixture
+def run_or_mock() -> Iterator[Dict[Tuple[str, ...], str]]:
+    real_run = subprocess.run
+    mocked_commands: Dict[Tuple[str, ...], str] = {}
+
+    def _run(*args: Any, **kwargs: Any) -> Any:
+        cmd = args[0]
+        cmd_tuple = tuple(cmd)
+        while cmd_tuple:
+            if cmd_tuple in mocked_commands:
+                return SimpleNamespace(
+                    stdout=mocked_commands[cmd_tuple].encode()
+                )
+            cmd_tuple = cmd_tuple[:-1]
+        return real_run(*args, **kwargs)
+
+    with patch.object(subprocess, "run", _run):
+        yield mocked_commands
+
+
+def _manage_cookie(argv: Iterable[str]) -> None:
+    with patch.object(sys, "argv", argv):
+        manage_cookie_main()
 
 
 @pytest.mark.parametrize(
@@ -73,7 +104,30 @@ def new_cookie(
     ids=["no_updates", "updates"],
     indirect=True,
 )
-def test_manage_cookie_update(new_cookie: str) -> None:
-    testargs = ["manage-cookie", "update", str(new_cookie), "-p"]
-    with patch.object(sys, "argv", testargs):
-        manage_cookie_main()
+def test_manage_cookie_update(new_cookie_with_lock: str) -> None:
+    _manage_cookie(
+        ["manage-cookie", "update", str(new_cookie_with_lock), "-p"]
+    )
+
+
+@pytest.mark.parametrize("add_commit", (True, False))
+def test_manage_cookie_release(
+    new_cookie: str, run_or_mock: Dict[Tuple[str, ...], str], add_commit: bool
+) -> None:
+    run_or_mock[("gh", "release", "list")] = textwrap.dedent(
+        """
+        TITLE       TYPE         TAG NAME  PUBLISHED
+        v1.1.38     Latest       v1.1.38   in a galaxy far, far away
+        v0.21.87                 v0.21.87  about a long time ago
+        v0.0.1                   v0.0.1    about never ago
+        """
+    ).strip()
+    run_or_mock[("gh",)] = ""  # Prevent any actual gh invocations
+    subprocess.run(["git", "tag", "v1.1.38", "@"], cwd=new_cookie, check=True)
+    if add_commit:
+        subprocess.run(
+            ["git", "commit", "--allow-empty", "-m", "create empty commit"],
+            cwd=new_cookie,
+            check=True,
+        )
+    _manage_cookie(["manage-cookie", "release", str(new_cookie), "-p"])

tests/test_manage_cookie.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+class VersionInfo:
+    @staticmethod
+    def parse(version: str) -> VersionInfo:
+        pass
+    def bump_patch(self) -> VersionInfo:
+        pass