Fix whl azypysdk env (#44065)

* fix whl environment for running in CI

Author: scbedd

argfile.json

@@ -110,7 +110,13 @@ def get_executable(self, isolate: bool, check_name: str, executable: str, packag
         return executable, staging_directory
 
     def run_venv_command(
-        self, executable: str, command: Sequence[str], cwd: str, check: bool = False, append_executable: bool = True
+        self,
+        executable: str,
+        command: Sequence[str],
+        cwd: str,
+        check: bool = False,
+        append_executable: bool = True,
+        immediately_dump: bool = False,
     ) -> subprocess.CompletedProcess[str]:
         """Run a command in the given virtual environment.
         - Prepends the virtual environment's bin directory to the PATH environment variable (if one exists)
@@ -149,9 +155,9 @@ def run_venv_command(
         logger.debug(f"VIRTUAL_ENV: {env['VIRTUAL_ENV']}.")
         logger.debug(f"PATH : {env['PATH']}.")
 
-        result = subprocess.run(
-            cmd_to_run, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=check, env=env
-        )
+        s_out = None if immediately_dump else subprocess.PIPE
+        s_err = None if immediately_dump else subprocess.PIPE
+        result = subprocess.run(cmd_to_run, cwd=cwd, stdout=s_out, stderr=s_err, text=True, check=check, env=env)
 
         return result
 

eng/tools/azure-sdk-tools/azpysdk/Check.py

@@ -25,6 +25,7 @@
 from .ruff import ruff
 from .verifytypes import verifytypes
 from .verify_sdist import verify_sdist
+from .whl import whl
 from .verify_whl import verify_whl
 from .bandit import bandit
 from .verify_keywords import verify_keywords
@@ -86,6 +87,7 @@ def build_parser() -> argparse.ArgumentParser:
     ruff().register(subparsers, [common])
     verifytypes().register(subparsers, [common])
     verify_sdist().register(subparsers, [common])
+    whl().register(subparsers, [common])
     verify_whl().register(subparsers, [common])
     bandit().register(subparsers, [common])
     verify_keywords().register(subparsers, [common])

eng/tools/azure-sdk-tools/azpysdk/main.py

@@ -1,18 +1,29 @@
 import argparse
-import tempfile
 import os
-from typing import Optional, List, Any
 import sys
-from subprocess import run
+from subprocess import CalledProcessError
+from typing import List, Optional
 
 from .Check import Check
 
 from ci_tools.functions import is_error_code_5_allowed, install_into_venv
-from ci_tools.variables import set_envvar_defaults
-from ci_tools.parsing import ParsedSetup
 from ci_tools.scenario.generation import create_package_and_install
+from ci_tools.variables import discover_repo_root, set_envvar_defaults
 from ci_tools.logging import logger
 
+REPO_ROOT = discover_repo_root()
+
+PACKAGING_REQUIREMENTS = [
+    "wheel==0.45.1",
+    "packaging==24.2",
+    "urllib3==2.2.3",
+    "tomli==2.2.1",
+    "build==1.2.2.post1",
+    "pkginfo==1.12.1.2",
+]
+
+TEST_TOOLS_REQUIREMENTS = os.path.join(REPO_ROOT, "eng/test_tools.txt")
+
 
 class whl(Check):
     def __init__(self) -> None:
@@ -27,64 +38,120 @@ def register(
         parents = parent_parsers or []
         p = subparsers.add_parser("whl", parents=parents, help="Run the whl check")
         p.set_defaults(func=self.run)
-        # TODO add mark_args, and other parameters
+        p.add_argument(
+            "--pytest-args",
+            nargs=argparse.REMAINDER,
+            help="Additional arguments forwarded to pytest.",
+        )
 
     def run(self, args: argparse.Namespace) -> int:
         """Run the whl check command."""
         logger.info("Running whl check...")
 
-        set_envvar_defaults()
+        set_envvar_defaults({"PROXY_URL": "http://localhost:5001"})
 
         targeted = self.get_targeted_directories(args)
+        if not targeted:
+            logger.warning("No target packages discovered for whl check.")
+            return 0
 
-        results: List[int] = []
+        overall_result = 0
 
         for parsed in targeted:
-            pkg = parsed.folder
-            executable, staging_directory = self.get_executable(args.isolate, args.command, sys.executable, pkg)
-
-            logger.info(f"Invoking check with {executable}")
-
-            self.install_dev_reqs(executable, args, pkg)
-
-            create_package_and_install(
-                distribution_directory=staging_directory,
-                target_setup=pkg,
-                skip_install=False,
-                cache_dir=None,
-                work_dir=staging_directory,
-                force_create=False,
-                package_type="wheel",
-                pre_download_disabled=False,
-                python_executable=executable,
-            )
-
-            # TODO: split sys.argv[1:] on -- and pass in everything after the -- as additional arguments
-            # TODO: handle mark_args
-            logger.info(f"Invoke pytest for {pkg}")
-            exit_code = run(
-                [executable, "-m", "pytest", "."]
-                + [
-                    "-rsfE",
-                    f"--junitxml={pkg}/test-junit-{args.command}.xml",
-                    "--verbose",
-                    "--cov-branch",
-                    "--durations=10",
-                    "--ignore=azure",
-                    "--ignore-glob=.venv*",
-                    "--ignore=build",
-                    "--ignore=.eggs",
-                    "--ignore=samples",
-                ],
-                cwd=pkg,
-            ).returncode
-
-            if exit_code != 0:
-                if exit_code == 5 and is_error_code_5_allowed(parsed.folder, parsed.name):
-                    logger.info("Exit code 5 is allowed, continuing execution.")
-                else:
-                    logger.info(f"pytest failed with exit code {exit_code}.")
-                    results.append(exit_code)
-
-        # final result is the worst case of all the results
-        return max(results)
+            package_dir = parsed.folder
+            package_name = parsed.name
+
+            executable, staging_directory = self.get_executable(args.isolate, args.command, sys.executable, package_dir)
+            logger.info(f"Processing {package_name} using interpreter {executable}")
+
+            try:
+                self._install_common_requirements(executable, package_dir)
+                self.install_dev_reqs(executable, args, package_dir)
+            except CalledProcessError as exc:
+                logger.error(f"Failed to install dependencies for {package_name}: {exc}")
+                overall_result = max(overall_result, exc.returncode or 1)
+                continue
+
+            try:
+                create_package_and_install(
+                    distribution_directory=staging_directory,
+                    target_setup=package_dir,
+                    skip_install=False,
+                    cache_dir=None,
+                    work_dir=staging_directory,
+                    force_create=False,
+                    package_type="wheel",
+                    pre_download_disabled=False,
+                    python_executable=executable,
+                )
+            except CalledProcessError as exc:
+                logger.error(f"Failed to build/install wheel for {package_name}: {exc}")
+                overall_result = max(overall_result, exc.returncode or 1)
+                continue
+
+            pytest_args = self._build_pytest_args(package_dir, args)
+            pytest_command = ["-m", "pytest", *pytest_args]
+            pytest_result = self.run_venv_command(executable, pytest_command, cwd=package_dir, immediately_dump=True)
+
+            if pytest_result.returncode != 0:
+                if pytest_result.returncode == 5 and is_error_code_5_allowed(package_dir, package_name):
+                    logger.info(
+                        "pytest exited with code 5 for %s, which is allowed for management or opt-out packages.",
+                        package_name,
+                    )
+                    # Align with tox: skip coverage when tests are skipped entirely
+                    continue
+
+                logger.error(f"pytest failed for {package_name} with exit code {pytest_result.returncode}.")
+                continue
+
+            coverage_command = [
+                os.path.join(REPO_ROOT, "eng/tox/run_coverage.py"),
+                "-t",
+                package_dir,
+                "-r",
+                REPO_ROOT,
+            ]
+            coverage_result = self.run_venv_command(executable, coverage_command, cwd=package_dir)
+            if coverage_result.returncode != 0:
+                logger.error(
+                    f"Coverage generation failed for {package_name} with exit code {coverage_result.returncode}."
+                )
+                if coverage_result.stdout:
+                    logger.error(coverage_result.stdout)
+                if coverage_result.stderr:
+                    logger.error(coverage_result.stderr)
+                overall_result = max(overall_result, coverage_result.returncode)
+
+        return overall_result
+
+    def _install_common_requirements(self, executable: str, package_dir: str) -> None:
+        install_into_venv(executable, PACKAGING_REQUIREMENTS, package_dir)
+
+        if os.path.exists(TEST_TOOLS_REQUIREMENTS):
+            install_into_venv(executable, ["-r", TEST_TOOLS_REQUIREMENTS], package_dir)
+        else:
+            logger.warning(f"Test tools requirements file not found at {TEST_TOOLS_REQUIREMENTS}.")
+
+    def _build_pytest_args(self, package_dir: str, args: argparse.Namespace) -> List[str]:
+        log_level = os.getenv("PYTEST_LOG_LEVEL", "51")
+        junit_path = os.path.join(package_dir, f"test-junit-{args.command}.xml")
+
+        default_args = [
+            "-rsfE",
+            f"--junitxml={junit_path}",
+            "--verbose",
+            "--cov-branch",
+            "--durations=10",
+            "--ignore=azure",
+            "--ignore=.tox",
+            "--ignore-glob=.venv*",
+            "--ignore=build",
+            "--ignore=.eggs",
+            "--ignore=samples",
+            f"--log-cli-level={log_level}",
+        ]
+
+        additional = args.pytest_args if args.pytest_args else []
+
+        return [*default_args, *additional, package_dir]

eng/tools/azure-sdk-tools/azpysdk/whl.py

@@ -121,10 +121,14 @@ def set_environment_from_dictionary(settings: Dict[str, str]) -> None:
             os.environ.setdefault(key, value)
 
 
-def set_envvar_defaults() -> None:
+def set_envvar_defaults(settings: Optional[Dict[str, str]] = None) -> None:
     """
     Sets default environment variables for any given process to our default dictionary.
     Args:
         settings (Dict[str, str]): A dictionary of environment variable names and their default values.
     """
     set_environment_from_dictionary(DEFAULT_ENVIRONMENT_VARIABLES)
+
+    if settings:
+        # this will override any defaults set prior in the case of override
+        set_environment_from_dictionary(settings)