update: git/docker version

Author: geritwagner

colrev/ops/commit.py

@@ -4,14 +4,16 @@
 from __future__ import annotations
 
 import importlib
-import os
+import shutil
 import sys
 import typing
 from importlib.metadata import version
 from pathlib import Path
 
 import git
 import gitdb.exc
+from docker import errors as docker_errors
+from docker import from_env as docker_from_env
 
 import colrev.env.environment_manager
 import colrev.env.utils
@@ -86,12 +88,37 @@ def _set_versions(self) -> None:
         self.colrev_version = f'version {version("colrev")}'
         sys_v = sys.version
         self.python_version = f'version {sys_v[: sys_v.find(" ")]}'
-        stream = os.popen("git --version")
-        self.git_version = stream.read().replace("git ", "").replace("\n", "")
-        stream = os.popen("docker --version")
-        self.docker_version = stream.read().replace("Docker ", "").replace("\n", "")
-        if self.docker_version == "":  # pragma: no cover
-            self.docker_version = "Not installed"
+        self.git_version = self._get_git_version()
+        self.docker_version = self._get_docker_version()
+
+    def _get_git_version(self) -> str:
+        git_executable = shutil.which("git")
+        if git_executable is None:
+            return "Not installed"
+
+        try:
+            # Use the resolved absolute executable path to avoid partial-path execution.
+            git.refresh(path=git_executable)
+            version_info = git.cmd.Git().version_info
+            return "version " + ".".join(map(str, version_info))
+        except (git.exc.GitError, TypeError, ValueError):
+            return "Not installed"
+
+    def _get_docker_version(self) -> str:
+        # This validates Docker daemon availability/version through the Docker SDK,
+        # not just whether the docker CLI binary exists on PATH.
+        client = None
+        try:
+            client = docker_from_env()
+            docker_version = client.version().get("Version", "")
+            if docker_version == "":  # pragma: no cover
+                return "Not installed"
+            return f"version {docker_version}"
+        except docker_errors.DockerException:
+            return "Not installed"
+        finally:
+            if client is not None:
+                client.close()
 
     def _set_script_information(self, script_name: str) -> None:
         self.ext_script_name = ""

tests/review_manager/2_ops/commit_test.py

@@ -1,7 +1,9 @@
 #!/usr/bin/env python
 """Tests of the CoLRev commit operation"""
 
+import git
 import pytest
+from docker import errors as docker_errors
 
 import colrev.exceptions as colrev_exceptions
 import colrev.ops.check
@@ -61,3 +63,40 @@ def patched_has_record_changes() -> bool:
     commit_fixture.review_manager.force_mode = False
     commit_fixture.review_manager.force_mode = True
     commit_fixture.create()
+
+
+def test_get_git_version_success(commit_fixture, mocker):  # type: ignore
+    mocker.patch("colrev.ops.commit.shutil.which", return_value="/usr/bin/git")
+    mocker.patch("colrev.ops.commit.git.refresh")
+    mocker.patch(
+        "colrev.ops.commit.git.cmd.Git.version_info",
+        new_callable=mocker.PropertyMock,
+        return_value=(2, 44, 0),
+    )
+
+    assert commit_fixture._get_git_version() == "version 2.44.0"
+
+
+def test_get_git_version_failure(commit_fixture, mocker):  # type: ignore
+    mocker.patch("colrev.ops.commit.shutil.which", return_value="/usr/bin/git")
+    mocker.patch("colrev.ops.commit.git.refresh", side_effect=git.exc.GitError("err"))
+
+    assert commit_fixture._get_git_version() == "Not installed"
+
+
+def test_get_docker_version_success(commit_fixture, mocker):  # type: ignore
+    docker_client = mocker.MagicMock()
+    docker_client.version.return_value = {"Version": "27.1.0"}
+    mocker.patch("colrev.ops.commit.docker_from_env", return_value=docker_client)
+
+    assert commit_fixture._get_docker_version() == "version 27.1.0"
+    docker_client.close.assert_called_once()
+
+
+def test_get_docker_version_failure(commit_fixture, mocker):  # type: ignore
+    mocker.patch(
+        "colrev.ops.commit.docker_from_env",
+        side_effect=docker_errors.DockerException("unavailable"),
+    )
+
+    assert commit_fixture._get_docker_version() == "Not installed"