devservices 1.1.0__tar.gz → 1.1.1__tar.gz

{devservices-1.1.0 → devservices-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devservices
-Version: 1.1.0
+Version: 1.1.1
 Requires-Python: >=3.10
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.1.0 → devservices-1.1.1}/README.md

@@ -22,6 +22,7 @@ NOTE: service-name is an optional parameter. If not provided, devservices will a
 - `devservices list-dependencies <service-name>`: List all dependencies for a service and whether they are enabled/disabled.
 - `devservices update` Update devservices to the latest version.
 - `devservices purge`: Purge the local devservices cache.
+- `devservices toggle <service-name>`: Toggle the runtime for a service between containerized and local.
 
 ## Installation
 
@@ -30,7 +31,7 @@ NOTE: service-name is an optional parameter. If not provided, devservices will a
 The recommended way to install devservices is through a virtualenv in the requirements.txt. Once that is installed and a devservices config file is added, you should be able to run `devservices up` to begin local development.
 
 ```
-devservices==1.1.0
+devservices==1.1.1
 ```
 
 ### 2. Add devservices config files

{devservices-1.1.0 → devservices-1.1.1}/devservices/constants.py

@@ -39,7 +39,14 @@ DEPENDENCY_GIT_PARTIAL_CLONE_CONFIG_OPTIONS = {
 DEVSERVICES_RELEASES_URL = (
     "https://api.github.com/repos/getsentry/devservices/releases/latest"
 )
-DOCKER_COMPOSE_DOWNLOAD_URL = "https://github.com/docker/compose/releases/download"
+
+# We mirror this in our GCP bucket since GitHub downloads can be flaky at times.
+# gsutil cp docker-compose-darwin-aarch64 gs://sentry-dev-infra-assets/docker-compose/v2.29.7/docker-compose-darwin-aarch64
+# gsutil cp docker-compose-linux-x86_64 gs://sentry-dev-infra-assets/docker-compose/v2.29.7/docker-compose-linux-x86_64
+DOCKER_COMPOSE_DOWNLOAD_URL = (
+    "https://storage.googleapis.com/sentry-dev-infra-assets/docker-compose"
+)
+
 DEVSERVICES_DOWNLOAD_URL = "https://github.com/getsentry/devservices/releases/download"
 BINARY_PERMISSIONS = 0o755
 MAX_LOG_LINES = "100"

{devservices-1.1.0 → devservices-1.1.1}/devservices/utils/supervisor.py

@@ -6,12 +6,31 @@ import os
 import socket
 import subprocess
 import xmlrpc.client
+from enum import IntEnum
 
 from devservices.constants import DEVSERVICES_SUPERVISOR_CONFIG_DIR
 from devservices.exceptions import SupervisorConfigError
 from devservices.exceptions import SupervisorConnectionError
 from devservices.exceptions import SupervisorError
 from devservices.exceptions import SupervisorProcessError
+from devservices.utils.console import Console
+
+
+class SupervisorProcessState(IntEnum):
+    """
+    Supervisor process states.
+
+    https://supervisord.org/subprocess.html#process-states
+    """
+
+    STOPPED = 0
+    STARTING = 10
+    RUNNING = 20
+    BACKOFF = 30
+    STOPPING = 40
+    EXITED = 100
+    FATAL = 200
+    UNKNOWN = 1000
 
 
 class UnixSocketHTTPConnection(http.client.HTTPConnection):
@@ -101,6 +120,21 @@ class SupervisorManager:
                 f"Failed to connect to supervisor XML-RPC server: {e.errmsg}"
             )
 
+    def _is_program_running(self, program_name: str) -> bool:
+        try:
+            client = self._get_rpc_client()
+            process_info = client.supervisor.getProcessInfo(program_name)
+            if not isinstance(process_info, dict):
+                return False
+
+            state = process_info.get("state")
+            if not isinstance(state, int):
+                return False
+            return state == SupervisorProcessState.RUNNING
+        except xmlrpc.client.Fault:
+            # If we can't get the process info, assume it's not running
+            return False
+
     def start_supervisor_daemon(self) -> None:
         try:
             subprocess.run(["supervisord", "-c", self.config_file_path], check=True)
@@ -118,6 +152,8 @@ class SupervisorManager:
             raise SupervisorError(f"Failed to stop supervisor: {e.faultString}")
 
     def start_program(self, program_name: str) -> None:
+        if self._is_program_running(program_name):
+            return
         try:
             self._get_rpc_client().supervisor.startProcess(program_name)
         except xmlrpc.client.Fault as e:
@@ -126,9 +162,35 @@ class SupervisorManager:
             )
 
     def stop_program(self, program_name: str) -> None:
+        if not self._is_program_running(program_name):
+            return
         try:
             self._get_rpc_client().supervisor.stopProcess(program_name)
         except xmlrpc.client.Fault as e:
             raise SupervisorProcessError(
                 f"Failed to stop program {program_name}: {e.faultString}"
             )
+
+    def tail_program_logs(self, program_name: str) -> None:
+        if not self._is_program_running(program_name):
+            console = Console()
+            console.failure(f"Program {program_name} is not running")
+            return
+
+        try:
+            # Use supervisorctl tail command
+            subprocess.run(
+                [
+                    "supervisorctl",
+                    "-c",
+                    self.config_file_path,
+                    "tail",
+                    "-f",
+                    program_name,
+                ],
+                check=True,
+            )
+        except subprocess.CalledProcessError as e:
+            raise SupervisorError(f"Failed to tail logs for {program_name}: {str(e)}")
+        except KeyboardInterrupt:
+            pass

{devservices-1.1.0 → devservices-1.1.1}/devservices.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devservices
-Version: 1.1.0
+Version: 1.1.1
 Requires-Python: >=3.10
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.1.0 → devservices-1.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devservices"
-version = "1.1.0"
+version = "1.1.1"
 # 3.10 is just for internal pypi compat
 requires-python = ">=3.10"
 dependencies = [

{devservices-1.1.0 → devservices-1.1.1}/tests/utils/test_docker_compose.py

@@ -216,7 +216,7 @@ def test_install_docker_compose_macos_arm64(
     mock_tempdir.return_value.__enter__.return_value = "tempdir"
     install_docker_compose()
     mock_urlretrieve.assert_called_once_with(
-        "https://github.com/docker/compose/releases/download/v2.29.7/docker-compose-darwin-aarch64",
+        "https://storage.googleapis.com/sentry-dev-infra-assets/docker-compose/v2.29.7/docker-compose-darwin-aarch64",
         "tempdir/docker-compose",
     )
     mock_chmod.assert_called_once_with("tempdir/docker-compose", 0o755)
@@ -249,7 +249,7 @@ def test_install_docker_compose_linux_x86(
     mock_tempdir.return_value.__enter__.return_value = "tempdir"
     install_docker_compose()
     mock_urlretrieve.assert_called_once_with(
-        "https://github.com/docker/compose/releases/download/v2.29.7/docker-compose-linux-x86_64",
+        "https://storage.googleapis.com/sentry-dev-infra-assets/docker-compose/v2.29.7/docker-compose-linux-x86_64",
         "tempdir/docker-compose",
     )
     mock_chmod.assert_called_once_with("tempdir/docker-compose", 0o755)
@@ -286,7 +286,7 @@ def test_install_docker_compose_custom_docker_config_dir(
     ):
         install_docker_compose()
     mock_urlretrieve.assert_called_once_with(
-        "https://github.com/docker/compose/releases/download/v2.29.7/docker-compose-darwin-aarch64",
+        "https://storage.googleapis.com/sentry-dev-infra-assets/docker-compose/v2.29.7/docker-compose-darwin-aarch64",
         "tempdir/docker-compose",
     )
     mock_chmod.assert_called_once_with("tempdir/docker-compose", 0o755)

devservices-1.1.1/tests/utils/test_supervisor.py

@@ -0,0 +1,388 @@
+from __future__ import annotations
+
+import socket
+import subprocess
+import xmlrpc.client
+from pathlib import Path
+from unittest import mock
+
+import pytest
+
+from devservices.constants import DEVSERVICES_DIR_NAME
+from devservices.exceptions import SupervisorConfigError
+from devservices.exceptions import SupervisorConnectionError
+from devservices.exceptions import SupervisorError
+from devservices.exceptions import SupervisorProcessError
+from devservices.utils.supervisor import SupervisorManager
+from devservices.utils.supervisor import SupervisorProcessState
+from devservices.utils.supervisor import UnixSocketHTTPConnection
+from devservices.utils.supervisor import UnixSocketTransport
+
+
+@mock.patch("socket.socket")
+def test_unix_socket_http_connection_connect(
+    mock_socket: mock.MagicMock, tmp_path: Path
+) -> None:
+    socket_path = str(tmp_path / "test.sock")
+    mock_sock = mock_socket.return_value
+
+    conn = UnixSocketHTTPConnection(socket_path)
+    conn.connect()
+
+    mock_socket.assert_called_once_with(socket.AF_UNIX, socket.SOCK_STREAM)
+    mock_sock.connect.assert_called_once_with(socket_path)
+    assert conn.sock == mock_sock
+
+
+@mock.patch("socket.socket")
+def test_unix_socket_transport_make_connection(
+    mock_socket: mock.MagicMock, tmp_path: Path
+) -> None:
+    """
+    Test that the Unix socket transport correctly attempts to connect to the socket.
+    """
+    socket_path = str(tmp_path / "test.sock")
+    mock_sock = mock_socket.return_value
+
+    transport = UnixSocketTransport(socket_path)
+
+    connection = transport.make_connection("localhost")
+
+    # Connect the socket - this happens when we make an RPC call
+    connection.connect()
+
+    # Verify socket creation with correct family and type
+    mock_socket.assert_called_with(socket.AF_UNIX, socket.SOCK_STREAM)
+    # Verify connection to the right path
+    mock_sock.connect.assert_called_with(socket_path)
+
+
+@pytest.fixture
+def supervisor_manager(tmp_path: Path) -> SupervisorManager:
+    with mock.patch(
+        "devservices.utils.supervisor.DEVSERVICES_SUPERVISOR_CONFIG_DIR", tmp_path
+    ):
+        config_file_path = tmp_path / DEVSERVICES_DIR_NAME / "processes.conf"
+        config_file_path.parent.mkdir(parents=True, exist_ok=True)
+        config_file_path.write_text(
+            """
+    [program:test_program]
+    command = python test_program.py
+    """
+        )
+        return SupervisorManager(
+            config_file_path=str(config_file_path), service_name="test-service"
+        )
+
+
+def test_init_with_config_file(supervisor_manager: SupervisorManager) -> None:
+    assert supervisor_manager.service_name == "test-service"
+    assert "test-service.processes.conf" in supervisor_manager.config_file_path
+
+
+def test_init_with_nonexistent_config() -> None:
+    with pytest.raises(SupervisorConfigError):
+        SupervisorManager(
+            config_file_path="/nonexistent/path.conf", service_name="test-service"
+        )
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_get_rpc_client_success(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.return_value = mock.MagicMock()
+    client = supervisor_manager._get_rpc_client()
+    assert client is not None
+    mock_rpc_client.assert_called_once()
+    transport_arg = mock_rpc_client.call_args[1]["transport"]
+    assert isinstance(transport_arg, UnixSocketTransport)
+    assert transport_arg.socket_path == supervisor_manager.socket_path
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_get_rpc_client_failure(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.side_effect = xmlrpc.client.Fault(1, "Error")
+    with pytest.raises(SupervisorConnectionError):
+        supervisor_manager._get_rpc_client()
+    mock_rpc_client.assert_called_once()
+    transport_arg = mock_rpc_client.call_args[1]["transport"]
+    assert isinstance(transport_arg, UnixSocketTransport)
+    assert transport_arg.socket_path == supervisor_manager.socket_path
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_is_program_running_success(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.RUNNING
+    }
+    assert supervisor_manager._is_program_running("test_program")
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_is_program_running_program_not_running(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.STOPPED
+    }
+    assert not supervisor_manager._is_program_running("test_program")
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_is_program_running_typing_error(
+    mock_rpc_client: mock.MagicMock,
+    supervisor_manager: SupervisorManager,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = 1
+    assert not supervisor_manager._is_program_running("test_program")
+    mock_rpc_client.return_value.supervisor.getProcessInfo.side_effect = {
+        "state": [SupervisorProcessState.STOPPED]
+    }
+    assert not supervisor_manager._is_program_running("test_program")
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_is_program_running_failure(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.side_effect = (
+        xmlrpc.client.Fault(1, "Error")
+    )
+    assert not supervisor_manager._is_program_running("test_program")
+
+
+@mock.patch("devservices.utils.supervisor.subprocess.run")
+def test_start_supervisor_daemon_success(
+    mock_subprocess_run: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    supervisor_manager.start_supervisor_daemon()
+    mock_subprocess_run.assert_called_once_with(
+        ["supervisord", "-c", supervisor_manager.config_file_path], check=True
+    )
+
+
+@mock.patch("devservices.utils.supervisor.subprocess.run")
+def test_start_supervisor_daemon_subprocess_failure(
+    mock_subprocess_run: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_subprocess_run.side_effect = subprocess.CalledProcessError(1, "supervisord")
+    with pytest.raises(SupervisorError):
+        supervisor_manager.start_supervisor_daemon()
+
+
+@mock.patch("devservices.utils.supervisor.subprocess.run")
+def test_start_supervisor_daemon_file_not_found_failure(
+    mock_subprocess_run: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_subprocess_run.side_effect = FileNotFoundError("supervisord")
+    with pytest.raises(SupervisorError):
+        supervisor_manager.start_supervisor_daemon()
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_stop_supervisor_daemon_success(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    supervisor_manager.stop_supervisor_daemon()
+    supervisor_manager._get_rpc_client().supervisor.shutdown.assert_called_once()
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_stop_supervisor_daemon_failure(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.return_value.supervisor.shutdown.side_effect = xmlrpc.client.Fault(
+        1, "Error"
+    )
+    with pytest.raises(SupervisorError):
+        supervisor_manager.stop_supervisor_daemon()
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_start_program_success(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.STOPPED
+    }
+    supervisor_manager.start_program("test_program")
+    supervisor_manager._get_rpc_client().supervisor.startProcess.assert_called_once_with(
+        "test_program"
+    )
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_start_program_failure(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.STOPPED
+    }
+    mock_rpc_client.return_value.supervisor.startProcess.side_effect = (
+        xmlrpc.client.Fault(1, "Error")
+    )
+    with pytest.raises(SupervisorProcessError):
+        supervisor_manager.start_program("test_program")
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_start_program_already_running(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.RUNNING
+    }
+    supervisor_manager.start_program("test_program")
+    mock_rpc_client.supervisor.startProcess.assert_not_called()
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_stop_program_success(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.RUNNING
+    }
+    supervisor_manager.stop_program("test_program")
+    supervisor_manager._get_rpc_client().supervisor.stopProcess.assert_called_once_with(
+        "test_program"
+    )
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_stop_program_failure(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.RUNNING
+    }
+    mock_rpc_client.return_value.supervisor.stopProcess.side_effect = (
+        xmlrpc.client.Fault(1, "Error")
+    )
+    with pytest.raises(SupervisorProcessError):
+        supervisor_manager.stop_program("test_program")
+
+
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_stop_program_not_running(
+    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.STOPPED
+    }
+    supervisor_manager.stop_program("test_program")
+    mock_rpc_client.supervisor.stopProcess.assert_not_called()
+
+
+def test_extend_config_file(
+    supervisor_manager: SupervisorManager, tmp_path: Path
+) -> None:
+    assert supervisor_manager.config_file_path == str(
+        tmp_path / "test-service.processes.conf"
+    )
+    with open(supervisor_manager.config_file_path, "r") as f:
+        assert (
+            f.read()
+            == f"""[program:test_program]
+command = python test_program.py
+
+[unix_http_server]
+file = {tmp_path}/test-service.sock
+
+[supervisord]
+pidfile = {tmp_path}/test-service.pid
+
+[supervisorctl]
+serverurl = unix://{tmp_path}/test-service.sock
+
+[rpcinterface:supervisor]
+supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
+
+"""
+        )
+
+
+@mock.patch("devservices.utils.supervisor.subprocess.run")
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def tail_program_logs_success(
+    mock_rpc_client: mock.MagicMock,
+    mock_subprocess_run: mock.MagicMock,
+    supervisor_manager: SupervisorManager,
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.RUNNING
+    }
+    supervisor_manager.tail_program_logs("test_program")
+    mock_subprocess_run.assert_called_once_with(
+        [
+            "supervisorctl",
+            "-c",
+            supervisor_manager.config_file_path,
+            "fg",
+            "test_program",
+        ],
+        check=True,
+    )
+
+
+@mock.patch("devservices.utils.supervisor.subprocess.run")
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_tail_program_logs_not_running(
+    mock_rpc_client: mock.MagicMock,
+    mock_subprocess_run: mock.MagicMock,
+    supervisor_manager: SupervisorManager,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.STOPPED
+    }
+    supervisor_manager.tail_program_logs("test_program")
+    captured = capsys.readouterr()
+    assert "Program test_program is not running" in captured.out
+    mock_subprocess_run.assert_not_called()
+
+
+@mock.patch("devservices.utils.supervisor.subprocess.run")
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_tail_program_logs_failure(
+    mock_rpc_client: mock.MagicMock,
+    mock_subprocess_run: mock.MagicMock,
+    supervisor_manager: SupervisorManager,
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.RUNNING
+    }
+    mock_subprocess_run.side_effect = subprocess.CalledProcessError(1, "supervisorctl")
+    with pytest.raises(SupervisorError, match="Failed to tail logs for test_program"):
+        supervisor_manager.tail_program_logs("test_program")
+
+
+@mock.patch("devservices.utils.supervisor.subprocess.run")
+@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
+def test_tail_program_logs_keyboard_interrupt(
+    mock_rpc_client: mock.MagicMock,
+    mock_subprocess_run: mock.MagicMock,
+    supervisor_manager: SupervisorManager,
+) -> None:
+    mock_rpc_client.return_value.supervisor.getProcessInfo.return_value = {
+        "state": SupervisorProcessState.RUNNING
+    }
+    mock_subprocess_run.side_effect = KeyboardInterrupt()
+    supervisor_manager.tail_program_logs("test_program")
+    mock_subprocess_run.assert_called_once_with(
+        [
+            "supervisorctl",
+            "-c",
+            supervisor_manager.config_file_path,
+            "tail",
+            "-f",
+            "test_program",
+        ],
+        check=True,
+    )

devservices-1.1.0/tests/utils/test_supervisor.py

@@ -1,189 +0,0 @@
-from __future__ import annotations
-
-import subprocess
-import xmlrpc.client
-from pathlib import Path
-from unittest import mock
-
-import pytest
-
-from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.exceptions import SupervisorConfigError
-from devservices.exceptions import SupervisorConnectionError
-from devservices.exceptions import SupervisorError
-from devservices.exceptions import SupervisorProcessError
-from devservices.utils.supervisor import SupervisorManager
-from devservices.utils.supervisor import UnixSocketTransport
-
-
-@pytest.fixture
-def supervisor_manager(tmp_path: Path) -> SupervisorManager:
-    with mock.patch(
-        "devservices.utils.supervisor.DEVSERVICES_SUPERVISOR_CONFIG_DIR", tmp_path
-    ):
-        config_file_path = tmp_path / DEVSERVICES_DIR_NAME / "processes.conf"
-        config_file_path.parent.mkdir(parents=True, exist_ok=True)
-        config_file_path.write_text(
-            """
-    [program:test_program]
-    command = python test_program.py
-    """
-        )
-        return SupervisorManager(
-            config_file_path=str(config_file_path), service_name="test-service"
-        )
-
-
-def test_init_with_config_file(supervisor_manager: SupervisorManager) -> None:
-    assert supervisor_manager.service_name == "test-service"
-    assert "test-service.processes.conf" in supervisor_manager.config_file_path
-
-
-def test_init_with_nonexistent_config() -> None:
-    with pytest.raises(SupervisorConfigError):
-        SupervisorManager(
-            config_file_path="/nonexistent/path.conf", service_name="test-service"
-        )
-
-
-@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
-def test_get_rpc_client_success(
-    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
-) -> None:
-    mock_rpc_client.return_value = mock.MagicMock()
-    client = supervisor_manager._get_rpc_client()
-    assert client is not None
-    mock_rpc_client.assert_called_once()
-    transport_arg = mock_rpc_client.call_args[1]["transport"]
-    assert isinstance(transport_arg, UnixSocketTransport)
-    assert transport_arg.socket_path == supervisor_manager.socket_path
-
-
-@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
-def test_get_rpc_client_failure(
-    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
-) -> None:
-    mock_rpc_client.side_effect = xmlrpc.client.Fault(1, "Error")
-    with pytest.raises(SupervisorConnectionError):
-        supervisor_manager._get_rpc_client()
-    mock_rpc_client.assert_called_once()
-    transport_arg = mock_rpc_client.call_args[1]["transport"]
-    assert isinstance(transport_arg, UnixSocketTransport)
-    assert transport_arg.socket_path == supervisor_manager.socket_path
-
-
-@mock.patch("devservices.utils.supervisor.subprocess.run")
-def test_start_supervisor_daemon_success(
-    mock_subprocess_run: mock.MagicMock, supervisor_manager: SupervisorManager
-) -> None:
-    supervisor_manager.start_supervisor_daemon()
-    mock_subprocess_run.assert_called_once_with(
-        ["supervisord", "-c", supervisor_manager.config_file_path], check=True
-    )
-
-
-@mock.patch("devservices.utils.supervisor.subprocess.run")
-def test_start_supervisor_daemon_subprocess_failure(
-    mock_subprocess_run: mock.MagicMock, supervisor_manager: SupervisorManager
-) -> None:
-    mock_subprocess_run.side_effect = subprocess.CalledProcessError(1, "supervisord")
-    with pytest.raises(SupervisorError):
-        supervisor_manager.start_supervisor_daemon()
-
-
-@mock.patch("devservices.utils.supervisor.subprocess.run")
-def test_start_supervisor_daemon_file_not_found_failure(
-    mock_subprocess_run: mock.MagicMock, supervisor_manager: SupervisorManager
-) -> None:
-    mock_subprocess_run.side_effect = FileNotFoundError("supervisord")
-    with pytest.raises(SupervisorError):
-        supervisor_manager.start_supervisor_daemon()
-
-
-@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
-def test_stop_supervisor_daemon_success(
-    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
-) -> None:
-    supervisor_manager.stop_supervisor_daemon()
-    supervisor_manager._get_rpc_client().supervisor.shutdown.assert_called_once()
-
-
-@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
-def test_stop_supervisor_daemon_failure(
-    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
-) -> None:
-    mock_rpc_client.return_value.supervisor.shutdown.side_effect = xmlrpc.client.Fault(
-        1, "Error"
-    )
-    with pytest.raises(SupervisorError):
-        supervisor_manager.stop_supervisor_daemon()
-
-
-@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
-def test_start_program_success(
-    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
-) -> None:
-    supervisor_manager.start_program("test_program")
-    supervisor_manager._get_rpc_client().supervisor.startProcess.assert_called_once_with(
-        "test_program"
-    )
-
-
-@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
-def test_start_program_failure(
-    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
-) -> None:
-    mock_rpc_client.return_value.supervisor.startProcess.side_effect = (
-        xmlrpc.client.Fault(1, "Error")
-    )
-    with pytest.raises(SupervisorProcessError):
-        supervisor_manager.start_program("test_program")
-
-
-@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
-def test_stop_program_success(
-    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
-) -> None:
-    supervisor_manager.stop_program("test_program")
-    supervisor_manager._get_rpc_client().supervisor.stopProcess.assert_called_once_with(
-        "test_program"
-    )
-
-
-@mock.patch("devservices.utils.supervisor.xmlrpc.client.ServerProxy")
-def test_stop_program_failure(
-    mock_rpc_client: mock.MagicMock, supervisor_manager: SupervisorManager
-) -> None:
-    mock_rpc_client.return_value.supervisor.stopProcess.side_effect = (
-        xmlrpc.client.Fault(1, "Error")
-    )
-    with pytest.raises(SupervisorProcessError):
-        supervisor_manager.stop_program("test_program")
-
-
-def test_extend_config_file(
-    supervisor_manager: SupervisorManager, tmp_path: Path
-) -> None:
-    assert supervisor_manager.config_file_path == str(
-        tmp_path / "test-service.processes.conf"
-    )
-    with open(supervisor_manager.config_file_path, "r") as f:
-        assert (
-            f.read()
-            == f"""[program:test_program]
-command = python test_program.py
-
-[unix_http_server]
-file = {tmp_path}/test-service.sock
-
-[supervisord]
-pidfile = {tmp_path}/test-service.pid
-
-[supervisorctl]
-serverurl = unix://{tmp_path}/test-service.sock
-
-[rpcinterface:supervisor]
-supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
-
-"""
-        )