Anchor in-core editable installs in hatch env collector to project root (DataDog#23765)

* Use absolute paths for in-core editable installs in hatch env collector

The post-install command emitted by the ddev environment collector
referenced datadog_checks_base/dev with relative paths (`../...`),
which only resolved correctly when hatch happened to run the command
with CWD == integration root. Hatch <=1.9 silently cd'd into the
project root before running scripts; hatch 1.10+ preserves the
invocation CWD, so invoking hatch from a subdirectory (e.g.
`tests/lab/`) caused the install to look for the dependencies under
that subdirectory and fail with "Distribution not found".

Anchor both installs to `self.root.parent` (the integrations-core
checkout directory, determined by hatch via pyproject.toml lookup),
so the install commands work regardless of the hatch version or the
CWD hatch was invoked from.

* Add changelog entry for DataDog#23765

* Anchor ruff config and mypy config paths to the project root

Both `ruff_settings_dir` and the typing-script's `mypy --config-file`
relied on relative paths (`./pyproject.toml`, `..`, `../pyproject.toml`)
resolved from the invocation CWD. They had the same CWD-sensitivity
class of bug as the editable-install paths fixed earlier in this PR
and break the same way on hatch 1.10+ when invoked from a subdirectory.
Anchor them to `self.root` (the integration root, resolved by hatch
via pyproject.toml walk-up) so the emitted commands are stable.

Also add a regression suite for `format_base_package`,
`base_package_install_command`, `test_package_install_command`, and
`ruff_settings_dir` covering both the in-core (absolute path) and
non-core (PyPI package name) branches.

* Mark hatch env collector tests as a package and harden the install test

- Add __init__.py to the new ddev/tests/plugin/external/hatch/ subtree
  to match the convention used by every other ddev/tests/ subdir and
  avoid future filename collisions under pytest's default import mode.
- Clear DDEV_TEST_BASE_PACKAGE_VERSION in the in-core install test so a
  leaked env var can't short-circuit into the version branch and fail
  the assertion for a reason unrelated to path anchoring.
- Use pytest.param(id=...) on the format_base_package parametrize for
  self-describing test IDs.

* Derive local-path test expectations from the input for Windows portability

The two local_path parametrize cases hardcoded POSIX-style expected
strings, but format_base_package returns str(local_path), which renders
with backslashes on Windows. The ddev test target runs on windows-2022
in CI, so the equality assertion would fail there. Build the expected
string with an f-string over the same Path input.

* Quote absolute editable/config paths cross-platform in generated hatch scripts

Hatch runs post-install and lint/typing scripts with shell=True, so an absolute checkout path containing whitespace (e.g. /Users/Jane Doe or C:\Users\Jane Doe) was word-split before uv/ruff/mypy received it. shlex.quote only produces POSIX quoting, which cmd.exe ignores, so add a shell_quote helper that double-quotes on Windows and uses shlex.quote elsewhere, applied at each path interpolation site.

* Extract a fake_checkout fixture to dedupe whitespace-checkout test setup

Merges the plain/whitespace variants of the base and test package
install command tests into single parametrized tests, and reuses the
fixture for the ruff settings dir and lint command tests.

* Fix Windows CI failures in environment collector tests

Pin sys.platform and use PurePosixPath in test_format_base_package so
the raw-string assertion isn't broken by shlex.quote wrapping
backslash-laden WindowsPath strings in quotes on a Windows host.
Also fix the expected lint config path to match the separator each
underlying code path actually produces (forced '/' for ruff, native
join for mypy).

---------

Co-authored-by: Alexey Pilyugin <alexey.pilyugin@datadoghq.com>

Author: AAraKKe

ddev/changelog.d/23765.fixed

@@ -0,0 +1 @@
+Anchor in-core editable installs in the hatch environment collector to the project root so the post-install command works on hatch 1.10+ when invoked from a subdirectory of the integration. The generated install, lint, and typing commands now shell-quote those absolute paths so checkouts under a path containing whitespace work on both POSIX and Windows.

ddev/src/ddev/plugin/external/hatch/environment_collector.py

@@ -1,12 +1,21 @@
 import os
 import re
+import shlex
+import sys
 from functools import cached_property
-from pathlib import Path
 from typing import Any
 
 from hatch.env.collectors.plugin.interface import EnvironmentCollectorInterface
 
 
+def shell_quote(token: str) -> str:
+    """Quote a token for the shell Hatch runs commands through: cmd.exe on Windows, POSIX sh elsewhere."""
+    # Mypy has special recognition for sys.platform, not os.name.
+    if sys.platform == 'win32':
+        return f'"{token}"'
+    return shlex.quote(token)
+
+
 class DatadogChecksEnvironmentCollector(EnvironmentCollectorInterface):
     PLUGIN_NAME = 'datadog-checks'
 
@@ -80,7 +89,7 @@ def test_package_install_command(self):
         if not self.in_core_repo:
             return self.uv_install_command('datadog-checks-dev')
         elif not (self.is_test_package or self.is_dev_package):
-            return self.uv_install_command('-e', '../datadog_checks_dev')
+            return self.uv_install_command('-e', shell_quote(str(self.root.parent / 'datadog_checks_dev')))
 
     def base_package_install_command(self, features):
         from ddev.testing.constants import TestEnvVars
@@ -90,14 +99,16 @@ def base_package_install_command(self, features):
         elif not self.in_core_repo:
             return self.uv_install_command(self.format_base_package(features))
         elif not (self.is_base_package or self.is_dev_package):
-            return self.uv_install_command('-e', self.format_base_package(features, local=True))
+            return self.uv_install_command(
+                '-e', self.format_base_package(features, local_path=self.root.parent / 'datadog_checks_base')
+            )
 
     @staticmethod
-    def format_base_package(features, version='', local=False):
+    def format_base_package(features, version='', local_path=None):
         if not features:
             features = ['deps']
 
-        base_package = '../datadog_checks_base' if local else 'datadog-checks-base'
+        base_package = shell_quote(str(local_path)) if local_path is not None else 'datadog-checks-base'
         formatted = f'{base_package}[{",".join(sorted(features))}]'
         if version:
             formatted += f'=={version}'
@@ -161,17 +172,19 @@ def finalize_config(self, config):
             scripts.setdefault('benchmark', '_dd-benchmark')
 
     def lint_command(self, options: str, settings_dir: str) -> str:
+        config = shell_quote(f'{settings_dir}/pyproject.toml')
         return self.on_config(
             'disable-linter',
             "echo 'Linter is disabled for this environment'",
-            f'ruff check {options} --config {settings_dir}/pyproject.toml .',
+            f'ruff check {options} --config {config} .',
         )
 
     def formatter_command(self, options: str, settings_dir: str) -> str:
+        config = shell_quote(f'{settings_dir}/pyproject.toml')
         return self.on_config(
             'disable-formatter',
             "echo 'Formatter is disabled for this environment'",
-            f'ruff format {options} --config {settings_dir}/pyproject.toml .',
+            f'ruff format {options} --config {config} .',
         )
 
     def inject_ddtrace_dependency(self, env_config):
@@ -189,12 +202,12 @@ def inject_ddtrace_dependency(self, env_config):
 
     def ruff_settings_dir(self):
         # If the local pyproject.toml exists and has ruff configuration, use it
-        local_pyproject = Path("./pyproject.toml")
+        local_pyproject = self.root / 'pyproject.toml'
         if local_pyproject.exists():
             pyproject_text = local_pyproject.read_text()
             if re.search(r'\[tool\.ruff\]', pyproject_text):
-                return "."
-        return ".."
+                return str(self.root)
+        return str(self.root.parent)
 
     def get_initial_config(self):
         settings_dir = self.ruff_settings_dir()
@@ -234,9 +247,10 @@ def get_initial_config(self):
         config = {'lint': lint_env}
 
         if self.check_types:
-            lint_env['scripts']['typing'] = [
-                f'mypy --config-file=../pyproject.toml {" ".join(self.mypy_args)} {" ".join(self.mypy_files)}'.rstrip()
-            ]
+            mypy_config = shell_quote(f'--config-file={self.root.parent / "pyproject.toml"}')
+            mypy_args = ' '.join(self.mypy_args)
+            mypy_files = ' '.join(self.mypy_files)
+            lint_env['scripts']['typing'] = [f'mypy {mypy_config} {mypy_args} {mypy_files}'.rstrip()]
             lint_env['scripts']['all'].append('typing')
             lint_env['dependencies'].extend(self.mypy_deps)
 

ddev/tests/plugin/__init__.py

@@ -0,0 +1,3 @@
+# (C) Datadog, Inc. 2026-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)

ddev/tests/plugin/external/__init__.py

@@ -0,0 +1,3 @@
+# (C) Datadog, Inc. 2026-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)

ddev/tests/plugin/external/hatch/__init__.py

@@ -0,0 +1,3 @@
+# (C) Datadog, Inc. 2026-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)

ddev/tests/plugin/external/hatch/test_environment_collector.py

@@ -0,0 +1,187 @@
+# (C) Datadog, Inc. 2026-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+import shlex
+import sys
+from pathlib import Path, PurePosixPath
+
+import pytest
+
+from ddev.plugin.external.hatch.environment_collector import DatadogChecksEnvironmentCollector, shell_quote
+
+
+def tokenize(command):
+    """Tokenize a generated command the way a POSIX shell does (Hatch runs scripts with ``shell=True``)."""
+    return shlex.split(command.replace('{verbosity:flag:-1}', '-q'))
+
+
+@pytest.fixture
+def fake_checkout(tmp_path):
+    """Build a fake in-core checkout, returning `(integrations_core, integration_root)`."""
+
+    def _make(*extra_dirs, whitespace=False):
+        base = tmp_path / 'Jane Doe' if whitespace else tmp_path
+        integrations_core = base / 'integrations-core'
+        (integrations_core / 'datadog_checks_base').mkdir(parents=True)
+        for extra_dir in extra_dirs:
+            (integrations_core / extra_dir).mkdir()
+        integration_root = integrations_core / 'fake_integration'
+        integration_root.mkdir()
+        return integrations_core, integration_root
+
+    return _make
+
+
+@pytest.mark.parametrize(
+    'features, version, local_path, expected',
+    [
+        pytest.param(['deps'], '', None, 'datadog-checks-base[deps]', id='pypi_with_deps'),
+        pytest.param([], '', None, 'datadog-checks-base[deps]', id='pypi_empty_features_defaults_to_deps'),
+        pytest.param(['deps', 'http'], '', None, 'datadog-checks-base[deps,http]', id='pypi_multi_features'),
+        pytest.param(['deps'], '1.2.3', None, 'datadog-checks-base[deps]==1.2.3', id='pypi_with_version'),
+        pytest.param(
+            ['deps'],
+            '',
+            PurePosixPath('/repo') / 'integrations-core' / 'datadog_checks_base',
+            f"{PurePosixPath('/repo') / 'integrations-core' / 'datadog_checks_base'}[deps]",
+            id='local_path_with_deps',
+        ),
+        pytest.param(
+            ['deps', 'http'],
+            '',
+            PurePosixPath('/repo') / 'integrations-core' / 'datadog_checks_base',
+            f"{PurePosixPath('/repo') / 'integrations-core' / 'datadog_checks_base'}[deps,http]",
+            id='local_path_multi_features',
+        ),
+    ],
+)
+def test_format_base_package(monkeypatch, features, version, local_path, expected):
+    # Pin to a POSIX target: a native `Path` would render backslashes on a Windows host,
+    # which `shlex.quote` treats as unsafe and wraps in quotes, breaking the raw string comparison.
+    monkeypatch.setattr(sys, 'platform', 'linux')
+
+    assert DatadogChecksEnvironmentCollector.format_base_package(features, version=version, local_path=local_path) == (
+        expected
+    )
+
+
+@pytest.mark.parametrize('whitespace', [False, True], ids=['plain_checkout', 'whitespace_checkout'])
+def test_base_package_install_command_uses_absolute_path_in_core(fake_checkout, monkeypatch, tmp_path, whitespace):
+    monkeypatch.delenv('DDEV_TEST_BASE_PACKAGE_VERSION', raising=False)
+
+    integrations_core, integration_root = fake_checkout(whitespace=whitespace)
+    monkeypatch.chdir(tmp_path)
+
+    collector = DatadogChecksEnvironmentCollector(integration_root, {})
+    command = collector.base_package_install_command(features=None)
+
+    assert tokenize(command)[-1] == f"{integrations_core / 'datadog_checks_base'}[deps]"
+
+
+@pytest.mark.parametrize('whitespace', [False, True], ids=['plain_checkout', 'whitespace_checkout'])
+def test_test_package_install_command_uses_absolute_path_in_core(fake_checkout, whitespace):
+    integrations_core, integration_root = fake_checkout('datadog_checks_dev', whitespace=whitespace)
+
+    collector = DatadogChecksEnvironmentCollector(integration_root, {})
+    command = collector.test_package_install_command
+
+    assert tokenize(command)[-1] == str(integrations_core / 'datadog_checks_dev')
+
+
+@pytest.mark.parametrize(
+    'has_local_ruff_config, expected_relative_to',
+    [
+        pytest.param(True, 'self', id='local_ruff_config_returns_integration_root'),
+        pytest.param(False, 'parent', id='no_local_ruff_config_returns_repo_root'),
+    ],
+)
+def test_ruff_settings_dir_uses_absolute_path(
+    fake_checkout, monkeypatch, tmp_path, has_local_ruff_config, expected_relative_to
+):
+    integrations_core, integration_root = fake_checkout()
+
+    pyproject = '[project]\nname = "fake"\n'
+    if has_local_ruff_config:
+        pyproject += '\n[tool.ruff]\nline-length = 120\n'
+    (integration_root / 'pyproject.toml').write_text(pyproject)
+
+    monkeypatch.chdir(tmp_path)
+
+    collector = DatadogChecksEnvironmentCollector(integration_root, {})
+    settings_dir = collector.ruff_settings_dir()
+
+    expected = str(integration_root) if expected_relative_to == 'self' else str(integrations_core)
+    assert settings_dir == expected
+    assert settings_dir not in ('.', '..')
+
+
+def test_format_base_package_quotes_local_path_with_whitespace():
+    local_path = Path('/Users/Jane Doe/integrations-core/datadog_checks_base')
+
+    token = DatadogChecksEnvironmentCollector.format_base_package(['deps'], local_path=local_path)
+    command = DatadogChecksEnvironmentCollector.uv_install_command('-e', token)
+
+    assert tokenize(command)[-1] == f'{local_path}[deps]'
+
+
+@pytest.mark.parametrize(
+    'platform, path, expected',
+    [
+        pytest.param('linux', '/Users/Jane Doe/integrations-core', "'/Users/Jane Doe/integrations-core'", id='linux'),
+        pytest.param('darwin', '/Users/Jane Doe/integrations-core', "'/Users/Jane Doe/integrations-core'", id='macos'),
+        pytest.param(
+            'win32', r'C:\Users\Jane Doe\integrations-core', r'"C:\Users\Jane Doe\integrations-core"', id='win'
+        ),
+    ],
+)
+def test_shell_quote_matches_target_shell(monkeypatch, platform, path, expected):
+    monkeypatch.setattr(sys, 'platform', platform)
+
+    assert shell_quote(path) == expected
+
+
+def test_shell_quote_windows_groups_whitespace_path_into_one_token(monkeypatch):
+    monkeypatch.setattr(sys, 'platform', 'win32')
+    path = r'C:\Users\Jane Doe\integrations-core\datadog_checks_base'
+
+    quoted = shell_quote(path)
+
+    # cmd.exe treats a double-quoted span as a single argument; the path is recovered intact, spaces and all.
+    assert quoted == f'"{path}"'
+    assert quoted[1:-1] == path
+
+
+def test_format_base_package_double_quotes_local_path_on_windows(monkeypatch):
+    monkeypatch.setattr(sys, 'platform', 'win32')
+    local_path = Path('/Users/Jane Doe/integrations-core/datadog_checks_base')
+
+    token = DatadogChecksEnvironmentCollector.format_base_package(['deps'], local_path=local_path)
+
+    assert token == f'"{local_path}"[deps]'
+
+
+@pytest.mark.parametrize(
+    'script_name, config_flag',
+    [
+        pytest.param('style', '--config', id='ruff_style'),
+        pytest.param('fmt', '--config', id='ruff_fmt'),
+        pytest.param('typing', '--config-file', id='mypy_typing'),
+    ],
+)
+def test_lint_commands_survive_whitespace_checkout(fake_checkout, monkeypatch, tmp_path, script_name, config_flag):
+    integrations_core, integration_root = fake_checkout(whitespace=True)
+    monkeypatch.chdir(tmp_path)
+
+    collector = DatadogChecksEnvironmentCollector(integration_root, {'check-types': True})
+    scripts = collector.get_initial_config()['lint']['scripts']
+
+    for command in scripts[script_name]:
+        tokens = tokenize(command)
+        if config_flag == '--config-file':
+            # mypy's config path is built with `Path.__truediv__`, which uses the native separator.
+            config_path = str(integrations_core / 'pyproject.toml')
+            assert f'--config-file={config_path}' in tokens
+        else:
+            # ruff's config path is always joined with `/`, regardless of platform.
+            config_path = f'{integrations_core}/pyproject.toml'
+            assert config_path == tokens[tokens.index('--config') + 1]