p4cmd 2.9.2__tar.gz → 2.10.0__tar.gz

{p4cmd-2.9.2 → p4cmd-2.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p4cmd
-Version: 2.9.2
+Version: 2.10.0
 Summary: Simple P4 python module
 Home-page: https://github.com/nielsvaes/p4cmd
 Author: Niels Vaes

{p4cmd-2.9.2 → p4cmd-2.10.0}/p4cmd/__init__.py

@@ -1,4 +1,4 @@
-VERSION = "2.9.2"
+VERSION = "2.10.0"
 
 from .p4cmd import P4Client
 from .p4file import P4File

{p4cmd-2.9.2 → p4cmd-2.10.0}/p4cmd/p4cmd.py

@@ -84,7 +84,7 @@ class P4Client(object):
         """
         self.max_parallel_connections = value
 
-    def run_cmd(self, cmd, args=None, file_list=None, use_global_options=True, online_check=True):
+    def run_cmd(self, cmd, args=None, file_list=None, use_global_options=True, online_check=True, raise_on_errors=False):
         """
         Reads the output stream of the command and returns it as a marshaled dict.
 
@@ -145,6 +145,20 @@ class P4Client(object):
                         dict_list.append(output_dict)
                     pipe.kill()
 
+        # Check for error dicts in the results
+        errors = [d for d in dict_list if d.get(b"code") == b"error" or d.get("code") == "error"]
+        if errors:
+            messages = []
+            for e in errors:
+                msg = e.get(b"data") or e.get("data") or e.get(b"error") or e.get("error") or "unknown error"
+                if isinstance(msg, bytes):
+                    msg = msg.decode("utf-8", errors="replace")
+                messages.append(msg.strip())
+            for msg in messages:
+                logging.warning(f"p4 {cmd}: {msg}")
+            if raise_on_errors:
+                raise p4errors.P4CommandError(cmd, messages)
+
         return dict_list
 
     def __replace_description_in_template(self, template, new_description):

{p4cmd-2.9.2 → p4cmd-2.10.0}/p4cmd/p4errors.py

@@ -15,6 +15,20 @@ class WorkSpaceError(P4cmdError):
     pass
 
 
+class P4CommandError(P4cmdError):
+    """Raised when a P4 command returns one or more error dicts.
+
+    Attributes:
+        cmd: The P4 command that failed (e.g. "sync", "edit").
+        messages: List of error message strings from the error dicts.
+    """
+    def __init__(self, cmd, messages):
+        self.cmd = cmd
+        self.messages = messages
+        joined = "; ".join(str(m).strip() for m in messages)
+        super().__init__(f"p4 {cmd}: {joined}")
+
+
 class ServerOffline(P4cmdError):
     """Raised when the Perforce server is unreachable.
 

{p4cmd-2.9.2 → p4cmd-2.10.0}/p4cmd.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p4cmd
-Version: 2.9.2
+Version: 2.10.0
 Summary: Simple P4 python module
 Home-page: https://github.com/nielsvaes/p4cmd
 Author: Niels Vaes

{p4cmd-2.9.2 → p4cmd-2.10.0}/tests/test_p4client.py

@@ -1,10 +1,12 @@
 """Tests for p4cmd/p4cmd.py — P4Client with run_cmd mocked."""
+import logging
 import socket
 from unittest.mock import MagicMock, patch
 
 import pytest
 
 from p4cmd.p4cmd import P4Client
+from p4cmd.p4errors import P4CommandError
 from p4cmd.p4file import P4File, Status
 from tests.conftest import make_fstat_dict
 
@@ -577,6 +579,80 @@ def test_get_depot_paths_missing_depot_file(p4client):
     assert result == ["//depot/project/file.txt"]
 
 
+# ---------------------------------------------------------------------------
+# run_cmd error handling
+# ---------------------------------------------------------------------------
+
+def test_run_cmd_logs_warning_on_error_dicts(p4client, caplog):
+    """run_cmd logs a warning for each error dict returned by p4."""
+    error_dict = {b"code": b"error", b"data": b"//depot/file.txt - file(s) not on client.\n"}
+    ok_dict = {b"code": b"stat", b"depotFile": b"//depot/other.txt"}
+    with patch("subprocess.Popen") as mock_popen:
+        import marshal as _m, io as _io
+        buf = _io.BytesIO()
+        _m.dump(error_dict, buf)
+        _m.dump(ok_dict, buf)
+        buf.seek(0)
+        mock_popen.return_value.__enter__ = lambda s: s
+        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
+        mock_popen.return_value.stdout = buf
+        mock_popen.return_value.kill = MagicMock()
+        with caplog.at_level(logging.WARNING):
+            result = p4client.run_cmd("sync", file_list=["//depot/file.txt", "//depot/other.txt"])
+    assert len(result) == 2  # both dicts still returned
+    assert "file(s) not on client" in caplog.text
+
+
+def test_run_cmd_raise_on_errors(p4client):
+    """run_cmd raises P4CommandError when raise_on_errors=True and errors are present."""
+    error_dict = {b"code": b"error", b"data": b"//depot/file.txt - file(s) not on client.\n"}
+    with patch("subprocess.Popen") as mock_popen:
+        import marshal as _m, io as _io
+        buf = _io.BytesIO()
+        _m.dump(error_dict, buf)
+        buf.seek(0)
+        mock_popen.return_value.__enter__ = lambda s: s
+        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
+        mock_popen.return_value.stdout = buf
+        mock_popen.return_value.kill = MagicMock()
+        with pytest.raises(P4CommandError, match="file\\(s\\) not on client"):
+            p4client.run_cmd("sync", file_list=["//depot/file.txt"], raise_on_errors=True)
+
+
+def test_run_cmd_no_raise_without_errors(p4client):
+    """run_cmd doesn't raise when raise_on_errors=True but no errors are present."""
+    ok_dict = {b"code": b"stat", b"depotFile": b"//depot/file.txt"}
+    with patch("subprocess.Popen") as mock_popen:
+        import marshal as _m, io as _io
+        buf = _io.BytesIO()
+        _m.dump(ok_dict, buf)
+        buf.seek(0)
+        mock_popen.return_value.__enter__ = lambda s: s
+        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
+        mock_popen.return_value.stdout = buf
+        mock_popen.return_value.kill = MagicMock()
+        result = p4client.run_cmd("sync", file_list=["//depot/file.txt"], raise_on_errors=True)
+    assert result == [ok_dict]
+
+
+def test_run_cmd_handles_string_key_error_dicts(p4client, caplog):
+    """run_cmd handles error dicts with string keys (from ValueError fallback)."""
+    # String-keyed error dicts come from the ValueError handler in run_cmd
+    error_dict = {b"code": b"error", b"data": b"some error\n"}
+    with patch("subprocess.Popen") as mock_popen:
+        import marshal as _m, io as _io
+        buf = _io.BytesIO()
+        _m.dump(error_dict, buf)
+        buf.seek(0)
+        mock_popen.return_value.__enter__ = lambda s: s
+        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
+        mock_popen.return_value.stdout = buf
+        mock_popen.return_value.kill = MagicMock()
+        with caplog.at_level(logging.WARNING):
+            p4client.run_cmd("sync", file_list=["//depot/file.txt"])
+    assert "some error" in caplog.text
+
+
 def test_get_local_paths_missing_path(p4client):
     """get_local_paths skips entries where path is missing (e.g. unmapped paths from p4 where)."""
     info_dicts = [