devservices 1.5.0__tar.gz → 1.5.3__tar.gz

{devservices-1.5.0 → devservices-1.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devservices
-Version: 1.5.0
+Version: 1.5.3
 Requires-Python: >=3.11
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.5.0 → devservices-1.5.3}/README.md

@@ -33,7 +33,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.5.0
+devservices==1.5.3
 ```
 
 ### 2. Add devservices config files

{devservices-1.5.0 → devservices-1.5.3}/devservices/commands/up.py

@@ -30,6 +30,7 @@ from devservices.exceptions import SupervisorError
 from devservices.utils.console import Console
 from devservices.utils.console import Status
 from devservices.utils.dependencies import DependencyNode
+from devservices.utils.dependencies import DependencyUpdateMode
 from devservices.utils.dependencies import InstalledRemoteDependency
 from devservices.utils.dependencies import construct_dependency_graph
 from devservices.utils.dependencies import install_and_verify_dependencies
@@ -68,6 +69,12 @@ def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
         action="store_true",
         default=False,
     )
+    parser.add_argument(
+        "--offline",
+        help="Use cached dependencies and images without accessing the network",
+        action="store_true",
+        default=False,
+    )
     parser.set_defaults(func=up)
 
 
@@ -96,6 +103,7 @@ def up(args: Namespace, existing_status: Status | None = None) -> None:
     modes = service.config.modes
     mode = args.mode
     exclude_local = getattr(args, "exclude_local", False)
+    offline = getattr(args, "offline", False)
 
     sentry_logger.info(
         "Starting service",
@@ -162,7 +170,9 @@ def up(args: Namespace, existing_status: Status | None = None) -> None:
             },
         )
 
-        remote_dependencies = _install_service_dependencies(service, mode, status)
+        remote_dependencies = _install_service_dependencies(
+            service, mode, status, offline
+        )
         _create_devservices_network()
         # Add the service to the starting services table
         state.update_service_entry(service.name, mode, StateTables.STARTING_SERVICES)
@@ -204,6 +214,7 @@ def up(args: Namespace, existing_status: Status | None = None) -> None:
                         service_name=local_runtime_dependency_name,
                         mode="default",  # We intentionally don't use the mode from the parent command here
                         exclude_local=True,  # TODO: This should be False (or maybe whatever the parent command is set to)
+                        offline=offline,
                     ),
                     status,
                 )
@@ -216,7 +227,12 @@ def up(args: Namespace, existing_status: Status | None = None) -> None:
             span.set_data("exclude_local", exclude_local)
             try:
                 bring_up_docker_compose_services(
-                    service, [mode], remote_dependencies, mode_dependencies, status
+                    service,
+                    [mode],
+                    remote_dependencies,
+                    mode_dependencies,
+                    status,
+                    offline,
                 )
             except DockerComposeError as dce:
                 capture_exception(dce, level="info")
@@ -239,25 +255,39 @@ def up(args: Namespace, existing_status: Status | None = None) -> None:
 
 
 def _install_service_dependencies(
-    service: Service, mode: str, status: Status
+    service: Service, mode: str, status: Status, offline: bool = False
 ) -> set[InstalledRemoteDependency]:
     with start_span(
         op="service.dependencies.install", name="Install dependencies"
     ) as span:
-        status.info("Retrieving dependencies")
+        status.info(
+            "Using cached dependencies" if offline else "Retrieving dependencies"
+        )
         span.set_data("service_name", service.name)
         span.set_data("mode", mode)
+        span.set_data("offline", offline)
+
+        update_mode = (
+            DependencyUpdateMode.OFFLINE if offline else DependencyUpdateMode.FORCE
+        )
         try:
             remote_dependencies = install_and_verify_dependencies(
-                service, force_update_dependencies=True, modes=[mode]
+                service,
+                update_mode,
+                modes=[mode],
             )
             span.set_data("remote_dependency_count", len(remote_dependencies))
             return remote_dependencies
         except DependencyError as de:
             capture_exception(de)
-            status.failure(
-                f"{str(de)}. If this error persists, try running `devservices purge`"
-            )
+            if offline:
+                status.failure(
+                    f"{str(de)}. Run `devservices up` without `--offline` to fetch and cache dependencies"
+                )
+            else:
+                status.failure(
+                    f"{str(de)}. If this error persists, try running `devservices purge`"
+                )
             exit(1)
         except ModeDoesNotExistError as mde:
             status.failure(str(mde))
@@ -310,6 +340,7 @@ def bring_up_docker_compose_services(
     remote_dependencies: set[InstalledRemoteDependency],
     mode_dependencies: list[str],
     status: Status,
+    offline: bool = False,
 ) -> None:
     relative_local_dependency_directory = os.path.relpath(
         os.path.join(DEVSERVICES_DEPENDENCIES_CACHE_DIR, DEPENDENCY_CONFIG_VERSION),
@@ -334,35 +365,41 @@ def bring_up_docker_compose_services(
         ),
     )
 
-    # Pull all images in parallel
-    status.info("Pulling images")
-    pull_commands = get_docker_compose_commands_to_run(
-        service=service,
-        remote_dependencies=sorted_remote_dependencies,
-        current_env=current_env,
-        command="pull",
-        options=[],
-        service_config_file_path=service_config_file_path,
-        mode_dependencies=mode_dependencies,
-    )
-
-    with concurrent.futures.ThreadPoolExecutor() as pull_dependency_executor:
-        futures = [
-            pull_dependency_executor.submit(
-                _pull_dependency_images, cmd, current_env, status
-            )
-            for cmd in pull_commands
-        ]
-        for future in concurrent.futures.as_completed(futures):
-            _ = future.result()
+    if offline:
+        status.info("Skipping image pull (offline mode)")
+    else:
+        # Pull all images in parallel
+        status.info("Pulling images")
+        pull_commands = get_docker_compose_commands_to_run(
+            service=service,
+            remote_dependencies=sorted_remote_dependencies,
+            current_env=current_env,
+            command="pull",
+            options=[],
+            service_config_file_path=service_config_file_path,
+            mode_dependencies=mode_dependencies,
+        )
 
-    # Bring up all necessary containers
+        with concurrent.futures.ThreadPoolExecutor() as pull_dependency_executor:
+            futures = [
+                pull_dependency_executor.submit(
+                    _pull_dependency_images, cmd, current_env, status
+                )
+                for cmd in pull_commands
+            ]
+            for future in concurrent.futures.as_completed(futures):
+                _ = future.result()
+
+    # Bring up all necessary containers. In offline mode, never pull missing images.
+    up_options = ["-d"]
+    if offline:
+        up_options += ["--pull", "never"]
     up_commands = get_docker_compose_commands_to_run(
         service=service,
         remote_dependencies=sorted_remote_dependencies,
         current_env=current_env,
         command="up",
-        options=["-d"],
+        options=up_options,
         service_config_file_path=service_config_file_path,
         mode_dependencies=mode_dependencies,
     )

{devservices-1.5.0 → devservices-1.5.3}/devservices/exceptions.py

@@ -99,7 +99,12 @@ class DependencyError(Exception):
         self.stderr = stderr
 
     def __str__(self) -> str:
-        return f"DependencyError: {self.repo_name} ({self.repo_link}) on {self.branch}"
+        message = (
+            f"DependencyError: {self.repo_name} ({self.repo_link}) on {self.branch}"
+        )
+        if self.__cause__ is not None:
+            message += f" ({type(self.__cause__).__name__}: {self.__cause__})"
+        return message
 
 
 class InvalidDependencyConfigError(DependencyError):

{devservices-1.5.0 → devservices-1.5.3}/devservices/main.py

@@ -84,6 +84,13 @@ if not disable_sentry:
             ArgvIntegration(),
             LoggingIntegration(sentry_logs_level=logging.DEBUG),
         ],
+        # By default the Sentry SDK loads integrations for all relevant libraries in
+        # the venv. When running devservices in the seer directory we end up loading
+        # Hugging Face, OpenAI, Anthropic and Celery. Likewise in sentry we end up
+        # loading Django, Redis and boto3. This is in spite of devservices not
+        # actually using those libraries. By disabling this behaviour we can reduce
+        # startup time for devservices.
+        auto_enabling_integrations=False,
         enable_logs=True,
         environment=sentry_environment,
         before_send=before_send_error,

{devservices-1.5.0 → devservices-1.5.3}/devservices/utils/dependencies.py

@@ -10,6 +10,7 @@ from collections import deque
 from concurrent.futures import ThreadPoolExecutor
 from concurrent.futures import as_completed
 from dataclasses import dataclass
+from enum import StrEnum
 from typing import TypeGuard
 
 from sentry_sdk import logger as sentry_logger
@@ -113,13 +114,29 @@ class InstalledRemoteDependency:
     mode: str = "default"
 
 
+class DependencyUpdateMode(StrEnum):
+    """Controls how remote dependencies are resolved during installation.
+
+    FORCE always fetches from the network, IF_NEEDED uses the cache when valid and
+    otherwise fetches, and OFFLINE never fetches and raises if the cache is
+    incomplete.
+    """
+
+    FORCE = "force"
+    IF_NEEDED = "if_needed"
+    OFFLINE = "offline"
+
+
 def install_and_verify_dependencies(
     service: Service,
-    force_update_dependencies: bool = False,
+    update_mode: DependencyUpdateMode = DependencyUpdateMode.IF_NEEDED,
     modes: list[str] | None = None,
 ) -> set[InstalledRemoteDependency]:
     """
-    Install and verify dependencies for a service
+    Install and verify dependencies for a service.
+
+    update_mode controls whether dependencies are fetched from the network. See
+    DependencyUpdateMode.
     """
     if modes is None:
         modes = ["default"]
@@ -138,18 +155,18 @@ def install_and_verify_dependencies(
         if dependency_key in mode_dependencies
     ]
 
-    if force_update_dependencies:
-        remote_dependencies = install_dependencies(matching_dependencies)
+    skip_dependency_install = update_mode is DependencyUpdateMode.OFFLINE or (
+        update_mode is DependencyUpdateMode.IF_NEEDED
+        and verify_local_dependencies(matching_dependencies)
+    )
+
+    if skip_dependency_install:
+        remote_dependencies = get_installed_remote_dependencies(matching_dependencies)
     else:
-        are_dependencies_valid = verify_local_dependencies(matching_dependencies)
-        if not are_dependencies_valid:
-            # TODO: Figure out how to handle this case as installing dependencies may not be the right thing to do
-            #       since the dependencies may have changed since the service was started.
-            remote_dependencies = install_dependencies(matching_dependencies)
-        else:
-            remote_dependencies = get_installed_remote_dependencies(
-                matching_dependencies
-            )
+        # TODO: Figure out how to handle this case as installing dependencies may not be the right thing to do
+        #       since the dependencies may have changed since the service was started.
+        remote_dependencies = install_dependencies(matching_dependencies)
+
     return remote_dependencies
 
 
@@ -275,9 +292,10 @@ def get_installed_remote_dependencies(
                 mode=remote_config.mode,
             )
         )
-        nested_remote_configs = _get_remote_configs(
-            list(service_config.dependencies.values())
+        active_nested_dependencies = _get_active_nested_dependencies(
+            service_config, remote_config.mode
         )
+        nested_remote_configs = _get_remote_configs(active_nested_dependencies)
         remote_configs.extend(nested_remote_configs)
 
     return installed_dependencies
@@ -359,18 +377,9 @@ def install_dependency(dependency: RemoteConfig) -> set[InstalledRemoteDependenc
                 branch=dependency.branch,
             ) from e
 
-    if dependency.mode not in installed_config.modes:
-        raise ModeDoesNotExistError(
-            service_name=installed_config.service_name,
-            mode=dependency.mode,
-            available_modes=list(installed_config.modes.keys()),
-        )
-
-    active_nested_dependencies = [
-        nested_dependency
-        for nested_dependency_name, nested_dependency in installed_config.dependencies.items()
-        if nested_dependency_name in installed_config.modes[dependency.mode]
-    ]
+    active_nested_dependencies = _get_active_nested_dependencies(
+        installed_config, dependency.mode
+    )
     nested_remote_configs = _get_remote_configs(active_nested_dependencies)
 
     installed_dependencies: set[InstalledRemoteDependency] = set(
@@ -399,6 +408,14 @@ def install_dependency(dependency: RemoteConfig) -> set[InstalledRemoteDependenc
     return installed_dependencies
 
 
+def _is_retryable_download_error(e: BaseException) -> bool:
+    # GitHub's API intermittently returns 5xx (and 429 when throttled). Those
+    # are worth retrying; other HTTP errors (404, 401, 403) won't fix themselves.
+    if isinstance(e, urllib.error.HTTPError):
+        return e.code >= 500 or e.code == 429
+    return True
+
+
 def _fetch_dependency(
     dependency: RemoteConfig,
     dependency_repo_dir: str,
@@ -431,8 +448,11 @@ def _fetch_dependency(
         zip_data = io.BytesIO(
             retry(
                 _download,
+                retries=5,
+                delay=1.0,
+                backoff=2.0,
                 exceptions=(OSError,),
-                should_retry=lambda e: not isinstance(e, urllib.error.HTTPError),
+                should_retry=_is_retryable_download_error,
             )
         )
     except (OSError, ValueError) as e:
@@ -484,6 +504,22 @@ def _fetch_dependency(
         ) from e
 
 
+def _get_active_nested_dependencies(
+    service_config: ServiceConfig, mode: str
+) -> list[Dependency]:
+    if mode not in service_config.modes:
+        raise ModeDoesNotExistError(
+            service_name=service_config.service_name,
+            mode=mode,
+            available_modes=list(service_config.modes.keys()),
+        )
+    return [
+        dependency
+        for dependency_name, dependency in service_config.dependencies.items()
+        if dependency_name in service_config.modes[mode]
+    ]
+
+
 def _get_remote_configs(dependencies: list[Dependency]) -> list[RemoteConfig]:
     return [
         dependency.remote

{devservices-1.5.0 → devservices-1.5.3}/devservices/utils/docker_compose.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import concurrent.futures
 import json
 import logging
 import os
@@ -254,17 +255,25 @@ def get_docker_compose_commands_to_run(
     service_config_file_path: str,
     mode_dependencies: list[str],
 ) -> list[DockerComposeCommand]:
+    dependency_config_paths = [
+        os.path.join(dependency.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME)
+        for dependency in remote_dependencies
+    ]
+
+    # Each lookup shells out to `docker compose config`, so run them concurrently
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        *dependency_non_remote_services, non_remote_services = executor.map(
+            lambda config_path: get_non_remote_services(config_path, current_env),
+            [*dependency_config_paths, service_config_file_path],
+        )
+
     docker_compose_commands = []
-    for dependency in remote_dependencies:
+    for dependency, dependency_config_path, dependency_services in zip(
+        remote_dependencies, dependency_config_paths, dependency_non_remote_services
+    ):
         # TODO: Consider passing in service config in InstalledRemoteDependency instead of loading it here
         dependency_service_config = load_service_config_from_file(dependency.repo_path)
-        dependency_config_path = os.path.join(
-            dependency.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
-        )
-        non_remote_services = get_non_remote_services(
-            dependency_config_path, current_env
-        )
-        services_to_use = non_remote_services.intersection(
+        services_to_use = dependency_services.intersection(
             set(dependency_service_config.modes[dependency.mode])
         )
         docker_compose_commands.append(
@@ -278,7 +287,6 @@ def get_docker_compose_commands_to_run(
         )
 
     # Add docker compose command for the top level service
-    non_remote_services = get_non_remote_services(service_config_file_path, current_env)
     services_to_use = non_remote_services.intersection(set(mode_dependencies))
     if len(services_to_use) > 0:
         docker_compose_commands.append(

{devservices-1.5.0 → devservices-1.5.3}/devservices/utils/retry.py

@@ -12,6 +12,7 @@ def retry(
     *,
     retries: int = 3,
     delay: float = 1.0,
+    backoff: float = 1.0,
     exceptions: tuple[type[BaseException], ...] = (Exception,),
     on_retry: Callable[[BaseException, int], None] | None = None,
     should_retry: Callable[[BaseException], bool] | None = None,
@@ -23,7 +24,8 @@ def retry(
     Args:
         fn: Callable to invoke.
         retries: Total number of attempts (must be >= 1).
-        delay: Seconds to sleep between attempts.
+        delay: Seconds to sleep before the first retry.
+        backoff: Multiplier applied to the delay after each retry.
         exceptions: Exception types that trigger a retry.
         on_retry: Optional callback(exc, attempts_remaining) invoked before each sleep.
         should_retry: Optional predicate; if it returns False the exception is re-raised
@@ -41,5 +43,5 @@ def retry(
                 raise
             if on_retry is not None:
                 on_retry(e, retries - attempt - 1)
-            time.sleep(delay)
+            time.sleep(delay * backoff**attempt)
     raise AssertionError("unreachable")

{devservices-1.5.0 → devservices-1.5.3}/devservices.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devservices
-Version: 1.5.0
+Version: 1.5.3
 Requires-Python: >=3.11
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.5.0 → devservices-1.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devservices"
-version = "1.5.0"
+version = "1.5.3"
 # 3.11 is just for internal pypi compat
 # but we test/support on 3.13
 requires-python = ">=3.11"

{devservices-1.5.0 → devservices-1.5.3}/tests/utils/test_dependencies.py

@@ -106,7 +106,7 @@ def test_fetch_dependency_network_error(tmp_path: Path) -> None:
         _fetch_dependency(dep, str(tmp_path / "dest"))
 
 
-def test_fetch_dependency_http_error_not_retried(tmp_path: Path) -> None:
+def test_fetch_dependency_client_error_not_retried(tmp_path: Path) -> None:
     dep = RemoteConfig(
         repo_name="test-repo",
         branch="main",
@@ -125,10 +125,75 @@ def test_fetch_dependency_http_error_not_retried(tmp_path: Path) -> None:
     )
     with urlopen_mock as mock_urlopen, pytest.raises(DependencyError):
         _fetch_dependency(dep, str(tmp_path / "dest"))
-    # HTTP errors must not be retried, so urlopen is only ever called once.
+    # Client errors won't fix themselves, so urlopen is only ever called once.
     mock_urlopen.assert_called_once()
 
 
+def _http_error(code: int, msg: str) -> urllib.error.HTTPError:
+    return urllib.error.HTTPError(
+        url="https://api.github.com/repos/getsentry/test-repo/zipball/main",
+        code=code,
+        msg=msg,
+        hdrs=None,  # type: ignore[arg-type]
+        fp=None,
+    )
+
+
+@pytest.mark.parametrize(
+    ("code", "msg"),
+    [(500, "Internal Server Error"), (503, "Service Unavailable"), (429, "Too Many")],
+)
+def test_fetch_dependency_retries_transient_http_error(
+    tmp_path: Path, code: int, msg: str
+) -> None:
+    dep = RemoteConfig(
+        repo_name="test-repo",
+        branch="main",
+        repo_link="https://github.com/getsentry/test-repo",
+    )
+    zip_bytes = _make_zip_bytes(BASIC_SERVICE_CONFIG)
+    dest = str(tmp_path / "dest")
+    with (
+        mock.patch("devservices.utils.retry.time.sleep") as mock_sleep,
+        mock.patch(
+            "devservices.utils.dependencies.urllib.request.urlopen",
+            side_effect=[
+                _http_error(code, msg),
+                _http_error(code, msg),
+                _make_urlopen_response(zip_bytes),
+            ],
+        ) as mock_urlopen,
+    ):
+        _fetch_dependency(dep, dest)
+    assert mock_urlopen.call_count == 3
+    assert [c.args[0] for c in mock_sleep.call_args_list] == [1.0, 2.0]
+    assert (Path(dest) / DEVSERVICES_DIR_NAME / CONFIG_FILE_NAME).exists()
+
+
+def test_fetch_dependency_server_error_exhausts_retries(tmp_path: Path) -> None:
+    dep = RemoteConfig(
+        repo_name="test-repo",
+        branch="main",
+        repo_link="https://github.com/getsentry/test-repo",
+    )
+    with (
+        mock.patch("devservices.utils.retry.time.sleep") as mock_sleep,
+        mock.patch(
+            "devservices.utils.dependencies.urllib.request.urlopen",
+            side_effect=_http_error(500, "Internal Server Error"),
+        ) as mock_urlopen,
+        pytest.raises(DependencyError) as exc_info,
+    ):
+        _fetch_dependency(dep, str(tmp_path / "dest"))
+    assert mock_urlopen.call_count == 5
+    assert [c.args[0] for c in mock_sleep.call_args_list] == [1.0, 2.0, 4.0, 8.0]
+    # The underlying cause is surfaced so CI logs show what actually failed.
+    assert str(exc_info.value) == (
+        "DependencyError: test-repo (https://github.com/getsentry/test-repo) on main "
+        "(HTTPError: HTTP Error 500: Internal Server Error)"
+    )
+
+
 def test_fetch_dependency_read_error(tmp_path: Path) -> None:
     dep = RemoteConfig(
         repo_name="test-repo",
@@ -316,6 +381,87 @@ def test_get_installed_remote_dependencies_single_dep_installed(tmp_path: Path)
         }
 
 
+def test_get_installed_remote_dependencies_does_not_return_unnecessary_dependencies(
+    tmp_path: Path,
+) -> None:
+    """Cached traversal only returns nested deps in the active mode."""
+    with mock.patch(
+        "devservices.utils.dependencies.DEVSERVICES_DEPENDENCIES_CACHE_DIR",
+        str(tmp_path / "dependency-dir"),
+    ):
+        repo_a_config = {
+            "x-sentry-service-config": {
+                "version": 0.1,
+                "service_name": "repo-a",
+                "dependencies": {
+                    "repo-b": {
+                        "description": "nested dependency",
+                        "remote": {
+                            "repo_name": "repo-b",
+                            "repo_link": "https://github.com/getsentry/repo-b",
+                            "branch": "main",
+                        },
+                    },
+                    "unnecessary-repo": {
+                        "description": "unnecessary nested dependency",
+                        "remote": {
+                            "repo_name": "unnecessary-repo",
+                            "repo_link": "invalid-link",
+                            "branch": "main",
+                        },
+                    },
+                },
+                "modes": {"default": ["repo-b"], "other": ["unnecessary-repo"]},
+            },
+        }
+
+        with mock.patch(
+            "devservices.utils.dependencies.urllib.request.urlopen",
+            side_effect=_url_dispatch(
+                {
+                    "repo-a": _make_zip_bytes(repo_a_config),
+                    "repo-b": _make_zip_bytes(BASIC_SERVICE_CONFIG),
+                }
+            ),
+        ):
+            install_dependency(
+                RemoteConfig(
+                    repo_name="repo-a",
+                    branch="main",
+                    repo_link="https://github.com/getsentry/repo-a",
+                )
+            )
+
+            installed = get_installed_remote_dependencies(
+                dependencies=[
+                    Dependency(
+                        description="test repo",
+                        remote=RemoteConfig(
+                            repo_name="repo-a",
+                            branch="main",
+                            repo_link="https://github.com/getsentry/repo-a",
+                        ),
+                        dependency_type=DependencyType.SERVICE,
+                    )
+                ]
+            )
+
+        assert installed == {
+            InstalledRemoteDependency(
+                service_name="repo-a",
+                repo_path=str(
+                    tmp_path / "dependency-dir" / DEPENDENCY_CONFIG_VERSION / "repo-a"
+                ),
+            ),
+            InstalledRemoteDependency(
+                service_name="basic",
+                repo_path=str(
+                    tmp_path / "dependency-dir" / DEPENDENCY_CONFIG_VERSION / "repo-b"
+                ),
+            ),
+        }
+
+
 def test_install_dependency_invalid_repo(tmp_path: Path) -> None:
     with mock.patch(
         "devservices.utils.dependencies.DEVSERVICES_DEPENDENCIES_CACHE_DIR",

{devservices-1.5.0 → devservices-1.5.3}/tests/utils/test_docker_compose.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 import subprocess
+from collections.abc import Callable
 from pathlib import Path
 from unittest import mock
 
@@ -27,6 +28,21 @@ from devservices.utils.services import Service
 from testing.utils import create_mock_git_repo
 
 
+def mock_docker_compose_config_services(
+    services_by_repo_path: dict[str, str],
+) -> Callable[..., subprocess.CompletedProcess[str]]:
+    def _run(
+        cmd: list[str], *args: object, **kwargs: object
+    ) -> subprocess.CompletedProcess[str]:
+        config_path = cmd[cmd.index("-f") + 1]
+        repo_path = os.path.dirname(os.path.dirname(config_path))
+        return subprocess.CompletedProcess(
+            args=cmd, returncode=0, stdout=services_by_repo_path[repo_path]
+        )
+
+    return _run
+
+
 @mock.patch("subprocess.run")
 def test_check_docker_compose_version_success(mock_run: mock.Mock) -> None:
     mock_run.return_value.stdout = "2.29.7\n"
@@ -452,18 +468,12 @@ def test_get_all_commands_to_run_simple_remote(
         parent_service_repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
     mode_dependencies = service_config.modes["default"]
-    mock_run.side_effect = [
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="child-service\n",
-        ),
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="parent-service\n",
-        ),
-    ]
+    mock_run.side_effect = mock_docker_compose_config_services(
+        {
+            child_service_repo_path_str: "child-service\n",
+            parent_service_repo_path_str: "parent-service\n",
+        }
+    )
     commands = get_docker_compose_commands_to_run(
         service=service,
         remote_dependencies=remote_dependencies,
@@ -555,23 +565,13 @@ def test_get_all_commands_to_run_complex_remote(
         grandparent_service_repo_path_str, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
     mode_dependencies = service_config.modes["default"]
-    mock_run.side_effect = [
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="child-service\n",
-        ),
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="parent-service\n",
-        ),
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="grandparent-service\n",
-        ),
-    ]
+    mock_run.side_effect = mock_docker_compose_config_services(
+        {
+            child_service_repo_path_str: "child-service\n",
+            parent_service_repo_path_str: "parent-service\n",
+            grandparent_service_repo_path_str: "grandparent-service\n",
+        }
+    )
     commands = get_docker_compose_commands_to_run(
         service=service,
         remote_dependencies=list(remote_dependencies),
@@ -685,23 +685,13 @@ def test_get_all_commands_to_run_complex_shared_dependency(
         grandparent_service_repo_path_str, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
     )
     mode_dependencies = service_config.modes["default"]
-    mock_run.side_effect = [
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="child-service\n",
-        ),
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="parent-service\n",
-        ),
-        subprocess.CompletedProcess(
-            args=["docker", "compose", "config", "--services"],
-            returncode=0,
-            stdout="grandparent-service\n",
-        ),
-    ]
+    mock_run.side_effect = mock_docker_compose_config_services(
+        {
+            child_service_repo_path_str: "child-service\n",
+            parent_service_repo_path_str: "parent-service\n",
+            grandparent_service_repo_path_str: "grandparent-service\n",
+        }
+    )
     commands = get_docker_compose_commands_to_run(
         service=service,
         remote_dependencies=remote_dependencies,