cleanup

Author: vitkyrka

datadog_checks_dev/datadog_checks/dev/__init__.py

@@ -3,7 +3,7 @@
 # Licensed under a 3-clause BSD style license (see LICENSE)
 from .__about__ import __version__
 from .conditions import WaitFor
-from .docker import docker_run, get_docker_hostname, get_e2e_discovery_metadata, get_e2e_process_discovery_metadata
+from .docker import docker_run, get_docker_hostname, get_e2e_discovery_metadata, get_e2e_process_discovery_metadata, process_e2e_docker_run
 from .env import environment_run
 from .errors import RetryError
 from .fs import chdir, get_here, temp_chdir, temp_dir

datadog_checks_dev/datadog_checks/dev/docker.py

@@ -287,6 +287,33 @@ def get_e2e_process_discovery_metadata(
     }
 
 
+def process_e2e_docker_run(
+    compose_file: str | os.PathLike[str],
+    env_vars: Mapping[str, str] | None = None,
+    conditions: Sequence | None = None,
+    service_name: str | None = None,
+    check_root: str | os.PathLike[str] | None = None,
+):
+    """Generator for process-autodiscovery e2e environments.
+
+    Yields the ``(config, metadata)`` tuple expected by ``dd_environment``, where
+    ``config`` is ``None`` (process autodiscovery must find and configure the check)
+    and ``metadata`` comes from :func:`get_e2e_process_discovery_metadata`.
+
+    Use with ``yield from`` in a ``dd_environment`` fixture::
+
+        elif is_process_e2e:
+            yield from process_e2e_docker_run(COMPOSE_FILE_PROCESS, env_vars=env_vars, conditions=conditions)
+    """
+    with docker_run(
+        compose_file=str(compose_file),
+        env_vars=env_vars,
+        conditions=list(conditions) if conditions is not None else None,
+        service_name=service_name,
+    ):
+        yield (None, get_e2e_process_discovery_metadata(check_root=check_root))
+
+
 def compose_file_active(compose_file):
     """
     Returns a `bool` indicating whether or not a compose file has any active services.

datadog_checks_dev/datadog_checks/dev/plugin/pytest.py

@@ -483,12 +483,21 @@ def enum_object_items(data_source, machine_name, object_name, detail_level):
 )
 
 
+PROCESS_E2E_ENV_NAME = 'e2e-process'
+
+
+@pytest.fixture(scope='session')
+def is_process_e2e() -> bool:
+    return os.getenv('DDEV_E2E_ENV_NAME') == PROCESS_E2E_ENV_NAME
+
+
 def pytest_configure(config):
     # pytest will emit warnings if these aren't registered ahead of time
     for ttype in TEST_TYPES:
         config.addinivalue_line('markers', '{}: {}'.format(ttype.name, ttype.description))
 
     config.addinivalue_line("markers", "latest_metrics: marker for verifying support of new metrics")
+    config.addinivalue_line("markers", "not_process_e2e: skip this test in the process autodiscovery e2e environment")
 
 
 def pytest_addoption(parser):
@@ -498,16 +507,24 @@ def pytest_addoption(parser):
 def pytest_collection_modifyitems(config, items):
     # at test collection time, this function gets called by pytest, see:
     # https://docs.pytest.org/en/latest/example/simple.html#control-skipping-of-tests-according-to-command-line-option
-    # if the particular option is not present, it will skip all tests marked `latest_metrics`
-    if config.getoption("--run-latest-metrics"):
-        # --run-check-metrics given in cli: do not skip slow tests
-        return
+    skip_latest_metrics = (
+        None
+        if config.getoption("--run-latest-metrics")
+        else pytest.mark.skip(reason="need --run-latest-metrics option to run")
+    )
+    skip_not_process_e2e = (
+        pytest.mark.skip(reason="not applicable in the process autodiscovery e2e environment")
+        if os.getenv('DDEV_E2E_ENV_NAME') == PROCESS_E2E_ENV_NAME
+        else None
+    )
 
-    skip_latest_metrics = pytest.mark.skip(reason="need --run-latest-metrics option to run")
     for item in items:
-        if "latest_metrics" in item.keywords:
+        if skip_latest_metrics and "latest_metrics" in item.keywords:
             item.add_marker(skip_latest_metrics)
 
+        if skip_not_process_e2e and "not_process_e2e" in item.keywords:
+            item.add_marker(skip_not_process_e2e)
+
         item_path = item.path
         if item_path is None:
             continue

ddev/src/ddev/e2e/constants.py

@@ -16,6 +16,7 @@ class E2EEnvVars:
     RESULT_FILE = 'DDEV_E2E_RESULT_FILE'
     LOGS_DIR_PREFIX = 'DDEV_E2E_ENV_TEMP_DIR_DD_LOG_'
     DOCKER_VOLUMES = 'DDEV_E2E_ENV_docker_volumes'
+    ENV_NAME = 'DDEV_E2E_ENV_NAME'
 
 
 class E2EMetadata:

ddev/src/ddev/e2e/run.py

@@ -19,12 +19,24 @@ def __init__(self, env: str, verbosity: int):
 
     @contextmanager
     def start(self) -> Generator[list[str], None, None]:
-        with EnvVars({E2EEnvVars.TEAR_DOWN: 'false', **get_hatch_env_vars(verbosity=self.__verbosity)}):
+        with EnvVars(
+            {
+                E2EEnvVars.TEAR_DOWN: 'false',
+                E2EEnvVars.ENV_NAME: self.__env,
+                **get_hatch_env_vars(verbosity=self.__verbosity),
+            }
+        ):
             yield self._base_command()
 
     @contextmanager
     def stop(self) -> Generator[list[str], None, None]:
-        with EnvVars({E2EEnvVars.SET_UP: 'false', **get_hatch_env_vars(verbosity=self.__verbosity)}):
+        with EnvVars(
+            {
+                E2EEnvVars.SET_UP: 'false',
+                E2EEnvVars.ENV_NAME: self.__env,
+                **get_hatch_env_vars(verbosity=self.__verbosity),
+            }
+        ):
             yield self._base_command()
 
     def _base_command(self) -> list[str]:

krakend/hatch.toml

@@ -24,9 +24,6 @@ KRAKEND_IS_LAB = "true"
 e2e-env = true
 dependencies = ["httpx"]
 
-[envs.e2e-process.env-vars]
-KRAKEND_IS_PROCESS_E2E = "true"
-
 [envs.e2e-process.overrides]
 matrix.krakend.env-vars = "KRAKEND_VERSION"
 matrix.krakend.dependencies = ["httpx"]

krakend/tests/conftest.py

@@ -8,7 +8,7 @@
 
 import pytest
 
-from datadog_checks.dev import docker_run, get_e2e_discovery_metadata, get_e2e_process_discovery_metadata
+from datadog_checks.dev import docker_run, get_e2e_discovery_metadata, process_e2e_docker_run
 from datadog_checks.dev.conditions import CheckEndpoints
 from datadog_checks.dev.structures import LazyFunction
 from datadog_checks.krakend import KrakendCheck
@@ -17,19 +17,14 @@
 
 COMPOSE_FILE_E2E = Path(__file__).parent / "docker" / "docker-compose.yml"
 COMPOSE_FILE_LAB = Path(__file__).parent / "lab" / "docker-compose.yml"
-COMPOSE_FILE_PROCESS_E2E = Path(__file__).parent / "docker-process" / "docker-compose.yml"
+COMPOSE_FILE_PROCESS_E2E = Path(__file__).parent / "docker" / "docker-compose.process.yml"
 
 
 @pytest.fixture(scope="session")
 def is_lab() -> bool:
     return os.environ.get("KRAKEND_IS_LAB", "false") == "true"
 
 
-@pytest.fixture(scope="session")
-def is_process_e2e() -> bool:
-    return os.environ.get("KRAKEND_IS_PROCESS_E2E", "false") == "true"
-
-
 def run_docker_lab(env_vars: dict[str, str], conditions: list[LazyFunction]):
     with docker_run(
         compose_file=str(COMPOSE_FILE_LAB),
@@ -66,18 +61,6 @@ def run_docker_e2e(env_vars: dict[str, str], conditions: list[LazyFunction]):
         )
 
 
-def run_docker_process_e2e(env_vars: dict[str, str], conditions: list[LazyFunction]):
-    with docker_run(
-        compose_file=str(COMPOSE_FILE_PROCESS_E2E),
-        env_vars=env_vars,
-        conditions=conditions,
-    ):
-        yield (
-            None,  # No static config — process autodiscovery must find and configure the check.
-            get_e2e_process_discovery_metadata(),
-        )
-
-
 @pytest.fixture(scope="session")
 def dd_environment(dd_save_state, is_lab, is_process_e2e):
     """
@@ -102,7 +85,7 @@ def dd_environment(dd_save_state, is_lab, is_process_e2e):
         conditions = [
             CheckEndpoints(OPEN_METRICS_ENDPOINT, attempts=120, wait=2),
         ]
-        yield from run_docker_process_e2e(env_vars, conditions)
+        yield from process_e2e_docker_run(COMPOSE_FILE_PROCESS_E2E, env_vars=env_vars, conditions=conditions)
     else:
         conditions = [
             CheckEndpoints(f"{GATEWAY_ENDPOINT}/__health", attempts=120, wait=2),

…/tests/docker-process/docker-compose.yml …/tests/docker/docker-compose.process.ymlkrakend/tests/docker-process/docker-compose.yml renamed to krakend/tests/docker/docker-compose.process.yml krakend/tests/docker-process/docker-compose.yml renamed to krakend/tests/docker/docker-compose.process.yml

@@ -3,5 +3,5 @@ services:
     image: krakend:${KRAKEND_VERSION}
     network_mode: host
     volumes:
-      - ../docker/krakend.json:/etc/krakend/krakend.json:ro
+      - ./krakend.json:/etc/krakend/krakend.json:ro
     command: ["run", "-d", "-c", "/etc/krakend/krakend.json"]

krakend/tests/test_e2e.py

@@ -10,18 +10,14 @@
 
 
 @pytest.mark.e2e
-def test_e2e(dd_agent_check, instance: InstanceBuilder, is_process_e2e):
-    if is_process_e2e:
-        pytest.skip('direct-config test does not apply to the process autodiscovery environment')
-
+@pytest.mark.not_process_e2e
+def test_e2e(dd_agent_check, instance: InstanceBuilder):
     config = {"init_config": {}, "instances": [instance(True, True, get_docker_hostname(), 9090)]}
 
     aggregator = dd_agent_check(config, check_rate=True)
 
-    metadata_metrics = get_metrics_from_metadata()
-
     aggregator.assert_metrics_using_metadata(
-        metadata_metrics,
+        get_metrics_from_metadata(),
         check_submission_type=True,
         check_symmetric_inclusion=True,
     )
@@ -34,37 +30,18 @@ def test_e2e_discovery(dd_agent_check_discovery, is_lab, is_process_e2e):
     # config discovery.
     if is_lab:
         pytest.skip('lab does not currently support configuration discovery')
-    if is_process_e2e:
-        pytest.skip('container discovery test does not apply to the process autodiscovery environment')
 
-    aggregator = dd_agent_check_discovery(check_rate=True)
-
-    metadata_metrics = get_metrics_from_metadata()
+    timeout = 90 if is_process_e2e else 30
+    aggregator = dd_agent_check_discovery(check_rate=True, discovery_timeout=timeout)
 
     aggregator.assert_metrics_using_metadata(
-        metadata_metrics,
+        get_metrics_from_metadata(),
         check_submission_type=True,
-        check_symmetric_inclusion=True,
+        check_symmetric_inclusion=not is_process_e2e,
     )
 
 
 @pytest.mark.e2e
-def test_e2e_discovery_all_candidates(dd_agent_check, is_process_e2e):
-    if is_process_e2e:
-        pytest.skip('all-candidates test requires Docker network metadata unavailable with host networking')
+@pytest.mark.not_process_e2e
+def test_e2e_discovery_all_candidates(dd_agent_check):
     assert_all_discovery_candidates_stable(dd_agent_check, KrakendCheck)
-
-
-@pytest.mark.e2e
-def test_e2e_process_discovery(dd_agent_check_discovery, is_process_e2e):
-    if not is_process_e2e:
-        pytest.skip('process discovery test only runs in the e2e-process environment')
-
-    aggregator = dd_agent_check_discovery(check_rate=True, discovery_timeout=90)
-
-    metadata_metrics = get_metrics_from_metadata()
-
-    aggregator.assert_metrics_using_metadata(
-        metadata_metrics,
-        check_submission_type=True,
-    )