devservices 1.0.5__tar.gz → 1.0.6__tar.gz

{devservices-1.0.5 → devservices-1.0.6}/PKG-INFO

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

{devservices-1.0.5 → devservices-1.0.6}/README.md

@@ -11,7 +11,7 @@ A standalone cli tool used to manage dependencies for services. It simplifies th
 The recommended way to install devservices is through a virtualenv in the requirements.txt.
 
 ```
-devservices==1.0.5
+devservices==1.0.6
 ```
 
 

{devservices-1.0.5 → devservices-1.0.6}/devservices/commands/down.py

@@ -90,9 +90,14 @@ def down(args: Namespace) -> None:
             capture_exception(de)
             status.failure(str(de))
             exit(1)
-        remote_dependencies = get_non_shared_remote_dependencies(
-            service, remote_dependencies
-        )
+        try:
+            remote_dependencies = get_non_shared_remote_dependencies(
+                service, remote_dependencies
+            )
+        except DependencyError as de:
+            capture_exception(de)
+            status.failure(str(de))
+            exit(1)
         try:
             _down(service, remote_dependencies, list(mode_dependencies), status)
         except DockerComposeError as dce:

{devservices-1.0.5 → devservices-1.0.6}/devservices/commands/purge.py

@@ -8,11 +8,13 @@ from argparse import ArgumentParser
 from argparse import Namespace
 
 from devservices.constants import DEVSERVICES_CACHE_DIR
+from devservices.constants import DEVSERVICES_ORCHESTRATOR_LABEL
 from devservices.constants import DOCKER_NETWORK_NAME
 from devservices.exceptions import DockerDaemonNotRunningError
+from devservices.exceptions import DockerError
 from devservices.utils.console import Console
 from devservices.utils.console import Status
-from devservices.utils.docker import stop_all_running_containers
+from devservices.utils.docker import stop_matching_containers
 from devservices.utils.state import State
 
 
@@ -25,14 +27,6 @@ def purge(_args: Namespace) -> None:
     """Purge the local devservices cache."""
     console = Console()
 
-    # Prompt the user to stop all running containers
-    should_stop_containers = console.confirm(
-        "Warning: Purging stops all running containers and clears devservices state. Would you like to continue?"
-    )
-    if not should_stop_containers:
-        console.warning("Purge canceled")
-        return
-
     if os.path.exists(DEVSERVICES_CACHE_DIR):
         try:
             shutil.rmtree(DEVSERVICES_CACHE_DIR)
@@ -42,13 +36,16 @@ def purge(_args: Namespace) -> None:
     state = State()
     state.clear_state()
     with Status(
-        lambda: console.warning("Stopping all running containers"),
-        lambda: console.success("All running containers have been stopped"),
+        lambda: console.warning("Stopping all running devservices containers"),
+        lambda: console.success("All running devservices containers have been stopped"),
     ):
         try:
-            stop_all_running_containers()
+            stop_matching_containers(DEVSERVICES_ORCHESTRATOR_LABEL, should_remove=True)
         except DockerDaemonNotRunningError:
-            console.warning("The docker daemon not running, no containers to stop")
+            console.warning("The docker daemon is not running, no containers to stop")
+        except DockerError as e:
+            console.failure(f"Failed to stop running devservices containers {e.stderr}")
+            exit(1)
 
     console.warning("Removing any devservices networks")
     devservices_networks = (

{devservices-1.0.5 → devservices-1.0.6}/devservices/commands/update.py

@@ -7,10 +7,10 @@ from argparse import ArgumentParser
 from argparse import Namespace
 from importlib import metadata
 
-from devservices.commands.check_for_update import check_for_update
 from devservices.constants import DEVSERVICES_DOWNLOAD_URL
 from devservices.exceptions import BinaryInstallError
 from devservices.exceptions import DevservicesUpdateError
+from devservices.utils.check_for_update import check_for_update
 from devservices.utils.console import Console
 from devservices.utils.install_binary import install_binary
 

{devservices-1.0.5 → devservices-1.0.6}/devservices/constants.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+from datetime import timedelta
 
 MINIMUM_DOCKER_COMPOSE_VERSION = "2.29.7"
 DEVSERVICES_DIR_NAME = "devservices"
@@ -12,6 +13,7 @@ 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")
+DEVSERVICES_ORCHESTRATOR_LABEL = "orchestrator=devservices"
 DOCKER_COMPOSE_COMMAND_LENGTH = 7
 
 DEPENDENCY_CONFIG_VERSION = "v1"
@@ -21,9 +23,18 @@ DEPENDENCY_GIT_PARTIAL_CLONE_CONFIG_OPTIONS = {
     "core.sparseCheckout": "true",
 }
 
+DEVSERVICES_RELEASES_URL = (
+    "https://api.github.com/repos/getsentry/devservices/releases/latest"
+)
 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"
 LOGGER_NAME = "devservices"
 DOCKER_NETWORK_NAME = "devservices"
+
+# Latest Version Cache
+DEVSERVICES_LATEST_VERSION_CACHE_FILE = os.path.join(
+    DEVSERVICES_CACHE_DIR, "latest_version.txt"
+)
+DEVSERVICES_LATEST_VERSION_CACHE_TTL = timedelta(minutes=15)

{devservices-1.0.5 → devservices-1.0.6}/devservices/exceptions.py

@@ -57,8 +57,8 @@ class DockerComposeInstallationError(BinaryInstallError):
     pass
 
 
-class DockerComposeError(Exception):
-    """Base class for Docker Compose related errors."""
+class DockerError(Exception):
+    """Base class for Docker related errors."""
 
     def __init__(self, command: str, returncode: int, stdout: str, stderr: str):
         self.command = command
@@ -67,6 +67,12 @@ class DockerComposeError(Exception):
         self.stderr = stderr
 
 
+class DockerComposeError(DockerError):
+    """Base class for Docker Compose related errors."""
+
+    pass
+
+
 class ModeDoesNotExistError(Exception):
     """Raised when a mode does not exist."""
 

{devservices-1.0.5 → devservices-1.0.6}/devservices/main.py

@@ -23,10 +23,10 @@ from devservices.commands import purge
 from devservices.commands import status
 from devservices.commands import up
 from devservices.commands import update
-from devservices.commands.check_for_update import check_for_update
 from devservices.constants import LOGGER_NAME
 from devservices.exceptions import DockerComposeInstallationError
 from devservices.exceptions import DockerDaemonNotRunningError
+from devservices.utils.check_for_update import check_for_update
 from devservices.utils.console import Console
 from devservices.utils.docker_compose import check_docker_compose_version
 
@@ -102,7 +102,7 @@ def main() -> None:
     else:
         parser.print_help()
 
-    if args.command != "update":
+    if args.command != "update" and os.environ.get("CI") != "true":
         newest_version = check_for_update()
         if newest_version != current_version:
             console.warning(

devservices-1.0.6/devservices/utils/check_for_update.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime
+from datetime import timedelta
+from urllib.request import urlopen
+
+from devservices.constants import DEVSERVICES_CACHE_DIR
+from devservices.constants import DEVSERVICES_LATEST_VERSION_CACHE_FILE
+from devservices.constants import DEVSERVICES_LATEST_VERSION_CACHE_TTL
+from devservices.constants import DEVSERVICES_RELEASES_URL
+
+
+def _delete_cached_version() -> None:
+    if os.path.exists(DEVSERVICES_LATEST_VERSION_CACHE_FILE):
+        os.remove(DEVSERVICES_LATEST_VERSION_CACHE_FILE)
+
+
+def _get_cache_age() -> timedelta:
+    if os.path.exists(DEVSERVICES_LATEST_VERSION_CACHE_FILE):
+        file_modification_time = datetime.fromtimestamp(
+            os.path.getmtime(DEVSERVICES_LATEST_VERSION_CACHE_FILE)
+        )
+        return datetime.now() - file_modification_time
+    return timedelta.max
+
+
+def _get_cached_version() -> str | None:
+    cache_age = _get_cache_age()
+    if cache_age < DEVSERVICES_LATEST_VERSION_CACHE_TTL:
+        with open(DEVSERVICES_LATEST_VERSION_CACHE_FILE, "r", encoding="utf-8") as f:
+            return f.read()
+    else:
+        _delete_cached_version()
+        return None
+
+
+def _set_cached_version(latest_version: str) -> None:
+    with open(DEVSERVICES_LATEST_VERSION_CACHE_FILE, "w", encoding="utf-8") as f:
+        f.write(latest_version)
+
+
+def check_for_update() -> str | None:
+    os.makedirs(DEVSERVICES_CACHE_DIR, exist_ok=True)
+
+    cached_version = _get_cached_version()
+    if cached_version is not None:
+        return cached_version
+
+    with urlopen(DEVSERVICES_RELEASES_URL) as response:
+        if response.status == 200:
+            data = json.loads(response.read())
+            latest_version = str(data["tag_name"])
+
+            _set_cached_version(latest_version)
+
+            return latest_version
+    return None

devservices-1.0.6/devservices/utils/docker.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import subprocess
+
+from devservices.exceptions import DockerDaemonNotRunningError
+from devservices.exceptions import DockerError
+
+
+def check_docker_daemon_running() -> None:
+    """Checks if the Docker daemon is running. Raises DockerDaemonNotRunningError if not."""
+    try:
+        subprocess.run(
+            ["docker", "info"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise DockerDaemonNotRunningError from e
+
+
+def get_matching_containers(label: str) -> list[str]:
+    """
+    Returns a list of container IDs with the given label
+    """
+    check_docker_daemon_running()
+    try:
+        return (
+            subprocess.check_output(
+                [
+                    "docker",
+                    "ps",
+                    "-q",
+                    "--filter",
+                    f"label={label}",
+                ],
+                stderr=subprocess.DEVNULL,
+            )
+            .decode()
+            .strip()
+            .splitlines()
+        )
+    except subprocess.CalledProcessError as e:
+        raise DockerError(
+            command=f"docker ps -q --filter label={label}",
+            returncode=e.returncode,
+            stdout=e.stdout,
+            stderr=e.stderr,
+        ) from e
+
+
+def stop_matching_containers(label: str, should_remove: bool = False) -> None:
+    """
+    Stops all containers with the given label.
+    If should_remove is True, the containers will be removed.
+    """
+    matching_containers = get_matching_containers(label)
+    if len(matching_containers) == 0:
+        return
+    try:
+        subprocess.run(
+            ["docker", "stop"] + matching_containers,
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except subprocess.CalledProcessError as e:
+        raise DockerError(
+            command=f"docker stop {' '.join(matching_containers)}",
+            returncode=e.returncode,
+            stdout=e.stdout,
+            stderr=e.stderr,
+        ) from e
+    if should_remove:
+        try:
+            subprocess.run(
+                ["docker", "rm"] + matching_containers,
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+        except subprocess.CalledProcessError as e:
+            raise DockerError(
+                command=f"docker rm {' '.join(matching_containers)}",
+                returncode=e.returncode,
+                stdout=e.stdout,
+                stderr=e.stderr,
+            ) from e

{devservices-1.0.5 → devservices-1.0.6}/devservices.egg-info/PKG-INFO

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

{devservices-1.0.5 → devservices-1.0.6}/devservices.egg-info/SOURCES.txt

@@ -13,7 +13,6 @@ devservices.egg-info/entry_points.txt
 devservices.egg-info/requires.txt
 devservices.egg-info/top_level.txt
 devservices/commands/__init__.py
-devservices/commands/check_for_update.py
 devservices/commands/down.py
 devservices/commands/list_dependencies.py
 devservices/commands/list_services.py
@@ -24,6 +23,7 @@ devservices/commands/up.py
 devservices/commands/update.py
 devservices/configs/service_config.py
 devservices/utils/__init__.py
+devservices/utils/check_for_update.py
 devservices/utils/console.py
 devservices/utils/dependencies.py
 devservices/utils/devenv.py
@@ -46,6 +46,7 @@ tests/commands/test_status.py
 tests/commands/test_up.py
 tests/commands/test_update.py
 tests/configs/test_service_config.py
+tests/utils/test_check_for_update.py
 tests/utils/test_dependencies.py
 tests/utils/test_docker.py
 tests/utils/test_docker_compose.py

{devservices-1.0.5 → devservices-1.0.6}/pyproject.toml

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

{devservices-1.0.5 → devservices-1.0.6}/tests/commands/test_purge.py

@@ -1,47 +1,82 @@
 from __future__ import annotations
 
-import builtins
 from argparse import Namespace
 from pathlib import Path
 from unittest import mock
 
+import pytest
+
 from devservices.commands.purge import purge
+from devservices.exceptions import DockerDaemonNotRunningError
+from devservices.exceptions import DockerError
 from devservices.utils.state import State
 
 
-@mock.patch("devservices.commands.purge.stop_all_running_containers")
-def test_purge_not_confirmed(
-    mock_stop_all_running_containers: mock.Mock, tmp_path: Path
+@mock.patch("devservices.commands.purge.stop_matching_containers")
+@mock.patch("devservices.commands.purge.subprocess.run")
+def test_purge_docker_daemon_not_running(
+    mock_run: mock.Mock,
+    mock_stop_matching_containers: mock.Mock,
+    capsys: pytest.CaptureFixture[str],
+    tmp_path: Path,
 ) -> None:
+    mock_stop_matching_containers.side_effect = DockerDaemonNotRunningError()
     with (
         mock.patch(
             "devservices.commands.purge.DEVSERVICES_CACHE_DIR",
             str(tmp_path / ".devservices-cache"),
         ),
         mock.patch("devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")),
-        mock.patch.object(builtins, "input", lambda _: "no"),
+        mock.patch(
+            "devservices.commands.purge.subprocess.check_output",
+            return_value=b"",
+        ),
     ):
+        # Create a cache file to test purging
+        cache_dir = tmp_path / ".devservices-cache"
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        cache_file = tmp_path / ".devservices-cache" / "test.txt"
+        cache_file.write_text("This is a test cache file.")
+
+        state = State()
+        state.update_started_service("test-service", "test-mode")
+
+        assert cache_file.exists()
+        assert state.get_started_services() == ["test-service"]
+
         args = Namespace()
         purge(args)
 
-        mock_stop_all_running_containers.assert_not_called()
+        assert not cache_file.exists()
+        assert state.get_started_services() == []
 
+        mock_stop_matching_containers.assert_called_once()
+        mock_run.assert_not_called()
+
+        captured = capsys.readouterr()
+        assert (
+            "The docker daemon is not running, no containers to stop"
+            in captured.out.strip()
+        )
 
-@mock.patch("devservices.commands.purge.stop_all_running_containers")
+
+@mock.patch("devservices.commands.purge.stop_matching_containers")
 @mock.patch("devservices.commands.purge.subprocess.run")
-def test_purge_with_cache_and_state_and_no_running_containers_confirmed(
-    mock_run: mock.Mock, mock_stop_all_running_containers: mock.Mock, tmp_path: Path
+def test_purge_docker_daemon_docker_error(
+    mock_run: mock.Mock,
+    mock_stop_matching_containers: mock.Mock,
+    capsys: pytest.CaptureFixture[str],
+    tmp_path: Path,
 ) -> None:
+    mock_stop_matching_containers.side_effect = DockerError(
+        "command", 1, "output", "stderr"
+    )
     with (
         mock.patch(
             "devservices.commands.purge.DEVSERVICES_CACHE_DIR",
             str(tmp_path / ".devservices-cache"),
         ),
         mock.patch("devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")),
-        mock.patch.object(builtins, "input", lambda _: "yes"),
-        mock.patch(
-            "devservices.utils.docker.check_docker_daemon_running", return_value=None
-        ),
         mock.patch(
             "devservices.commands.purge.subprocess.check_output",
             return_value=b"",
@@ -60,19 +95,26 @@ def test_purge_with_cache_and_state_and_no_running_containers_confirmed(
         assert state.get_started_services() == ["test-service"]
 
         args = Namespace()
-        purge(args)
+        with pytest.raises(SystemExit):
+            purge(args)
 
         assert not cache_file.exists()
         assert state.get_started_services() == []
 
-        mock_stop_all_running_containers.assert_called_once()
+        mock_stop_matching_containers.assert_called_once()
         mock_run.assert_not_called()
 
+        captured = capsys.readouterr()
+        assert (
+            "Failed to stop running devservices containers stderr"
+            in captured.out.strip()
+        )
 
-@mock.patch("devservices.commands.purge.stop_all_running_containers")
+
+@mock.patch("devservices.commands.purge.stop_matching_containers")
 @mock.patch("devservices.commands.purge.subprocess.run")
-def test_purge_with_cache_and_state_and_running_containers_with_networks_confirmed(
-    mock_run: mock.Mock, mock_stop_all_running_containers: mock.Mock, tmp_path: Path
+def test_purge_with_cache_and_state_and_no_running_containers(
+    mock_run: mock.Mock, mock_stop_matching_containers: mock.Mock, tmp_path: Path
 ) -> None:
     with (
         mock.patch(
@@ -80,13 +122,12 @@ def test_purge_with_cache_and_state_and_running_containers_with_networks_confirm
             str(tmp_path / ".devservices-cache"),
         ),
         mock.patch("devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")),
-        mock.patch.object(builtins, "input", lambda _: "yes"),
         mock.patch(
             "devservices.utils.docker.check_docker_daemon_running", return_value=None
         ),
         mock.patch(
             "devservices.commands.purge.subprocess.check_output",
-            return_value=b"abc\ndef\nghe\n",
+            return_value=b"",
         ),
     ):
         # Create a cache file to test purging
@@ -107,35 +148,14 @@ def test_purge_with_cache_and_state_and_running_containers_with_networks_confirm
         assert not cache_file.exists()
         assert state.get_started_services() == []
 
-        mock_run.assert_has_calls(
-            [
-                mock.call(
-                    ["docker", "network", "rm", "abc"],
-                    check=True,
-                    stdout=mock.ANY,
-                    stderr=mock.ANY,
-                ),
-                mock.call(
-                    ["docker", "network", "rm", "def"],
-                    check=True,
-                    stdout=mock.ANY,
-                    stderr=mock.ANY,
-                ),
-                mock.call(
-                    ["docker", "network", "rm", "ghe"],
-                    check=True,
-                    stdout=mock.ANY,
-                    stderr=mock.ANY,
-                ),
-            ]
-        )
-        mock_stop_all_running_containers.assert_called_once()
+        mock_stop_matching_containers.assert_called_once()
+        mock_run.assert_not_called()
 
 
-@mock.patch("devservices.commands.purge.stop_all_running_containers")
+@mock.patch("devservices.commands.purge.stop_matching_containers")
 @mock.patch("devservices.commands.purge.subprocess.run")
-def test_purge_with_cache_and_state_and_running_containers_not_confirmed(
-    mock_run: mock.Mock, mock_stop_all_running_containers: mock.Mock, tmp_path: Path
+def test_purge_with_cache_and_state_and_running_containers_with_networks(
+    mock_run: mock.Mock, mock_stop_matching_containers: mock.Mock, tmp_path: Path
 ) -> None:
     with (
         mock.patch(
@@ -143,10 +163,13 @@ def test_purge_with_cache_and_state_and_running_containers_not_confirmed(
             str(tmp_path / ".devservices-cache"),
         ),
         mock.patch("devservices.utils.state.STATE_DB_FILE", str(tmp_path / "state")),
-        mock.patch.object(builtins, "input", lambda _: "no"),
         mock.patch(
             "devservices.utils.docker.check_docker_daemon_running", return_value=None
         ),
+        mock.patch(
+            "devservices.commands.purge.subprocess.check_output",
+            return_value=b"abc\ndef\nghe\n",
+        ),
     ):
         # Create a cache file to test purging
         cache_dir = tmp_path / ".devservices-cache"
@@ -157,11 +180,35 @@ def test_purge_with_cache_and_state_and_running_containers_not_confirmed(
         state = State()
         state.update_started_service("test-service", "test-mode")
 
+        assert cache_file.exists()
+        assert state.get_started_services() == ["test-service"]
+
         args = Namespace()
         purge(args)
 
-        assert cache_file.exists()
-        assert state.get_started_services() == ["test-service"]
+        assert not cache_file.exists()
+        assert state.get_started_services() == []
 
-        mock_run.assert_not_called()
-        mock_stop_all_running_containers.assert_not_called()
+        mock_stop_matching_containers.assert_called_once()
+        mock_run.assert_has_calls(
+            [
+                mock.call(
+                    ["docker", "network", "rm", "abc"],
+                    check=True,
+                    stdout=mock.ANY,
+                    stderr=mock.ANY,
+                ),
+                mock.call(
+                    ["docker", "network", "rm", "def"],
+                    check=True,
+                    stdout=mock.ANY,
+                    stderr=mock.ANY,
+                ),
+                mock.call(
+                    ["docker", "network", "rm", "ghe"],
+                    check=True,
+                    stdout=mock.ANY,
+                    stderr=mock.ANY,
+                ),
+            ]
+        )

devservices-1.0.6/tests/utils/test_check_for_update.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from datetime import datetime
+from datetime import timedelta
+from pathlib import Path
+from unittest import mock
+
+from freezegun import freeze_time
+
+from devservices.constants import DEVSERVICES_LATEST_VERSION_CACHE_TTL
+from devservices.constants import DEVSERVICES_RELEASES_URL
+from devservices.utils.check_for_update import check_for_update
+
+
+@mock.patch("devservices.utils.check_for_update.urlopen")
+def test_check_for_update_not_cached(mock_urlopen: mock.Mock, tmp_path: Path) -> None:
+    mock_response = mock.mock_open(read_data=b'{"tag_name": "1.0.0"}').return_value
+    mock_response.status = 200
+    mock_urlopen.side_effect = [mock_response]
+    cache_dir = tmp_path / "cache"
+    cached_file = cache_dir / "latest_version.txt"
+    with (
+        freeze_time("2024-05-14 05:43:21"),
+        mock.patch(
+            "devservices.utils.check_for_update.os.path.getmtime",
+            return_value=datetime.now().timestamp(),
+        ),
+        mock.patch(
+            "devservices.utils.check_for_update.DEVSERVICES_CACHE_DIR",
+            str(cache_dir),
+        ),
+        mock.patch(
+            "devservices.utils.check_for_update.DEVSERVICES_LATEST_VERSION_CACHE_FILE",
+            str(cached_file),
+        ),
+    ):
+        assert check_for_update() == "1.0.0"
+        mock_urlopen.assert_called_once_with(DEVSERVICES_RELEASES_URL)
+
+        with cached_file.open("r") as f:
+            cached_version = f.read()
+            assert cached_version == "1.0.0"
+
+
+@mock.patch("devservices.utils.check_for_update.urlopen")
+def test_check_for_update_no_cache_not_ok(
+    mock_urlopen: mock.Mock, tmp_path: Path
+) -> None:
+    mock_response = mock.mock_open().return_value
+    mock_response.status = 500
+    mock_urlopen.side_effect = [mock_response]
+    cache_dir = tmp_path / "cache"
+    cached_file = cache_dir / "latest_version.txt"
+    with (
+        mock.patch(
+            "devservices.utils.check_for_update.DEVSERVICES_CACHE_DIR",
+            str(cache_dir),
+        ),
+        mock.patch(
+            "devservices.utils.check_for_update.DEVSERVICES_LATEST_VERSION_CACHE_FILE",
+            str(cached_file),
+        ),
+    ):
+        assert check_for_update() is None
+        mock_urlopen.assert_called_once_with(DEVSERVICES_RELEASES_URL)
+
+        assert not cached_file.exists()
+
+
+@mock.patch("devservices.utils.check_for_update.urlopen")
+def test_check_for_update_cached_fresh(mock_urlopen: mock.Mock, tmp_path: Path) -> None:
+    cache_dir = tmp_path / "cache"
+    cached_file = cache_dir / "latest_version.txt"
+    with (
+        freeze_time("2024-05-14 05:43:21"),
+        mock.patch(
+            "devservices.utils.check_for_update.os.path.getmtime",
+            return_value=(
+                datetime.now()
+                - DEVSERVICES_LATEST_VERSION_CACHE_TTL
+                + timedelta(minutes=1)
+            ).timestamp(),
+        ),
+        mock.patch(
+            "devservices.utils.check_for_update.DEVSERVICES_CACHE_DIR",
+            str(cache_dir),
+        ),
+        mock.patch(
+            "devservices.utils.check_for_update.DEVSERVICES_LATEST_VERSION_CACHE_FILE",
+            str(cached_file),
+        ),
+    ):
+        cache_dir.mkdir()
+        cached_file.write_text("1.0.0")
+        assert check_for_update() == "1.0.0"
+        mock_urlopen.assert_not_called()
+
+
+@mock.patch("devservices.utils.check_for_update.urlopen")
+def test_check_for_update_cached_stale_without_update(
+    mock_urlopen: mock.Mock, tmp_path: Path
+) -> None:
+    mock_response = mock.mock_open(read_data=b'{"tag_name": "1.0.0"}').return_value
+    mock_response.status = 200
+    mock_urlopen.side_effect = [mock_response]
+    cache_dir = tmp_path / "cache"
+    cached_file = cache_dir / "latest_version.txt"
+    with (
+        freeze_time("2024-05-14 05:43:21"),
+        mock.patch(
+            "devservices.utils.check_for_update.os.path.getmtime",
+            return_value=(
+                datetime.now() - DEVSERVICES_LATEST_VERSION_CACHE_TTL
+            ).timestamp(),
+        ),
+        mock.patch(
+            "devservices.utils.check_for_update.DEVSERVICES_CACHE_DIR",
+            str(cache_dir),
+        ),
+        mock.patch(
+            "devservices.utils.check_for_update.DEVSERVICES_LATEST_VERSION_CACHE_FILE",
+            str(cached_file),
+        ),
+    ):
+        cache_dir.mkdir()
+        cached_file.write_text("1.0.0")
+        assert check_for_update() == "1.0.0"
+        mock_urlopen.assert_called_once_with(DEVSERVICES_RELEASES_URL)
+
+        with cached_file.open("r") as f:
+            cached_version = f.read()
+            assert cached_version == "1.0.0"
+
+
+@mock.patch("devservices.utils.check_for_update.urlopen")
+def test_check_for_update_cached_stale_with_update(
+    mock_urlopen: mock.Mock, tmp_path: Path
+) -> None:
+    mock_response = mock.mock_open(read_data=b'{"tag_name": "1.0.1"}').return_value
+    mock_response.status = 200
+    mock_urlopen.side_effect = [mock_response]
+    cache_dir = tmp_path / "cache"
+    cached_file = cache_dir / "latest_version.txt"
+    with (
+        freeze_time("2024-05-14 05:43:21"),
+        mock.patch(
+            "devservices.utils.check_for_update.os.path.getmtime",
+            return_value=(
+                datetime.now()
+                - DEVSERVICES_LATEST_VERSION_CACHE_TTL
+                - timedelta(minutes=1)
+            ).timestamp(),
+        ),
+        mock.patch(
+            "devservices.utils.check_for_update.DEVSERVICES_CACHE_DIR",
+            str(cache_dir),
+        ),
+        mock.patch(
+            "devservices.utils.check_for_update.DEVSERVICES_LATEST_VERSION_CACHE_FILE",
+            str(cached_file),
+        ),
+    ):
+        cache_dir.mkdir()
+        cached_file.write_text("1.0.0")
+        assert check_for_update() == "1.0.1"
+        mock_urlopen.assert_called_once_with(DEVSERVICES_RELEASES_URL)
+
+        with cached_file.open("r") as f:
+            cached_data = f.read()
+            assert cached_data == "1.0.1"

devservices-1.0.6/tests/utils/test_docker.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import subprocess
+from unittest import mock
+
+import pytest
+
+from devservices.constants import DEVSERVICES_ORCHESTRATOR_LABEL
+from devservices.exceptions import DockerDaemonNotRunningError
+from devservices.exceptions import DockerError
+from devservices.utils.docker import check_docker_daemon_running
+from devservices.utils.docker import get_matching_containers
+from devservices.utils.docker import stop_matching_containers
+
+
+@mock.patch("subprocess.run")
+def test_check_docker_daemon_running_error(mock_run: mock.Mock) -> None:
+    mock_run.side_effect = subprocess.CalledProcessError(1, "cmd")
+    with pytest.raises(DockerDaemonNotRunningError):
+        check_docker_daemon_running()
+    mock_run.assert_called_once_with(
+        ["docker", "info"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+
+@mock.patch("subprocess.run")
+def test_check_docker_daemon_running(mock_run: mock.Mock) -> None:
+    check_docker_daemon_running()
+    mock_run.assert_called_once_with(
+        ["docker", "info"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+
+@mock.patch("subprocess.check_output")
+@mock.patch("devservices.utils.docker.check_docker_daemon_running")
+def test_get_matching_containers(
+    mock_check_docker_daemon_running: mock.Mock,
+    mock_check_output: mock.Mock,
+) -> None:
+    mock_check_docker_daemon_running.return_value = None
+    mock_check_output.return_value = b""
+    get_matching_containers(DEVSERVICES_ORCHESTRATOR_LABEL)
+    mock_check_docker_daemon_running.assert_called_once()
+    mock_check_output.assert_called_once_with(
+        ["docker", "ps", "-q", "--filter", f"label={DEVSERVICES_ORCHESTRATOR_LABEL}"],
+        stderr=subprocess.DEVNULL,
+    )
+
+
+@mock.patch("subprocess.check_output")
+@mock.patch("devservices.utils.docker.check_docker_daemon_running")
+def test_get_matching_containers_docker_daemon_not_running(
+    mock_check_docker_daemon_running: mock.Mock,
+    mock_check_output: mock.Mock,
+) -> None:
+    mock_check_docker_daemon_running.side_effect = DockerDaemonNotRunningError()
+    with pytest.raises(DockerDaemonNotRunningError):
+        get_matching_containers(DEVSERVICES_ORCHESTRATOR_LABEL)
+    mock_check_docker_daemon_running.assert_called_once()
+    mock_check_output.assert_not_called()
+
+
+@mock.patch("subprocess.check_output")
+@mock.patch("devservices.utils.docker.check_docker_daemon_running")
+def test_get_matching_containers_error(
+    mock_check_docker_daemon_running: mock.Mock,
+    mock_check_output: mock.Mock,
+) -> None:
+    mock_check_docker_daemon_running.return_value = None
+    mock_check_output.side_effect = subprocess.CalledProcessError(1, "cmd")
+    with pytest.raises(DockerError):
+        get_matching_containers(DEVSERVICES_ORCHESTRATOR_LABEL)
+    mock_check_docker_daemon_running.assert_called_once()
+    mock_check_output.assert_called_once_with(
+        ["docker", "ps", "-q", "--filter", f"label={DEVSERVICES_ORCHESTRATOR_LABEL}"],
+        stderr=subprocess.DEVNULL,
+    )
+
+
+@mock.patch("subprocess.run")
+@mock.patch("devservices.utils.docker.get_matching_containers")
+def test_stop_matching_containers_should_not_remove(
+    mock_get_matching_containers: mock.Mock,
+    mock_run: mock.Mock,
+) -> None:
+    mock_get_matching_containers.return_value = ["container1", "container2"]
+    stop_matching_containers(DEVSERVICES_ORCHESTRATOR_LABEL, should_remove=False)
+    mock_run.assert_called_once_with(
+        ["docker", "stop", "container1", "container2"],
+        check=True,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+@mock.patch("subprocess.run")
+@mock.patch("devservices.utils.docker.get_matching_containers")
+def test_stop_matching_containers_none(
+    mock_get_matching_containers: mock.Mock,
+    mock_run: mock.Mock,
+) -> None:
+    mock_get_matching_containers.return_value = []
+    stop_matching_containers(DEVSERVICES_ORCHESTRATOR_LABEL, should_remove=True)
+    mock_run.assert_not_called()
+
+
+@mock.patch("subprocess.run")
+@mock.patch("devservices.utils.docker.get_matching_containers")
+def test_stop_matching_containers_should_remove(
+    mock_get_matching_containers: mock.Mock,
+    mock_run: mock.Mock,
+) -> None:
+    mock_get_matching_containers.return_value = ["container1", "container2"]
+    stop_matching_containers(DEVSERVICES_ORCHESTRATOR_LABEL, should_remove=True)
+    mock_run.assert_has_calls(
+        [
+            mock.call(
+                ["docker", "stop", "container1", "container2"],
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            ),
+            mock.call(
+                ["docker", "rm", "container1", "container2"],
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            ),
+        ]
+    )
+
+
+@mock.patch("subprocess.run")
+@mock.patch("devservices.utils.docker.get_matching_containers")
+def test_stop_matching_containers_stop_error(
+    mock_get_matching_containers: mock.Mock,
+    mock_run: mock.Mock,
+) -> None:
+    mock_run.side_effect = subprocess.CalledProcessError(1, "cmd")
+    mock_get_matching_containers.return_value = ["container1", "container2"]
+    with pytest.raises(DockerError):
+        stop_matching_containers(DEVSERVICES_ORCHESTRATOR_LABEL, should_remove=True)
+    mock_run.assert_called_once_with(
+        ["docker", "stop", "container1", "container2"],
+        check=True,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+@mock.patch("subprocess.run")
+@mock.patch("devservices.utils.docker.get_matching_containers")
+def test_stop_matching_containers_remove_error(
+    mock_get_matching_containers: mock.Mock,
+    mock_run: mock.Mock,
+) -> None:
+    mock_run.side_effect = [None, subprocess.CalledProcessError(1, "cmd")]
+    mock_get_matching_containers.return_value = ["container1", "container2"]
+    with pytest.raises(DockerError):
+        stop_matching_containers(DEVSERVICES_ORCHESTRATOR_LABEL, should_remove=True)
+    mock_run.assert_has_calls(
+        [
+            mock.call(
+                ["docker", "stop", "container1", "container2"],
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            ),
+            mock.call(
+                ["docker", "rm", "container1", "container2"],
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            ),
+        ]
+    )

devservices-1.0.5/devservices/commands/check_for_update.py

@@ -1,14 +0,0 @@
-from __future__ import annotations
-
-import json
-from urllib.request import urlopen
-
-
-def check_for_update() -> str | None:
-    url = "https://api.github.com/repos/getsentry/devservices/releases/latest"
-    with urlopen(url) as response:
-        if response.status == 200:
-            data = json.loads(response.read().decode("utf-8"))
-            latest_version = str(data["tag_name"])
-            return latest_version
-    return None

devservices-1.0.5/devservices/utils/docker.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-import subprocess
-
-from devservices.exceptions import DockerDaemonNotRunningError
-
-
-def check_docker_daemon_running() -> None:
-    """Checks if the Docker daemon is running. Raises DockerDaemonNotRunningError if not."""
-    try:
-        subprocess.run(
-            ["docker", "info"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-    except subprocess.CalledProcessError as e:
-        raise DockerDaemonNotRunningError from e
-
-
-def stop_all_running_containers() -> None:
-    check_docker_daemon_running()
-    running_containers = (
-        subprocess.check_output(["docker", "ps", "-q"], stderr=subprocess.DEVNULL)
-        .decode()
-        .strip()
-        .splitlines()
-    )
-    if len(running_containers) == 0:
-        return
-    subprocess.run(
-        ["docker", "stop"] + running_containers,
-        check=True,
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )

devservices-1.0.5/tests/utils/test_docker.py

@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-import subprocess
-from unittest import mock
-
-from devservices.utils.docker import stop_all_running_containers
-
-
-@mock.patch("subprocess.check_output")
-@mock.patch("subprocess.run")
-@mock.patch("devservices.utils.docker.check_docker_daemon_running")
-def test_stop_all_running_containers_none_running(
-    mock_check_docker_daemon_running: mock.Mock,
-    mock_run: mock.Mock,
-    mock_check_output: mock.Mock,
-) -> None:
-    mock_check_docker_daemon_running.return_value = None
-    mock_check_output.return_value = b""
-    stop_all_running_containers()
-    mock_check_docker_daemon_running.assert_called_once()
-    mock_check_output.assert_called_once_with(
-        ["docker", "ps", "-q"], stderr=subprocess.DEVNULL
-    )
-    mock_run.assert_not_called()
-
-
-@mock.patch("subprocess.check_output")
-@mock.patch("subprocess.run")
-@mock.patch("devservices.utils.docker.check_docker_daemon_running")
-def test_stop_all_running_containers(
-    mock_check_docker_daemon_running: mock.Mock,
-    mock_run: mock.Mock,
-    mock_check_output: mock.Mock,
-) -> None:
-    mock_check_docker_daemon_running.return_value = None
-    mock_check_output.return_value = b"container1\ncontainer2\n"
-    stop_all_running_containers()
-    mock_check_docker_daemon_running.assert_called_once()
-    mock_check_output.assert_called_once_with(
-        ["docker", "ps", "-q"], stderr=subprocess.DEVNULL
-    )
-    mock_run.assert_called_once_with(
-        ["docker", "stop", "container1", "container2"],
-        check=True,
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )