p4cmd 2.11.2__tar.gz → 2.11.3__tar.gz

{p4cmd-2.11.2 → p4cmd-2.11.3}/PKG-INFO

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

{p4cmd-2.11.2 → p4cmd-2.11.3}/p4cmd/__init__.py

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

{p4cmd-2.11.2 → p4cmd-2.11.3}/p4cmd/p4cmd.py

@@ -1,7 +1,10 @@
+import contextlib
+import io
 import os
 import marshal
 import subprocess
 import socket
+import tempfile
 import warnings
 from pprint import pformat
 
@@ -17,6 +20,41 @@ MAX_CMD_LEN = 8190
 MAX_ARG_LEN = 8000  # max length of args string when combined, close to max, but leaving some extra margin
 
 
+def _run_command(command, cwd, input=None, stderr=None, check=False):
+    """
+    Run a shell command and return what it wrote to stdout, once it has exited.
+
+    The output goes to a temporary file rather than a pipe. Reading a pipe until it closes waits for every
+    process holding its write end, not just the command: on Windows, a process that something else in this
+    process starts at the same moment with handle inheritance (e.g. a host application starting a server on
+    another thread) inherits the write end and keeps it open, so the read never ends. The file is read once
+    the command has exited, whoever else holds it.
+
+    stdin is NUL, or a temporary file holding ``input``: the parent's stdin isn't duplicated (OSError
+    WinError 50 in non-interactive sessions, see #13), and a command asking for input it wasn't given gets
+    none instead of waiting for it.
+
+    :param input: *bytes* for the command's stdin, e.g. the form for ``p4 change -i``
+    :param stderr: as for subprocess.Popen: None leaves it as it is, subprocess.STDOUT adds it to the output
+    :param check: *bool* if True, a non-zero exit status raises subprocess.CalledProcessError with the
+        output, like subprocess.check_output
+    """
+    with contextlib.ExitStack() as files:
+        stdin = subprocess.DEVNULL
+        if input is not None:
+            stdin = files.enter_context(tempfile.TemporaryFile())
+            stdin.write(input)
+            stdin.seek(0)
+        output = files.enter_context(tempfile.TemporaryFile())
+        with subprocess.Popen(command, stdin=stdin, stdout=output, stderr=stderr, shell=True, cwd=cwd) as process:
+            returncode = process.wait()
+        output.seek(0)
+        data = output.read()
+    if check and returncode:
+        raise subprocess.CalledProcessError(returncode, command, output=data)
+    return data
+
+
 class P4Client(object):
     def __init__(self, perforce_root, user=None, client=None, server=None, silent=None, max_parallel_connections=4):
         """
@@ -61,7 +99,20 @@ class P4Client(object):
             if self.server is None:
                 raise p4errors.WorkSpaceError("Could not find P4PORT")
 
-        self.depot_root = self.get_depot_paths([self.perforce_root])[0]
+        # `p4 where` comes back empty when the client cannot talk to the
+        # server -- most commonly an expired ticket. Indexing [0] blindly
+        # turned that into a bare `IndexError: list index out of range`,
+        # which tells the caller nothing. Callers that reconstruct a
+        # P4Client to recover a dropped connection need to be able to tell
+        # "log in again" apart from a genuine bug.
+        depot_paths = self.get_depot_paths([self.perforce_root])
+        if not depot_paths:
+            raise p4errors.WorkSpaceError(
+                "Could not resolve the depot root for %s. The server may be "
+                "unreachable, or your Perforce ticket may have expired -- try "
+                "`p4 login`." % self.perforce_root
+            )
+        self.depot_root = depot_paths[0]
 
     @classmethod
     def from_env(cls, *args, **kwargs):
@@ -152,36 +203,38 @@ class P4Client(object):
                 if len(command) > MAX_CMD_LEN:
                     # This shouldn't happen, but just in case the command prefix end up really long
                     _log.warning(
-                        f"Command length: {format(len(command))} exceeds MAX_CMD_LEN {MAX_CMD_LEN} on command: {MAX_CMD_LEN}")
-
-                with subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, shell=True, cwd=self.perforce_root) as pipe:
-                    output = pipe.stdout
-                    if not marshal_output:
-                        # Without -G, p4 emits plain text (and `p4 set` ignores -G even when passed),
-                        # so marshal.load is guaranteed to fail. Read stdout directly from this Popen
-                        # — it has stdin=PIPE, so it's safe in non-interactive sessions where the old
-                        # check_output fallback hit OSError(WinError 50) on DuplicateHandle.
+                        f"Command length: {format(len(command))} exceeds MAX_CMD_LEN {MAX_CMD_LEN} on command: {command}")
+
+                output = _run_command(command, self.perforce_root)
+                if not marshal_output:
+                    # Without -G, p4 emits plain text (and `p4 set` ignores -G even when passed),
+                    # so marshal.load is guaranteed to fail. Use the output as it is — no second
+                    # subprocess, which in non-interactive sessions hit OSError(WinError 50) on
+                    # DuplicateHandle in the old check_output fallback.
+                    dict_list.append({
+                        "command": command,
+                        "code": "raw",
+                        "raw_output": output,
+                    })
+                else:
+                    stream = io.BytesIO(output)
+                    parsed = []
+                    try:
+                        while True:
+                            parsed.append(marshal.load(stream))
+                    except EOFError:
+                        dict_list.extend(parsed)
+                    except ValueError as error:
+                        # Output that isn't all marshaled dicts is returned whole, as one raw entry,
+                        # without the dicts read before the error (they're in it). It's the output
+                        # already read: running p4 again would repeat a sync or submit. With -G, p4
+                        # reports its errors on stdout, so this is all it said.
                         dict_list.append({
                             "command": command,
                             "code": "raw",
-                            "raw_output": output.read(),
+                            "error": str(error),
+                            "raw_output": output,
                         })
-                    else:
-                        try:
-                            while True:
-                                value_dict = marshal.load(output)
-                                dict_list.append(value_dict)
-                        except EOFError:
-                            pass
-                        except ValueError as error:
-                            output_dict = {
-                                "command": command,
-                                "code": "raw",
-                                "error": str(error),
-                                "raw_output": subprocess.check_output(command, stderr=subprocess.STDOUT, shell=True, cwd=self.perforce_root)
-                            }
-                            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"]
@@ -390,18 +443,20 @@ class P4Client(object):
         if not self.host_online():
             raise p4errors.ServerOffline("Can't connect to %s on port %s" % (self.__server_address(), self.__port_number()))
 
-        template = subprocess.check_output(
+        template = _run_command(
             f'p4 -u {self.user} -c {self.client} --field "Files=" change -o',
+            self.perforce_root,
             stderr=subprocess.STDOUT,
-            shell=True).decode()
+            check=True).decode()
 
         modified = self.__replace_description_in_template(template, description)
 
-        output = subprocess.check_output(
+        output = _run_command(
             f"p4 -u {self.user} -c {self.client} change -i",
+            self.perforce_root,
             input=modified.encode(),
             stderr=subprocess.STDOUT,
-            shell=True).decode()
+            check=True).decode()
 
         parts = output.split(" ")
         if len(parts) < 2:
@@ -446,15 +501,18 @@ class P4Client(object):
         try:
             changelist = self.__ensure_changelist(changelist)
 
-            template = subprocess.check_output(
+            template = _run_command(
                 f'p4 -u {self.user} -c {self.client} change -o {changelist}',
-                shell=True).decode()
+                self.perforce_root,
+                check=True).decode()
 
             modified = self.__replace_description_in_template(template, new_description)
 
-            result = subprocess.check_output(
+            _run_command(
                 f'p4 -u {self.user} -c {self.client} change -i',
-                input=modified.encode(), shell=True).decode()
+                self.perforce_root,
+                input=modified.encode(),
+                check=True)
 
             return True
         except subprocess.CalledProcessError as e:

{p4cmd-2.11.2 → p4cmd-2.11.3}/p4cmd.egg-info/PKG-INFO

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

p4cmd-2.11.3/tests/conftest.py

@@ -0,0 +1,57 @@
+import subprocess
+
+import pytest
+from unittest.mock import MagicMock, patch
+
+from p4cmd.p4cmd import P4Client
+
+
+def make_fstat_dict(**kwargs):
+    """Build a bytes-keyed dict like P4's marshaled fstat output."""
+    return {k.encode(): v.encode() for k, v in kwargs.items()}
+
+
+def fake_p4_popen(mock_popen, output=b"", returncode=0):
+    """Make a patched subprocess.Popen act like p4 writing ``output`` (bytes) to its stdout, which
+    _run_command gives it as a file, and exiting with ``returncode``. A list of outputs gives one per
+    call. What each call got as stdin (subprocess.DEVNULL, or the bytes in its stdin file) is collected
+    in ``mock_popen.stdin_received``."""
+    outputs = list(output) if isinstance(output, list) else None
+    mock_popen.stdin_received = []
+
+    def popen(*args, **kwargs):
+        stdin = kwargs.get("stdin")
+        mock_popen.stdin_received.append(stdin if stdin is subprocess.DEVNULL else stdin.read())
+        kwargs["stdout"].write(outputs.pop(0) if outputs is not None else output)
+        process = MagicMock()
+        process.__enter__.return_value = process
+        process.__exit__.return_value = False
+        process.wait.return_value = returncode
+        process.returncode = returncode
+        return process
+
+    mock_popen.side_effect = popen
+    return mock_popen
+
+
+@pytest.fixture
+def p4client(tmp_path):
+    """
+    A P4Client with all server calls mocked out.
+    Passing explicit user/client/server skips the `p4 set` auto-detection calls.
+    Only get_depot_paths (called for depot_root) still hits run_cmd — mocked here.
+    """
+    (tmp_path / ".p4config").write_text("P4PORT=ssl:perforce.example.com:1666\n")
+    where_result = [
+        {b"depotFile": b"//depot/project/...", b"path": b"/fake/project/...", b"unmap": b""}
+    ]
+    with patch.object(P4Client, "host_online", return_value=True):
+        with patch.object(P4Client, "run_cmd", return_value=where_result):
+            client = P4Client(
+                str(tmp_path),
+                user="testuser",
+                client="testclient",
+                server="ssl:perforce.example.com:1666",
+            )
+    client.depot_root = "//depot/project"
+    return client

{p4cmd-2.11.2 → p4cmd-2.11.3}/tests/test_p4client.py

@@ -1,14 +1,18 @@
 """Tests for p4cmd/p4cmd.py — P4Client with run_cmd mocked."""
 import logging
 import socket
+import subprocess
+import sys
+import tempfile
+import time
 from unittest.mock import MagicMock, patch
 
 import pytest
 
-from p4cmd.p4cmd import P4Client
-from p4cmd.p4errors import P4CommandError
+from p4cmd.p4cmd import P4Client, _run_command
+from p4cmd.p4errors import P4CommandError, WorkSpaceError
 from p4cmd.p4file import P4File, Status
-from tests.conftest import make_fstat_dict
+from tests.conftest import fake_p4_popen, make_fstat_dict
 
 
 # ---------------------------------------------------------------------------
@@ -526,12 +530,7 @@ def test_run_cmd_no_chdir(p4client):
          patch("p4cmd.p4cmd.subprocess.Popen") as mock_popen, \
          patch.object(p4client, "host_online", return_value=True):
         # Simulate an empty marshal stream (EOF immediately)
-        import io
-        mock_pipe = MagicMock()
-        mock_pipe.stdout = io.BytesIO(b"")
-        mock_pipe.__enter__ = lambda s: s
-        mock_pipe.__exit__ = MagicMock(return_value=False)
-        mock_popen.return_value = mock_pipe
+        fake_p4_popen(mock_popen)
 
         p4client.run_cmd("changes", args=[], online_check=False)
 
@@ -539,6 +538,29 @@ def test_run_cmd_no_chdir(p4client):
         # cwd should have been passed to Popen
         _, kwargs = mock_popen.call_args
         assert kwargs.get("cwd") == p4client.perforce_root
+        assert kwargs["stdin"] is subprocess.DEVNULL
+
+
+def test_run_command_does_not_wait_for_processes_holding_its_output():
+    """
+    A process that outlives the command and holds its output (here one the command leaves running;
+    in practice one that inherited it when something else started it at the same moment) doesn't
+    keep _run_command waiting. Read from a pipe until it closes, this took the 3 s of that process.
+    """
+    if sys.platform == "win32":
+        command = "echo hi& start /b ping -n 4 127.0.0.1 > NUL"
+    else:
+        command = "echo hi; sleep 3 &"
+    start = time.perf_counter()
+    output = _run_command(command, tempfile.gettempdir())
+    assert output.strip() == b"hi"
+    assert time.perf_counter() - start < 2.0
+
+
+def test_run_command_gives_the_command_its_input():
+    """input reaches the command as its stdin (the form for `p4 change -i`), and its output comes back."""
+    command = f'"{sys.executable}" -c "import sys; sys.stdout.buffer.write(sys.stdin.buffer.read().upper())"'
+    assert _run_command(command, tempfile.gettempdir(), input=b"change form\n") == b"CHANGE FORM\n"
 
 
 def test_get_p4_setting_malformed_output(p4client):
@@ -552,8 +574,9 @@ def test_get_p4_setting_malformed_output(p4client):
 def test_make_new_changelist_malformed_output(p4client):
     """make_new_changelist returns None instead of crashing on unexpected p4 output."""
     template = b"Change: new\n\nDescription:\n\t<enter description here>\n\nFiles:\n"
-    with patch("p4cmd.p4cmd.subprocess.check_output", side_effect=[template, b"Unexpected output\n"]), \
+    with patch("p4cmd.p4cmd.subprocess.Popen") as mock_popen, \
          patch.object(p4client, "host_online", return_value=True):
+        fake_p4_popen(mock_popen, [template, b"Unexpected output\n"])
         result = p4client.make_new_changelist("test description")
     assert result is None
 
@@ -561,16 +584,56 @@ def test_make_new_changelist_malformed_output(p4client):
 def test_make_new_changelist_preserves_newlines(p4client):
     """make_new_changelist correctly handles descriptions containing newlines."""
     template = b"Change: new\n\nDescription:\n\t<enter description here>\n\nFiles:\n"
-    with patch("p4cmd.p4cmd.subprocess.check_output", side_effect=[template, b"Change 12345 created.\n"]) as mock_co, \
+    with patch("p4cmd.p4cmd.subprocess.Popen") as mock_popen, \
          patch.object(p4client, "host_online", return_value=True):
+        fake_p4_popen(mock_popen, [template, b"Change 12345 created.\n"])
         result = p4client.make_new_changelist("Line one.\nLine two.")
 
     assert result == 12345
     # Verify the description sent to p4 change -i has tab-indented lines
-    submitted = mock_co.call_args_list[1]
-    input_data = submitted[1]["input"].decode()
+    change_o_stdin, change_i_stdin = mock_popen.stdin_received
+    assert change_o_stdin is subprocess.DEVNULL
+    input_data = change_i_stdin.decode()
     assert "\tLine one." in input_data
     assert "\tLine two." in input_data
+    # In the workspace root, like run_cmd, so both use its .p4config
+    assert all(call.kwargs["cwd"] == p4client.perforce_root for call in mock_popen.call_args_list)
+
+
+def test_make_new_changelist_raises_when_p4_fails(p4client):
+    """A failing p4 raises CalledProcessError with what p4 said, and no form is sent to `change -i`."""
+    with patch("p4cmd.p4cmd.subprocess.Popen") as mock_popen, \
+         patch.object(p4client, "host_online", return_value=True):
+        fake_p4_popen(mock_popen, b"Perforce password (P4PASSWD) invalid or unset.\n", returncode=1)
+        with pytest.raises(subprocess.CalledProcessError) as error:
+            p4client.make_new_changelist("test description")
+    assert b"P4PASSWD" in error.value.output
+    assert mock_popen.call_count == 1
+
+
+def test_update_changelist_description_sends_the_new_description(p4client):
+    """The changelist's form goes back to `change -i` with the new description in place of the old."""
+    template = (b"Change: 12345\n\nClient: testclient\n\nUser: testuser\n\nStatus: pending\n\n"
+                b"Description:\n\tOld description\n\nFiles:\n")
+    with patch("p4cmd.p4cmd.subprocess.Popen") as mock_popen:
+        fake_p4_popen(mock_popen, [template, b"Change 12345 updated.\n"])
+        result = p4client.update_changelist_description(12345, "New description")
+
+    assert result is True
+    change_o_stdin, change_i_stdin = mock_popen.stdin_received
+    assert change_o_stdin is subprocess.DEVNULL
+    assert "\tNew description" in change_i_stdin.decode()
+    assert "Old description" not in change_i_stdin.decode()
+
+
+def test_update_changelist_description_returns_false_when_p4_fails(p4client, caplog):
+    """A failing p4 is logged and gives False."""
+    with patch("p4cmd.p4cmd.subprocess.Popen") as mock_popen:
+        fake_p4_popen(mock_popen, b"", returncode=1)
+        with caplog.at_level(logging.ERROR):
+            result = p4client.update_changelist_description(12345, "New description")
+    assert result is False
+    assert "Failed to update changelist description" in caplog.text
 
 
 def test_get_pending_changelists_none_desc(p4client):
@@ -606,11 +669,7 @@ def test_run_cmd_logs_warning_on_error_dicts(p4client, caplog):
         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()
+        fake_p4_popen(mock_popen, buf.getvalue())
         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
@@ -624,11 +683,7 @@ def test_run_cmd_raise_on_errors(p4client):
         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()
+        fake_p4_popen(mock_popen, buf.getvalue())
         with pytest.raises(P4CommandError, match="file\\(s\\) not on client"):
             p4client.run_cmd("sync", file_list=["//depot/file.txt"], raise_on_errors=True)
 
@@ -640,11 +695,7 @@ def test_run_cmd_no_raise_without_errors(p4client):
         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()
+        fake_p4_popen(mock_popen, buf.getvalue())
         result = p4client.run_cmd("sync", file_list=["//depot/file.txt"], raise_on_errors=True)
     assert result == [ok_dict]
 
@@ -657,25 +708,35 @@ def test_run_cmd_handles_string_key_error_dicts(p4client, caplog):
         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()
+        fake_p4_popen(mock_popen, buf.getvalue())
         with caplog.at_level(logging.WARNING):
             p4client.run_cmd("sync", file_list=["//depot/file.txt"])
     assert "some error" in caplog.text
 
 
+def test_run_cmd_value_error_returns_the_output_once(p4client):
+    """
+    Output that isn't all marshaled dicts gives one raw entry with all of it, without the dicts
+    read before the error, and p4 isn't run again (that would repeat a sync or submit).
+    """
+    import marshal as _m
+    output = _m.dumps({b"code": b"stat", b"depotFile": b"//depot/file.txt"}) + b"not marshal data\n"
+    with patch("subprocess.Popen") as mock_popen, \
+         patch("p4cmd.p4cmd.subprocess.check_output") as mock_check_output:
+        fake_p4_popen(mock_popen, output)
+        result = p4client.run_cmd("sync", file_list=["//depot/file.txt"], online_check=False)
+
+    assert len(result) == 1
+    assert result[0]["code"] == "raw"
+    assert result[0]["raw_output"] == output
+    assert mock_popen.call_count == 1
+    mock_check_output.assert_not_called()
+
+
 def test_run_cmd_value_error_fallback_no_warning(p4client, caplog):
     """The marshal_output=False path (e.g. `p4 set`) must not log spurious error warnings."""
     with patch("subprocess.Popen") as mock_popen:
-        import io as _io
-        buf = _io.BytesIO(b"P4USER=niels.vaes (set)\n")
-        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()
+        fake_p4_popen(mock_popen, b"P4USER=niels.vaes (set)\n")
         with caplog.at_level(logging.WARNING):
             result = p4client.get_p4_setting("P4USER")
     assert result == "niels.vaes"
@@ -688,17 +749,13 @@ def test_run_cmd_no_global_options_does_not_spawn_second_subprocess(p4client):
     p4 outputs plain text — marshal.load is guaranteed to fail. The old fallback
     spawned a second subprocess via check_output without pinning stdin, which
     triggered OSError(WinError 50) on DuplicateHandle in non-interactive sessions
-    (UE commandlets, scheduled tasks, CI). The fix reads stdout directly from the
-    already-open Popen, which has stdin=PIPE.
+    (UE commandlets, scheduled tasks, CI). The fix uses the output of the one
+    subprocess, whose stdin is NUL.
     """
-    import io as _io
     p4_set_output = b"P4USER=niels.vaes (set)\r\n"
     with patch("subprocess.Popen") as mock_popen, \
          patch("p4cmd.p4cmd.subprocess.check_output") as mock_check_output:
-        mock_popen.return_value.__enter__ = lambda s: s
-        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
-        mock_popen.return_value.stdout = _io.BytesIO(p4_set_output)
-        mock_popen.return_value.kill = MagicMock()
+        fake_p4_popen(mock_popen, p4_set_output)
 
         result = p4client.get_p4_setting("P4USER")
 
@@ -708,13 +765,9 @@ def test_run_cmd_no_global_options_does_not_spawn_second_subprocess(p4client):
 
 def test_run_cmd_use_global_options_deprecation_alias(p4client):
     """The old `use_global_options` kwarg is accepted but emits DeprecationWarning."""
-    import io as _io
     import warnings as _warnings
     with patch("subprocess.Popen") as mock_popen:
-        mock_popen.return_value.__enter__ = lambda s: s
-        mock_popen.return_value.__exit__ = MagicMock(return_value=False)
-        mock_popen.return_value.stdout = _io.BytesIO(b"P4USER=niels.vaes (set)\n")
-        mock_popen.return_value.kill = MagicMock()
+        fake_p4_popen(mock_popen, b"P4USER=niels.vaes (set)\n")
 
         with _warnings.catch_warnings(record=True) as caught:
             _warnings.simplefilter("always")
@@ -827,3 +880,45 @@ def test_sync_files_warns_when_file_missing_unexpectedly(p4client, caplog):
                 with caplog.at_level("WARNING", logger="p4cmd.p4cmd"):
                     p4client.sync_files([path])
     assert "didn't exist after syncing" in caplog.text
+
+
+# ---------------------------------------------------------------------------
+# __init__ depot-root resolution
+# ---------------------------------------------------------------------------
+
+def test_init_raises_workspace_error_when_depot_root_unresolvable(tmp_path):
+    """An unresolvable depot root must raise WorkSpaceError, not IndexError.
+
+    ``p4 where`` returns nothing when the client is not authenticated
+    (expired ticket), so ``get_depot_paths(...)[0]`` blew up with a bare
+    ``IndexError: list index out of range``. Callers that retry the
+    constructor to recover a dropped connection then log that meaningless
+    message instead of "you need to log in", and cannot distinguish an
+    auth failure from a real bug.
+    """
+    (tmp_path / ".p4config").write_text("P4PORT=ssl:perforce.example.com:1666\n")
+    with patch.object(P4Client, "host_online", return_value=True):
+        with patch.object(P4Client, "run_cmd", return_value=[]):
+            with pytest.raises(WorkSpaceError):
+                P4Client(
+                    str(tmp_path),
+                    user="testuser",
+                    client="testclient",
+                    server="ssl:perforce.example.com:1666",
+                )
+
+
+def test_init_error_message_mentions_login(tmp_path):
+    """The raised message must point at the likely cause (auth/reachability)."""
+    (tmp_path / ".p4config").write_text("P4PORT=ssl:perforce.example.com:1666\n")
+    with patch.object(P4Client, "host_online", return_value=True):
+        with patch.object(P4Client, "run_cmd", return_value=[]):
+            with pytest.raises(WorkSpaceError) as excinfo:
+                P4Client(
+                    str(tmp_path),
+                    user="testuser",
+                    client="testclient",
+                    server="ssl:perforce.example.com:1666",
+                )
+    message = str(excinfo.value).lower()
+    assert "login" in message or "ticket" in message

p4cmd-2.11.2/tests/conftest.py

@@ -1,32 +0,0 @@
-import pytest
-from unittest.mock import patch
-
-from p4cmd.p4cmd import P4Client
-
-
-def make_fstat_dict(**kwargs):
-    """Build a bytes-keyed dict like P4's marshaled fstat output."""
-    return {k.encode(): v.encode() for k, v in kwargs.items()}
-
-
-@pytest.fixture
-def p4client(tmp_path):
-    """
-    A P4Client with all server calls mocked out.
-    Passing explicit user/client/server skips the `p4 set` auto-detection calls.
-    Only get_depot_paths (called for depot_root) still hits run_cmd — mocked here.
-    """
-    (tmp_path / ".p4config").write_text("P4PORT=ssl:perforce.example.com:1666\n")
-    where_result = [
-        {b"depotFile": b"//depot/project/...", b"path": b"/fake/project/...", b"unmap": b""}
-    ]
-    with patch.object(P4Client, "host_online", return_value=True):
-        with patch.object(P4Client, "run_cmd", return_value=where_result):
-            client = P4Client(
-                str(tmp_path),
-                user="testuser",
-                client="testclient",
-                server="ssl:perforce.example.com:1666",
-            )
-    client.depot_root = "//depot/project"
-    return client