resolve conversation

Author: Jannis-Mittenzwei

doc/shared_content/how_release.rst

@@ -8,7 +8,7 @@ Creating a Release
 
     .. code-block:: shell
 
-        nox -s release:prepare -- [-h]
+         nox -s release:prepare -- --type {major,minor,patch}
 
 #. Merge your **Pull Request** to the **default branch**
 
@@ -36,17 +36,17 @@ The release failed during pre-release checks
 
         git push --delete origin "<major>.<minor>.<patch>"
 
-#. Fix the issue(s) which lead to the failing checks
+#. Fix the issue(s) which led to the failing checks
 #. Start the release process from the beginning
 
 
 One of the release steps failed (Partial Release)
 -------------------------------------------------
-#. Check the Github action/workflow to see which steps failed
+#. Check the GitHub action/workflow to see which steps failed
 #. Finish or redo the failed release steps manually
 
 .. note:: Example
 
-    **Scenario**: Publishing of the release on Github was successfully but during the PyPi release, the upload step got interrupted.
+    **Scenario**: Publishing of the release on GitHub was successfully but during the PyPi release, the upload step was interrupted.
 
     **Solution**: Manually push the package to PyPi

exasol/toolbox/nox/_release.py

@@ -3,17 +3,11 @@
 import argparse
 import re
 import subprocess
-import sys
 from pathlib import Path
-from typing import (
-    List,
-    Tuple,
-)
 
 import nox
 from nox import Session
 
-from exasol.toolbox import cli
 from exasol.toolbox.nox._shared import (
     Mode,
     _version,
@@ -42,7 +36,6 @@ def _create_parser() -> argparse.ArgumentParser:
         type=ReleaseTypes,
         help="specifies which type of upgrade is to be performed",
         required=True,
-        choices=[rt.value for rt in list(ReleaseTypes)],
         default=argparse.SUPPRESS,
     )
     parser.add_argument(
@@ -97,17 +90,6 @@ def _add_files_to_index(session: Session, files: list[Path]) -> None:
         session.run("git", "add", f"{file}")
 
 
-def _type_release(release_type: ReleaseTypes, old_version: Version) -> Version:
-    upgrade = {
-        ReleaseTypes.Major: Version(old_version.major + 1, 0, 0),
-        ReleaseTypes.Minor: Version(old_version.major, old_version.minor + 1, 0),
-        ReleaseTypes.Patch: Version(
-            old_version.major, old_version.minor, old_version.patch + 1
-        ),
-    }
-    return upgrade[release_type]
-
-
 class ReleaseError(Exception):
     """Error during trigger release"""
 
@@ -119,7 +101,9 @@ def run(*args: str):
                 args, capture_output=True, text=True, check=True
             ).stdout
         except subprocess.CalledProcessError as ex:
-            raise ReleaseError(f"failed to execute command {args}") from ex
+            raise ReleaseError(
+                f"failed to execute command {ex.cmd}\n\n{ex.stderr}"
+            ) from ex
 
     branches = run("git", "remote", "show", "origin")
     if not (result := re.search(r"HEAD branch: (\S+)", branches)):
@@ -196,5 +180,5 @@ def prepare_release(session: Session, python=False) -> None:
 
 @nox.session(name="release:trigger", python=False)
 def trigger_release(session: Session) -> None:
-    """releases the project automatically"""
+    """trigger an automatic project release"""
     print(f"new version: {_trigger_release()}")

exasol/toolbox/release/__init__.py

@@ -28,6 +28,29 @@ def __str__(self):
         return self.name.lower()
 
 
+def poetry(arguments: str):
+    def decorator(function):
+        def wrapper(*args, **kwargs):
+            cmd = which("poetry")
+            if not cmd:
+                raise ToolboxError("Couldn't find poetry executable")
+
+            try:
+                command = [cmd] + arguments.split(" ")
+                result = subprocess.run(
+                    command,
+                    capture_output=True,
+                )
+            except subprocess.CalledProcessError as ex:
+                raise ToolboxError() from ex
+
+            return function(result)
+
+        return wrapper
+
+    return decorator
+
+
 @total_ordering
 @dataclass(frozen=True)
 class Version:
@@ -72,37 +95,19 @@ def from_string(version):
         return Version(*version)
 
     @staticmethod
-    def from_poetry():
-        poetry = which("poetry")
-        if not poetry:
-            raise ToolboxError("Couldn't find poetry executable")
-
-        try:
-            result = subprocess.run(
-                [poetry, "version", "--no-ansi", "--short"], capture_output=True
-            )
-        except subprocess.CalledProcessError as ex:
-            raise ToolboxError() from ex
+    @poetry("version --no-ansi --short")
+    def from_poetry(result):
         version = result.stdout.decode().strip()
 
         return Version.from_string(version)
 
     @staticmethod
     def upgrade_version_from_poetry(t: ReleaseTypes):
-        poetry = which("poetry")
-        if not poetry:
-            raise ToolboxError("Couldn't find poetry executable")
-
-        try:
-            result = subprocess.run(
-                [poetry, "version", str(t), "--dry-run", "--no-ansi", "--short"],
-                capture_output=True,
-            )
-        except subprocess.CalledProcessError as ex:
-            raise ToolboxError() from ex
-        version = result.stdout.decode().strip()
+        @poetry(f"version {str(t)} --dry-run --no-ansi --short")
+        def version(result):
+            return result.stdout.decode().strip()
 
-        return Version.from_string(version)
+        return Version.from_string(version())
 
 
 def extract_release_notes(file: str | Path) -> str:

test/unit/poetry_decorator_test.py

@@ -0,0 +1,31 @@
+from subprocess import CalledProcessError
+from unittest.mock import patch
+
+import pytest
+
+from exasol.toolbox.error import ToolboxError
+from exasol.toolbox.release import poetry
+
+
+@patch("exasol.toolbox.release.which", return_value=None)
+def test_poetry_decorator_no_poetry_executable(mock):
+    @poetry("test")
+    def test(result):
+        pass
+
+    with pytest.raises(ToolboxError):
+        test()
+
+
+@patch("exasol.toolbox.release.which", return_value="")
+@patch(
+    "exasol.toolbox.release.subprocess.run",
+    side_effect=CalledProcessError(returncode=1, cmd=["test"]),
+)
+def test_poetry_decorator_subprocess(mockSR, mockW):
+    @poetry("test")
+    def test(result):
+        pass
+
+    with pytest.raises(ToolboxError):
+        test()

test/unit/release_test.py

@@ -9,11 +9,10 @@
 
 import pytest
 
+from exasol.toolbox.error import ToolboxError
 from exasol.toolbox.nox._release import (
     ReleaseError,
-    ReleaseTypes,
     _trigger_release,
-    _type_release,
 )
 from exasol.toolbox.release import (
     Version,
@@ -156,83 +155,52 @@ def test_extract_release_notes(unreleased_md):
 
 
 @pytest.mark.parametrize(
-    "rtype,old,expected",
+    "error_cmd",
     [
-        ("major", "1.2.3", "2.0.0"),
-        ("minor", "1.2.3", "1.3.0"),
-        ("patch", "1.2.3", "1.2.4"),
+        ("git", "remote", "show", "origin"),
+        ("git", "checkout", "main"),
+        ("git", "pull"),
+        ("git", "tag", "--list"),
+        ("gh", "release", "list"),
+        ("git", "tag", "0.3.0"),
+        ("git", "push", "origin", "0.3.0"),
     ],
 )
-def test_type_release(rtype, old, expected):
-    actual = _type_release(ReleaseTypes(rtype), Version.from_string(old))
-    expected = Version.from_string(expected)
-    assert actual == expected
+@patch("exasol.toolbox.nox._release.Version.from_poetry", return_value="0.3.0")
+def test_trigger_release(mock, error_cmd):
+    def simulate_fail(args, **kwargs):
+        print("_______________")
+        print(args)
+        if args == error_cmd:
+            raise CalledProcessError(returncode=1, cmd=error_cmd)
+        result = ""
+        if args == ("git", "remote", "show", "origin"):
+            result = "test\nHEAD branch: main\ntest"
+        return MagicMock(returncode=0, stdout=result)
+
+    with patch("subprocess.run", side_effect=simulate_fail):
+        with pytest.raises(ReleaseError) as ex:
+            _trigger_release()
+        print(ex.value)
 
 
 @pytest.mark.parametrize(
-    "cmdline, expected",
+    "error_cmd, result",
     [
-        (
-            ("git", "remote", "show", "origin"),
-            CalledProcessError,
-        ),
         (
             ("git", "remote", "show", "origin"),
             "test\nHEAD: \ntest",
         ),
-        (
-            ("git", "checkout", "main"),
-            CalledProcessError,
-        ),
-        (
-            ("git", "pull"),
-            CalledProcessError,
-        ),
-        (
-            ("git", "tag", "--list"),
-            CalledProcessError,
-        ),
         (
             ("git", "tag", "--list"),
             "0.1.0\n0.2.0\n0.3.0",
         ),
-        (
-            ("gh", "release", "list"),
-            CalledProcessError,
-        ),
         (
             ("gh", "release", "list"),
             "0.1.0\n0.2.0\n0.3.0",
         ),
-        (
-            ("git", "tag", "0.3.0"),
-            CalledProcessError,
-        ),
-        (
-            ("git", "push", "origin", "0.3.0"),
-            CalledProcessError,
-        ),
     ],
 )
 @patch("exasol.toolbox.nox._release.Version.from_poetry", return_value="0.3.0")
-def test_x1(mock, cmdline, expected):
-    def valide_result(args):
-        if args == ("git", "remote", "show", "origin"):
-            return "test\nHEAD branch: main\ntest"
-        return ""
-
-    def simulate_fail(args, **kwargs):
-        print("_______________")
-        print(args)
-        if args != cmdline:
-            print(valide_result(args))
-            return MagicMock(returncode=0, stdout=valide_result(args))
-        if expected == CalledProcessError:
-            raise CalledProcessError(returncode=1, cmd=cmdline)
-        else:
-            return MagicMock(returncode=0, stdout=expected)
-
-    with patch("subprocess.run", side_effect=simulate_fail):
-        with pytest.raises(ReleaseError) as ex:
-            _trigger_release()
-        print(ex.value)
+def test_trigger_release_bad_return(mock, error_cmd, result):
+    assert True