devservices 0.0.4__tar.gz → 0.0.5__tar.gz

{devservices-0.0.4 → devservices-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devservices
-Version: 0.0.4
+Version: 0.0.5
 Requires-Python: >=3.10
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-0.0.4 → devservices-0.0.5}/README.md

@@ -13,14 +13,14 @@ A system-wide installation can be done by downloading the binary of the latest r
 ```
 PLATFORM=darwin # Options: darwin/linux
 INSTALL_DIR="$HOME/.local/bin"
-curl -L "https://github.com/getsentry/devservices/releases/download/0.0.4/devservices-$PLATFORM" -o "$INSTALL_DIR/devservices"
+curl -L "https://github.com/getsentry/devservices/releases/download/0.0.5/devservices-$PLATFORM" -o "$INSTALL_DIR/devservices"
 chmod +x "$INSTALL_DIR/devservices"
 ```
 
 Alternatively, if the repository you're working in has a python virtualenv, you can simply add this to the requirements-dev.txt:
 
 ```
-devservices==0.0.4
+devservices==0.0.5
 ```
 ## Usage
 

{devservices-0.0.4 → devservices-0.0.5}/devservices/commands/list_services.py

@@ -5,8 +5,8 @@ from argparse import ArgumentParser
 from argparse import Namespace
 
 from devservices.utils.devenv import get_coderoot
-from devservices.utils.docker_compose import get_active_docker_compose_projects
 from devservices.utils.services import get_local_services
+from devservices.utils.state import State
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -28,14 +28,15 @@ def list_services(args: Namespace) -> None:
     # Get all of the services installed locally
     coderoot = get_coderoot()
     services = get_local_services(coderoot)
-    running_projects = get_active_docker_compose_projects()
+    state = State()
+    running_services = state.get_started_services()
 
     if not services:
         print("No services found")
         return
 
     services_to_show = (
-        services if args.all else [s for s in services if s.name in running_projects]
+        services if args.all else [s for s in services if s.name in running_services]
     )
 
     if args.all:
@@ -44,7 +45,7 @@ def list_services(args: Namespace) -> None:
         print("Running services:")
 
     for service in services_to_show:
-        status = "running" if service.name in running_projects else "stopped"
+        status = "running" if service.name in running_services else "stopped"
         print(f"- {service.name}")
         print(f"  status: {status}")
         print(f"  location: {service.repo_path}")

{devservices-0.0.4 → devservices-0.0.5}/devservices/commands/logs.py

@@ -5,9 +5,12 @@ from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
+from devservices.constants import MAX_LOG_LINES
+from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
 from devservices.utils.docker_compose import run_docker_compose_command
 from devservices.utils.services import find_matching_service
+from devservices.utils.state import State
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -35,11 +38,22 @@ def logs(args: Namespace) -> None:
     mode_to_use = "default"
     mode_dependencies = modes[mode_to_use]
 
+    state = State()
+    running_services = state.get_started_services()
+    if service_name not in running_services:
+        print(f"Service {service_name} is not running")
+        return
+
     try:
-        logs = run_docker_compose_command(service, "logs", mode_dependencies)
+        logs_output = run_docker_compose_command(
+            service, "logs", mode_dependencies, options=["-n", MAX_LOG_LINES]
+        )
+    except DependencyError as de:
+        print(str(de))
+        exit(1)
     except DockerComposeError as dce:
         print(f"Failed to get logs for {service.name}: {dce.stderr}")
         exit(1)
-    for log in logs:
+    for log in logs_output:
         sys.stdout.write(log.stdout)
         sys.stdout.flush()

devservices-0.0.5/devservices/commands/purge.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import os
+import shutil
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+
+from devservices.constants import DEVSERVICES_CACHE_DIR
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser("purge", help="Purge the local devservices cache")
+    parser.set_defaults(func=purge)
+
+
+def purge(args: Namespace) -> None:
+    """Purge the local devservices cache."""
+    if os.path.exists(DEVSERVICES_CACHE_DIR):
+        try:
+            shutil.rmtree(DEVSERVICES_CACHE_DIR)
+        except PermissionError as e:
+            print(f"Failed to purge cache: {e}")
+            exit(1)
+    print("The local devservices cache has been purged")

{devservices-0.0.4 → devservices-0.0.5}/devservices/commands/start.py

@@ -4,10 +4,12 @@ from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
+from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
 from devservices.utils.console import Status
 from devservices.utils.docker_compose import run_docker_compose_command
 from devservices.utils.services import find_matching_service
+from devservices.utils.state import State
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -35,8 +37,18 @@ def start(args: Namespace) -> None:
     with Status(f"Starting {service.name}", f"{service.name} started") as status:
         try:
             run_docker_compose_command(
-                service, "up", mode_dependencies, ["-d"], force_update_dependencies=True
+                service,
+                "up",
+                mode_dependencies,
+                ["-d"],
+                force_update_dependencies=True,
             )
+        except DependencyError as de:
+            status.print(str(de))
+            exit(1)
         except DockerComposeError as dce:
             status.print(f"Failed to start {service.name}: {dce.stderr}")
             exit(1)
+    # TODO: We should factor in healthchecks here before marking service as running
+    state = State()
+    state.add_started_service(service.name, mode_to_start)

{devservices-0.0.4 → devservices-0.0.5}/devservices/commands/status.py

@@ -6,6 +6,7 @@ from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
+from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
 from devservices.utils.docker_compose import run_docker_compose_command
 from devservices.utils.services import find_matching_service
@@ -33,11 +34,13 @@ def format_status_output(status_json: str) -> str:
         service = json.loads(service_status)
         name = service["Service"]
         state = service["State"]
+        container_name = service["Name"]
         health = service.get("Health", "N/A")
         ports = service.get("Publishers", [])
         running_for = service.get("RunningFor", "N/A")
 
         output.append(f"{name}")
+        output.append(f"Container: {container_name}")
         output.append(f"Status: {state}")
         output.append(f"Health: {health}")
         output.append(f"Uptime: {running_for}")
@@ -71,18 +74,25 @@ def status(args: Namespace) -> None:
     mode_dependencies = modes[mode_to_view]
 
     try:
-        status_jsons = run_docker_compose_command(
+        status_json_results = run_docker_compose_command(
             service, "ps", mode_dependencies, options=["--format", "json"]
         )
+    except DependencyError as de:
+        print(str(de))
+        exit(1)
     except DockerComposeError as dce:
         print(f"Failed to get status for {service.name}: {dce.stderr}")
         exit(1)
-    # If the service is not running, the status_json will be empty
-    if len(status_jsons) == 0:
+
+    # Filter out empty stdout to help us determine if the service is running
+    status_json_results = [
+        status_json for status_json in status_json_results if status_json.stdout
+    ]
+    if len(status_json_results) == 0:
         print(f"{service.name} is not running")
         return
     output = f"Service: {service.name}\n\n"
-    for status_json in status_jsons:
+    for status_json in status_json_results:
         output += format_status_output(status_json.stdout)
     output += "=" * LINE_LENGTH
     sys.stdout.write(output + "\n")

{devservices-0.0.4 → devservices-0.0.5}/devservices/commands/stop.py

@@ -4,10 +4,12 @@ from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
+from devservices.exceptions import DependencyError
 from devservices.exceptions import DockerComposeError
 from devservices.utils.console import Status
 from devservices.utils.docker_compose import run_docker_compose_command
 from devservices.utils.services import find_matching_service
+from devservices.utils.state import State
 
 
 def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
@@ -31,10 +33,22 @@ def stop(args: Namespace) -> None:
     # TODO: allow custom modes to be used
     mode_to_stop = "default"
     mode_dependencies = modes[mode_to_stop]
+    state = State()
+    started_services = state.get_started_services()
+    if service.name not in started_services:
+        print(f"{service.name} is not running")
+        exit(0)
 
     with Status(f"Stopping {service.name}", f"{service.name} stopped") as status:
         try:
             run_docker_compose_command(service, "down", mode_dependencies)
+        except DependencyError as de:
+            status.print(str(de))
+            exit(1)
         except DockerComposeError as dce:
             status.print(f"Failed to stop {service.name}: {dce.stderr}")
             exit(1)
+
+    # TODO: We should factor in healthchecks here before marking service as stopped
+    state = State()
+    state.remove_started_service(service.name)

{devservices-0.0.4 → devservices-0.0.5}/devservices/constants.py

@@ -11,6 +11,7 @@ DEVSERVICES_CACHE_DIR = os.path.expanduser("~/.cache/sentry-devservices")
 DEVSERVICES_LOCAL_DIR = os.path.expanduser("~/.local/share/sentry-devservices")
 DEVSERVICES_DEPENDENCIES_CACHE_DIR = os.path.join(DEVSERVICES_CACHE_DIR, "dependencies")
 DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY = "DEVSERVICES_DEPENDENCIES_CACHE_DIR"
+STATE_DB_FILE = os.path.join(DEVSERVICES_LOCAL_DIR, "state")
 
 DEPENDENCY_CONFIG_VERSION = "v1"
 DEPENDENCY_GIT_PARTIAL_CLONE_CONFIG_OPTIONS = {
@@ -22,3 +23,4 @@ DEPENDENCY_GIT_PARTIAL_CLONE_CONFIG_OPTIONS = {
 DOCKER_COMPOSE_DOWNLOAD_URL = "https://github.com/docker/compose/releases/download"
 DEVSERVICES_DOWNLOAD_URL = "https://github.com/getsentry/devservices/releases/download"
 BINARY_PERMISSIONS = 0o755
+MAX_LOG_LINES = "100"

{devservices-0.0.4 → devservices-0.0.5}/devservices/exceptions.py

@@ -43,6 +43,12 @@ class DevservicesUpdateError(BinaryInstallError):
     pass
 
 
+class DockerDaemonNotRunningError(Exception):
+    """Raised when the Docker daemon is not running."""
+
+    pass
+
+
 class DockerComposeInstallationError(BinaryInstallError):
     """Raised when the Docker Compose installation fails."""
 
@@ -67,17 +73,29 @@ class DependencyError(Exception):
         self.repo_link = repo_link
         self.branch = branch
 
+    def __str__(self) -> str:
+        return f"DependencyError: {self.repo_name} ({self.repo_link}) on {self.branch}"
+
+
+class UnableToCloneDependencyError(DependencyError):
+    """Raised when a dependency is unable to be cloned."""
+
+    def __str__(self) -> str:
+        return f"Unable to clone dependency: {self.repo_name} ({self.repo_link}) on {self.branch}"
+
 
 class InvalidDependencyConfigError(DependencyError):
     """Raised when a dependency's config is invalid."""
 
-    pass
+    def __str__(self) -> str:
+        return f"Invalid config for dependency: {self.repo_name} ({self.repo_link}) on {self.branch}"
 
 
 class DependencyNotInstalledError(DependencyError):
     """Raised when a dependency is not installed correctly."""
 
-    pass
+    def __str__(self) -> str:
+        return f"Dependency not installed correctly: {self.repo_name} ({self.repo_link}) on {self.branch}"
 
 
 class GitConfigError(Exception):

{devservices-0.0.4 → devservices-0.0.5}/devservices/main.py

@@ -11,11 +11,14 @@ from sentry_sdk.integrations.argv import ArgvIntegration
 from devservices.commands import list_dependencies
 from devservices.commands import list_services
 from devservices.commands import logs
+from devservices.commands import purge
 from devservices.commands import start
 from devservices.commands import status
 from devservices.commands import stop
 from devservices.commands import update
 from devservices.commands.check_for_update import check_for_update
+from devservices.exceptions import DockerComposeInstallationError
+from devservices.exceptions import DockerDaemonNotRunningError
 from devservices.utils.docker_compose import check_docker_compose_version
 
 sentry_environment = (
@@ -41,7 +44,14 @@ def cleanup() -> None:
 
 
 def main() -> None:
-    check_docker_compose_version()
+    try:
+        check_docker_compose_version()
+    except DockerDaemonNotRunningError as e:
+        print(e)
+        exit(1)
+    except DockerComposeInstallationError:
+        print("Failed to ensure docker compose is installed and up-to-date")
+        exit(1)
     parser = argparse.ArgumentParser(
         prog="devservices",
         description="CLI tool for managing service dependencies.",
@@ -61,6 +71,7 @@ def main() -> None:
     status.add_parser(subparsers)
     logs.add_parser(subparsers)
     update.add_parser(subparsers)
+    purge.add_parser(subparsers)
 
     args = parser.parse_args()
 

{devservices-0.0.4 → devservices-0.0.5}/devservices/utils/dependencies.py

@@ -25,7 +25,11 @@ from devservices.exceptions import DependencyError
 from devservices.exceptions import DependencyNotInstalledError
 from devservices.exceptions import FailedToSetGitConfigError
 from devservices.exceptions import InvalidDependencyConfigError
+from devservices.exceptions import UnableToCloneDependencyError
 from devservices.utils.file_lock import lock
+from devservices.utils.services import find_matching_service
+from devservices.utils.services import Service
+from devservices.utils.state import State
 
 
 @dataclass(frozen=True)
@@ -132,6 +136,25 @@ def verify_local_dependencies(dependencies: list[Dependency]) -> bool:
     )
 
 
+def get_non_shared_remote_dependencies(
+    service_to_stop: Service, remote_dependencies: set[InstalledRemoteDependency]
+) -> set[InstalledRemoteDependency]:
+    state = State()
+    started_services = state.get_started_services()
+    # We don't care about the remote dependencies of the service we are stopping
+    started_services.remove(service_to_stop.name)
+    other_running_remote_dependencies: set[InstalledRemoteDependency] = set()
+    for service_name in started_services:
+        service = find_matching_service(service_name)
+        # TODO: There is an edge case here where there is a shared remote dependency with different modes
+        other_running_remote_dependencies = other_running_remote_dependencies.union(
+            get_installed_remote_dependencies(
+                list(service.config.dependencies.values())
+            )
+        )
+    return remote_dependencies.difference(other_running_remote_dependencies)
+
+
 def get_installed_remote_dependencies(
     dependencies: list[Dependency],
 ) -> set[InstalledRemoteDependency]:
@@ -344,7 +367,7 @@ def _checkout_dependency(
                 cwd=temp_dir,
             )
         except subprocess.CalledProcessError as e:
-            raise DependencyError(
+            raise UnableToCloneDependencyError(
                 repo_name=dependency.repo_name,
                 repo_link=dependency.repo_link,
                 branch=dependency.branch,

devservices-0.0.5/devservices/utils/docker.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import subprocess
+
+from devservices.exceptions import DockerDaemonNotRunningError
+
+
+def check_docker_daemon_running() -> None:
+    try:
+        subprocess.run(
+            ["docker", "info"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise DockerDaemonNotRunningError(
+            "Unable to connect to the docker daemon. Is the docker daemon running?"
+        ) from e

{devservices-0.0.4 → devservices-0.0.5}/devservices/utils/docker_compose.py

@@ -22,28 +22,15 @@ from devservices.exceptions import BinaryInstallError
 from devservices.exceptions import DockerComposeError
 from devservices.exceptions import DockerComposeInstallationError
 from devservices.utils.dependencies import get_installed_remote_dependencies
+from devservices.utils.dependencies import get_non_shared_remote_dependencies
 from devservices.utils.dependencies import install_dependencies
 from devservices.utils.dependencies import InstalledRemoteDependency
 from devservices.utils.dependencies import verify_local_dependencies
+from devservices.utils.docker import check_docker_daemon_running
 from devservices.utils.install_binary import install_binary
 from devservices.utils.services import Service
 
 
-def get_active_docker_compose_projects() -> list[str]:
-    cmd = ["docker", "compose", "ls", "-q"]
-    try:
-        running_projects = subprocess.check_output(cmd, text=True)
-    except subprocess.CalledProcessError as e:
-        raise DockerComposeError(
-            command=" ".join(cmd),
-            returncode=e.returncode,
-            stdout=e.stdout,
-            stderr=e.stderr,
-        )
-    # docker compose ls always returns newline delimited string with an extra newline at the end
-    return running_projects.split("\n")[:-1]
-
-
 def install_docker_compose() -> None:
     # Determine the platform
     system = platform.system()
@@ -104,11 +91,12 @@ def install_docker_compose() -> None:
 
 
 def check_docker_compose_version() -> None:
-    cmd = ["docker", "compose", "version", "--short"]
+    # Throw an error if docker daemon isn't running
+    check_docker_daemon_running()
     try:
         # Run the docker compose version command
         result = subprocess.run(
-            cmd,
+            ["docker", "compose", "version", "--short"],
             capture_output=True,
             text=True,
             check=True,
@@ -224,11 +212,12 @@ def _get_docker_compose_commands_to_run(
         service_config_file_path, current_env
     )
     services_to_use = non_remote_services.intersection(set(mode_dependencies))
-    docker_compose_commands.append(
-        create_docker_compose_command(
-            service.name, service_config_file_path, services_to_use
+    if len(services_to_use) > 0:
+        docker_compose_commands.append(
+            create_docker_compose_command(
+                service.name, service_config_file_path, services_to_use
+            )
         )
-    )
     return docker_compose_commands
 
 
@@ -250,6 +239,11 @@ def run_docker_compose_command(
             remote_dependencies = install_dependencies(dependencies)
         else:
             remote_dependencies = get_installed_remote_dependencies(dependencies)
+    # TODO: Refactor this to be more generic instead of having a one-off case for stopping
+    if command == "down":
+        remote_dependencies = get_non_shared_remote_dependencies(
+            service, remote_dependencies
+        )
     relative_local_dependency_directory = os.path.relpath(
         os.path.join(DEVSERVICES_DEPENDENCIES_CACHE_DIR, DEPENDENCY_CONFIG_VERSION),
         service.repo_path,

devservices-0.0.5/devservices/utils/state.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import os
+import sqlite3
+
+from devservices.constants import DEVSERVICES_LOCAL_DIR
+from devservices.constants import STATE_DB_FILE
+
+
+class State:
+    _instance: State | None = None
+    state_db_file: str
+    conn: sqlite3.Connection
+
+    def __new__(cls) -> State:
+        if cls._instance is None:
+            cls._instance = super(State, cls).__new__(cls)
+            if not os.path.exists(DEVSERVICES_LOCAL_DIR):
+                os.makedirs(DEVSERVICES_LOCAL_DIR)
+            cls._instance.state_db_file = STATE_DB_FILE
+            cls._instance.conn = sqlite3.connect(cls._instance.state_db_file)
+            cls._instance.initialize_database()
+        return cls._instance
+
+    def initialize_database(self) -> None:
+        cursor = self.conn.cursor()
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS started_services (
+                service_name TEXT PRIMARY KEY,
+                mode TEXT,
+                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """
+        )
+        self.conn.commit()
+
+    def add_started_service(self, service_name: str, mode: str) -> None:
+        cursor = self.conn.cursor()
+        started_services = self.get_started_services()
+        if service_name in started_services:
+            return
+        cursor.execute(
+            """
+            INSERT INTO started_services (service_name, mode) VALUES (?, ?)
+        """,
+            (service_name, mode),
+        )
+        self.conn.commit()
+
+    def remove_started_service(self, service_name: str) -> None:
+        cursor = self.conn.cursor()
+        cursor.execute(
+            """
+            DELETE FROM started_services WHERE service_name = ?
+        """,
+            (service_name,),
+        )
+        self.conn.commit()
+
+    def get_started_services(self) -> list[str]:
+        cursor = self.conn.cursor()
+        cursor.execute(
+            """
+            SELECT service_name FROM started_services
+        """
+        )
+        return [row[0] for row in cursor.fetchall()]
+
+    def get_mode_for_service(self, service_name: str) -> str | None:
+        cursor = self.conn.cursor()
+        cursor.execute(
+            """
+            SELECT mode FROM started_services WHERE service_name = ?
+        """,
+            (service_name,),
+        )
+        result = cursor.fetchone()
+        if result is None:
+            return None
+        return str(result[0])

{devservices-0.0.4 → devservices-0.0.5}/devservices.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devservices
-Version: 0.0.4
+Version: 0.0.5
 Requires-Python: >=3.10
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-0.0.4 → devservices-0.0.5}/devservices.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ devservices/commands/check_for_update.py
 devservices/commands/list_dependencies.py
 devservices/commands/list_services.py
 devservices/commands/logs.py
+devservices/commands/purge.py
 devservices/commands/start.py
 devservices/commands/status.py
 devservices/commands/stop.py
@@ -26,19 +27,23 @@ devservices/utils/__init__.py
 devservices/utils/console.py
 devservices/utils/dependencies.py
 devservices/utils/devenv.py
+devservices/utils/docker.py
 devservices/utils/docker_compose.py
 devservices/utils/file_lock.py
 devservices/utils/install_binary.py
 devservices/utils/services.py
+devservices/utils/state.py
 testing/__init__.py
 testing/utils.py
 tests/__init__.py
 tests/conftest.py
 tests/commands/test_list_services.py
+tests/commands/test_purge.py
 tests/commands/test_start.py
 tests/commands/test_stop.py
 tests/commands/test_update.py
 tests/configs/test_service_config.py
 tests/utils/test_dependencies.py
 tests/utils/test_docker_compose.py
-tests/utils/test_install_binary.py
+tests/utils/test_install_binary.py
+tests/utils/test_state.py

{devservices-0.0.4 → devservices-0.0.5}/pyproject.toml

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

{devservices-0.0.4 → devservices-0.0.5}/tests/commands/test_list_services.py

@@ -7,20 +7,19 @@ from unittest import mock
 import pytest
 
 from devservices.commands.list_services import list_services
+from devservices.utils.state import State
 from testing.utils import create_config_file
 
 
-@mock.patch(
-    "devservices.utils.docker_compose.subprocess.run",
-    return_value=Namespace(stdout="\nexample-service\n"),
-)
 def test_list_running_services(
-    mock_run: mock.Mock, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
     with mock.patch(
         "devservices.commands.list_services.get_coderoot",
         return_value=str(tmp_path / "code"),
-    ):
+    ), mock.patch("devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")):
+        state = State()
+        state.add_started_service("example-service", "default")
         config = {
             "x-sentry-service-config": {
                 "version": 0.1,
@@ -52,17 +51,13 @@ def test_list_running_services(
         )
 
 
-@mock.patch(
-    "devservices.utils.docker_compose.subprocess.run",
-    return_value=Namespace(stdout="\nexample-service\n"),
-)
-def test_list_all_services(
-    mock_run: mock.Mock, tmp_path: Path, capsys: pytest.CaptureFixture[str]
-) -> None:
+def test_list_all_services(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
     with mock.patch(
         "devservices.commands.list_services.get_coderoot",
         return_value=str(tmp_path / "code"),
-    ):
+    ), mock.patch("devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")):
+        state = State()
+        state.add_started_service("example-service", "default")
         config = {
             "x-sentry-service-config": {
                 "version": 0.1,