codecov-cli 11.0.0__py3-none-any.whl

codecov_cli/plugins/pycoverage.py

@@ -0,0 +1,134 @@
+import logging
+import os
+import pathlib
+import shutil
+import subprocess
+import typing
+from glob import iglob
+
+import sentry_sdk
+
+from codecov_cli.helpers.folder_searcher import globs_to_regex, search_files
+from codecov_cli.plugins.types import PreparationPluginReturn
+
+coverage_files_regex = globs_to_regex([".coverage", ".coverage.*"])
+logger = logging.getLogger("codecovcli")
+
+
+class PycoverageConfig(dict):
+    @property
+    def project_root(self) -> typing.Optional[pathlib.Path]:
+        """
+        The project root to search for coverage files.
+        project_root: pathlib.Path [default os.getcwd()]
+        """
+        return self.get("project_root", pathlib.Path(os.getcwd()))
+
+    @property
+    def report_type(self) -> str:
+        """
+        Report type to generate.
+        Overridden if include_contexts == True
+        report_type: str [values xml|json; default xml]
+        """
+        return self.get("report_type", "xml")
+
+    @property
+    def path_to_coverage_file(self) -> str:
+        """
+        The coverage dir with .coverage file
+        If set, will not look search for coverage files
+        """
+        return self.get("path_to_coverage_file", None)
+
+    @property
+    def include_contexts(self) -> bool:
+        """
+        Includes test context in JSON report. Flag.
+        (test contexts are the test labels used in ATS)
+        include_contexts: bool [default True]
+        """
+        return self.get("include_contexts", True)
+
+
+class Pycoverage(object):
+    def __init__(self, config: dict):
+        self.config = PycoverageConfig(config)
+
+    def run_preparation(self, collector) -> PreparationPluginReturn:
+        with sentry_sdk.start_span(name="pycoverage"):
+            if shutil.which("coverage") is None:
+                logger.warning("coverage.py is not installed or can't be found.")
+                return
+
+            path_to_coverage_data = self._get_path_to_coverage()
+            if path_to_coverage_data is None:
+                logger.warning("No coverage data found to transform")
+                return
+            coverage_dir = pathlib.Path(path_to_coverage_data).parent
+            if self.config.report_type == "xml":
+                return self._generate_XML_report(coverage_dir)
+            if self.config.report_type == "json":
+                return self._generate_JSON_report(coverage_dir)
+            return PreparationPluginReturn(
+                success=False,
+                messages=[f"report type {self.config.report_type} unknown"],
+            )
+
+    def _get_path_to_coverage(self) -> pathlib.Path:
+        if self.config.path_to_coverage_file:
+            path = pathlib.Path(self.config.path_to_coverage_file)
+            if path.exists():
+                return pathlib.Path(self.config.path_to_coverage_file)
+            logger.warning(
+                f"Dir {self.config.path_to_coverage_file} doesn't exist or doesn't have .coverage file. Falling back to search"
+            )
+        return next(
+            search_files(
+                self.config.project_root,
+                [],
+                filename_include_regex=coverage_files_regex,
+                filename_exclude_regex=None,
+            ),
+            None,
+        )
+
+    def _generate_XML_report(self, dir: pathlib.Path) -> PreparationPluginReturn:
+        """Generates up-to-date XML report in the given directory"""
+        # the following if conditions avoid creating dummy .coverage file
+        if next(iglob(str(dir / ".coverage.*")), None) is not None:
+            logger.info(f"Running coverage combine -a in {dir}")
+            subprocess.run(["coverage", "combine", "-a"], cwd=dir)
+
+        if (dir / ".coverage").exists():
+            logger.info(f"Generating coverage.xml report in {dir}")
+            completed_process = subprocess.run(
+                ["coverage", "xml", "-i"], cwd=dir, capture_output=True
+            )
+
+            output = completed_process.stdout.decode().strip()
+            logger.info(output)
+        return PreparationPluginReturn(success=True, messages=[])
+
+    def _generate_JSON_report(self, dir: pathlib.Path):
+        if (dir / ".coverage").exists():
+            logger.info(
+                f"Generating JSON report in {dir}",
+                extra=dict(
+                    extra_log_attributes=dict(
+                        include_contexts=self.config.include_contexts
+                    )
+                ),
+            )
+            command = ["coverage", "json"]
+            if self.config.include_contexts:
+                command.append("--show-contexts")
+            completed_process = subprocess.run(command, cwd=dir, capture_output=True)
+
+            output = completed_process.stdout.decode().strip()
+            logger.info(output)
+            return PreparationPluginReturn(success=True, messages=[])
+        logger.warning(f".coverage file not found at {dir}. Parsing failed")
+        return PreparationPluginReturn(
+            success=False, messages=[f".coverage file not found at {dir}."]
+        )

codecov_cli/plugins/types.py

@@ -0,0 +1,8 @@
+import typing
+from dataclasses import dataclass
+
+
+@dataclass
+class PreparationPluginReturn(object):
+    success: bool
+    messages: typing.List[str]

codecov_cli/plugins/xcode.py

@@ -0,0 +1,117 @@
+import logging
+import os
+import pathlib
+import re
+import shutil
+import subprocess
+import typing
+from fnmatch import translate
+
+import sentry_sdk
+
+from codecov_cli.helpers.folder_searcher import globs_to_regex, search_files
+from codecov_cli.plugins.types import PreparationPluginReturn
+
+logger = logging.getLogger("codecovcli")
+
+
+class XcodePlugin(object):
+    def __init__(
+        self,
+        app_name: typing.Optional[str] = None,
+        derived_data_folder: typing.Optional[pathlib.Path] = None,
+    ):
+        self.derived_data_folder = (
+            derived_data_folder
+            or pathlib.Path("~/Library/Developer/Xcode/DerivedData").expanduser()
+        )
+
+        # this is to speed up processing and to build reports for the project being tested,
+        # if empty the plugin will build reports for every xcode project it finds
+        self.app_name = app_name or ""
+
+    def run_preparation(self, collector) -> PreparationPluginReturn:
+        with sentry_sdk.start_span(name="xcode"):
+            logger.debug("Running xcode plugin...")
+
+            if shutil.which("xcrun") is None:
+                logger.warning("xcrun is not installed or can't be found.")
+                return
+
+            logger.debug(f"DerivedData folder: {self.derived_data_folder}")
+
+            filename_include_regex = globs_to_regex(["*.profdata"])
+
+            matched_paths = list(
+                search_files(
+                    folder_to_search=self.derived_data_folder,
+                    folders_to_ignore=[],
+                    filename_include_regex=filename_include_regex,
+                )
+            )
+
+            if not matched_paths:
+                logger.warning("No swift data found.")
+                return
+
+            logger.info(
+                "Running swift coverage on the following list of files:",
+                extra=dict(
+                    extra_log_attributes=dict(
+                        matched_paths=[p.as_posix() for p in matched_paths]
+                    )
+                ),
+            )
+
+            for path in matched_paths:
+                self.swiftcov(path, self.app_name)
+
+            return PreparationPluginReturn(success=True, messages="")
+
+    def swiftcov(self, path: pathlib.Path, app_name: str) -> None:
+        directory = os.path.dirname(path)
+        build_dir = pathlib.Path(re.sub("(Build).*", "Build", directory))
+
+        for type in ["app", "framework", "xctest"]:
+            filename_include_regex = re.compile(translate(f"*.{type}"))
+            matched_dir_paths = search_files(
+                folder_to_search=build_dir,
+                folders_to_ignore=[],
+                filename_include_regex=filename_include_regex,
+                search_for_directories=True,
+            )
+
+            for dir_path in matched_dir_paths:
+                # proj name without extension
+                proj = dir_path.stem
+                if app_name == "" or (app_name.lower() in proj.lower()):
+                    logger.info(f"+ Building reports for {proj} {type}")
+                    proj_path = dir_path / proj
+                    dest = (
+                        proj_path
+                        if proj_path.is_file()
+                        else dir_path / "Contents/MacOS/{proj}"
+                    )
+                    output_file_name = f"{proj}.{type}.coverage.txt".replace(" ", "")
+                    self.run_llvm_cov(output_file_name, path, dest)
+
+    def run_llvm_cov(
+        self, output_file_name: str, path: pathlib.Path, dest: pathlib.Path
+    ) -> None:
+        with open(output_file_name, "w") as output_file:
+            s = subprocess.run(
+                [
+                    "xcrun",
+                    "llvm-cov",
+                    "show",
+                    "-instr-profile",
+                    str(path),
+                    str(dest),
+                ],
+                stdout=output_file,
+            )
+            # 0 = success
+            if s.returncode != 0:
+                logger.warning(f"llvm-cov failed to produce results for {dest}")
+            else:
+                logger.info(f"Generated {output_file_name} file successfully")

codecov_cli/runners/__init__.py

@@ -0,0 +1,80 @@
+import logging
+import typing
+from importlib import import_module
+
+import click
+
+from codecov_cli.runners.dan_runner import DoAnythingNowRunner
+from codecov_cli.runners.pytest_standard_runner import PytestStandardRunner
+from codecov_cli.runners.types import LabelAnalysisRunnerInterface
+
+logger = logging.getLogger("codecovcli")
+
+
+class UnableToFindRunner(Exception):
+    pass
+
+
+def _load_runner_from_yaml(
+    plugin_dict: typing.Dict, dynamic_params: typing.Dict
+) -> LabelAnalysisRunnerInterface:
+    try:
+        module_obj = import_module(plugin_dict["module"])
+        class_obj = getattr(module_obj, plugin_dict["class"])
+    except ModuleNotFoundError:
+        click.secho(
+            f"Unable to dynamically load module {plugin_dict['module']}",
+            err=True,
+        )
+        raise
+    except AttributeError:
+        click.secho(
+            f"Unable to dynamically load class {plugin_dict['class']} from module {plugin_dict['module']}",
+            err=True,
+        )
+        raise
+    try:
+        final_params = {**plugin_dict["params"], **dynamic_params}
+        return class_obj(**final_params)
+    except TypeError:
+        click.secho(
+            f"Unable to instantiate {class_obj} with parameters {final_params}",
+            err=True,
+        )
+        raise
+
+
+def get_runner(
+    cli_config, runner_name: str, dynamic_params: typing.Dict = None
+) -> LabelAnalysisRunnerInterface:
+    if dynamic_params is None:
+        dynamic_params = {}
+    if runner_name == "pytest":
+        config_params = cli_config.get("runners", {}).get("pytest", {})
+        # This is for backwards compatibility with versions <= 0.3.4
+        # In which the key for this config was 'python', not 'pytest'
+        if config_params == {}:
+            config_params = cli_config.get("runners", {}).get("python", {})
+            if config_params:
+                logger.warning(
+                    "Using 'python' to configure the PytestStandardRunner is deprecated. Please change to 'pytest'"
+                )
+        final_params = {**config_params, **dynamic_params}
+        return PytestStandardRunner(final_params)
+    elif runner_name == "dan":
+        config_params = cli_config.get("runners", {}).get("dan", {})
+        final_params = {**config_params, **dynamic_params}
+        return DoAnythingNowRunner(final_params)
+    logger.debug(
+        f"Trying to load runner {runner_name}",
+        extra=dict(
+            extra_log_attributes=dict(
+                available_runners=cli_config.get("runners", {}).keys()
+            )
+        ),
+    )
+    if cli_config and runner_name in cli_config.get("runners", {}):
+        return _load_runner_from_yaml(
+            cli_config["runners"][runner_name], dynamic_params=dynamic_params
+        )
+    raise UnableToFindRunner(f"Can't find runner {runner_name}")

codecov_cli/runners/dan_runner.py

@@ -0,0 +1,64 @@
+import json
+import subprocess
+from typing import List, Optional, Union
+
+from codecov_cli.runners.types import (
+    LabelAnalysisRequestResult,
+    LabelAnalysisRunnerInterface,
+)
+
+
+class DoAnythingNowConfigParams(dict):
+    @property
+    def collect_tests_command(self) -> Union[List[str], str]:
+        """
+        Command to run when collecting tests.
+        The output of this command needs to be a list of test labels,
+        one test label per line.
+        """
+        return self.get("collect_tests_command", None)
+
+    @property
+    def process_labelanalysis_result_command(self) -> Union[List[str], str]:
+        """
+        Command to run that handles the label analysis result.
+        The result will be passed as an argument to the command in JSON format.
+        """
+        return self.get("process_labelanalysis_result_command", None)
+
+
+class DoAnythingNowRunner(LabelAnalysisRunnerInterface):
+    def __init__(self, config_params: Optional[dict] = None) -> None:
+        super().__init__()
+        if config_params is None:
+            config_params = {}
+        self.params = DoAnythingNowConfigParams(config_params)
+
+    def collect_tests(self) -> List[str]:
+        command = self.params.collect_tests_command
+        if command is None:
+            raise Exception(
+                "DAN runner missing 'collect_tests_command' configuration value"
+            )
+        return list(
+            subprocess.run(command, check=True, capture_output=True)
+            .stdout.decode()
+            .splitlines()
+        )
+
+    def process_labelanalysis_result(self, result: LabelAnalysisRequestResult):
+        json_result = json.dumps(result)
+        command = self.params.process_labelanalysis_result_command
+        if command is None:
+            raise Exception(
+                "DAN runner missing 'process_labelanalysis_result_command' configuration value"
+            )
+        command_list = []
+        if isinstance(command, list):
+            command_list.extend(command)
+        else:
+            command_list.append(command)
+        command_list.append(json_result)
+        return subprocess.run(
+            command_list, check=True, capture_output=True
+        ).stdout.decode()

codecov_cli/runners/pytest_standard_runner.py

@@ -0,0 +1,184 @@
+import inspect
+import logging
+import random
+import subprocess
+from subprocess import CalledProcessError
+from sys import stdout
+from typing import List, Optional
+
+import click
+
+from codecov_cli.runners.types import (
+    LabelAnalysisRequestResult,
+    LabelAnalysisRunnerInterface,
+)
+
+logger = logging.getLogger("codecovcli")
+
+
+class PytestStandardRunnerConfigParams(dict):
+    @property
+    def python_path(self) -> str:
+        python_path = self.get("python_path")
+        return python_path or "python"
+
+    @property
+    def collect_tests_options(self) -> List[str]:
+        return self.get("collect_tests_options", [])
+
+    @property
+    def execute_tests_options(self) -> List[str]:
+        options = self.get("execute_tests_options", [])
+        if any(map(lambda option: option.startswith("--cov"), options)):
+            logger.warning(
+                "--cov option detected when running tests. Please use coverage_root config option instead"
+            )
+        return options
+
+    @property
+    def coverage_root(self) -> str:
+        """
+        The coverage root. This will be passed to --cov=<coverage_root_dir>
+        Default: ./
+        """
+        return self.get("coverage_root", "./")
+
+    @classmethod
+    def get_available_params(cls) -> List[str]:
+        """Lists all the @property attribute names of this class.
+        These attributes are considered the 'valid config options'
+        """
+        klass_methods = [
+            x
+            for x in dir(cls)
+            if (inspect.isdatadescriptor(getattr(cls, x)) and not x.startswith("__"))
+        ]
+        return klass_methods
+
+
+class PytestStandardRunner(LabelAnalysisRunnerInterface):
+    dry_run_runner_options = ["--cov-context=test"]
+    params: PytestStandardRunnerConfigParams
+
+    def __init__(self, config_params: Optional[dict] = None) -> None:
+        super().__init__()
+        if config_params is None:
+            config_params = {}
+        # Before we create the config params we emit warnings if any param is unknown
+        # So the user knows something is wrong with their config
+        self._possibly_warn_bad_config(config_params)
+        self.params = PytestStandardRunnerConfigParams(config_params)
+
+    def _possibly_warn_bad_config(self, config_params: dict):
+        available_config_params = (
+            PytestStandardRunnerConfigParams.get_available_params()
+        )
+        provided_config_params = config_params.keys()
+        for provided_param in provided_config_params:
+            if provided_param not in available_config_params:
+                logger.warning(f"Config parameter '{provided_param}' is unknown.")
+
+    def parse_captured_output_error(self, exp: CalledProcessError) -> str:
+        result = ""
+        for out_stream in [exp.stdout, exp.stderr]:
+            if out_stream:
+                if type(out_stream) is bytes:
+                    out_stream = out_stream.decode()
+                result += "\n" + out_stream
+        return result
+
+    def _execute_pytest(self, pytest_args: List[str], capture_output: bool = True):
+        """Handles calling pytest using subprocess.run.
+        Raises Exception if pytest fails
+        Returns the complete pytest output
+        """
+        command = [self.params.python_path, "-m", "pytest"] + pytest_args
+        try:
+            result = subprocess.run(
+                command,
+                capture_output=capture_output,
+                check=True,
+                stdout=(stdout if not capture_output else None),
+            )
+        except CalledProcessError as exp:
+            message = f"Pytest exited with non-zero code {exp.returncode}."
+            message += "\nThis is likely not a problem with label-analysis. Check pytest's output and options."
+
+            if capture_output:
+                # If pytest failed but we captured its output the user won't know what's wrong
+                # So we need to include that in the error message
+                message += "\nPYTEST OUTPUT:"
+                message += self.parse_captured_output_error(exp)
+            else:
+                message += "\n(you can check pytest options on the logs before the test session start)"
+            raise click.ClickException(message)
+        if capture_output:
+            return result.stdout.decode()
+
+    def collect_tests(self):
+        default_options = ["-q", "--collect-only"]
+        extra_args = self.params.collect_tests_options
+        options_to_use = default_options + extra_args
+        logger.info(
+            "Collecting tests",
+            extra=dict(
+                extra_log_attributes=dict(
+                    pytest_command=[self.params.python_path, "-m", "pytest"],
+                    pytest_options=options_to_use,
+                ),
+            ),
+        )
+
+        output = self._execute_pytest(options_to_use)
+        lines = output.split(sep="\n")
+        test_names = list(line for line in lines if ("::" in line and "test" in line))
+        return test_names
+
+    def process_labelanalysis_result(self, result: LabelAnalysisRequestResult):
+        default_options = [
+            f"--cov={self.params.coverage_root}",
+            "--cov-context=test",
+        ] + self.params.execute_tests_options
+        all_labels = set(
+            result.absent_labels
+            + result.present_diff_labels
+            + result.global_level_labels
+        )
+        skipped_tests = set(result.present_report_labels) - all_labels
+        if skipped_tests:
+            logger.info(
+                "Some tests are being skipped. (run in verbose mode to get list of tests skipped)",
+                extra=dict(
+                    extra_log_attributes=dict(skipped_tests_count=len(skipped_tests))
+                ),
+            )
+            logger.debug(
+                "List of skipped tests",
+                extra=dict(
+                    extra_log_attributes=dict(skipped_tests=sorted(skipped_tests))
+                ),
+            )
+
+        if len(all_labels) == 0:
+            all_labels = [random.choice(result.present_report_labels)]
+            logger.info(
+                "All tests are being skipped. Selected random label to run",
+                extra=dict(extra_log_attributes=dict(selected_label=all_labels[0])),
+            )
+        tests_to_run = [
+            label.split("[")[0] if "[" in label else label for label in all_labels
+        ]
+        command_array = default_options + tests_to_run
+        logger.info(
+            "Running tests. (run in verbose mode to get list of tests executed)"
+        )
+        logger.info(f'  pytest options: "{" ".join(default_options)}"')
+        logger.info(f"  executed tests: {len(tests_to_run)}")
+        logger.debug(
+            "List of tests executed",
+            extra=dict(extra_log_attributes=dict(executed_tests=tests_to_run)),
+        )
+        output = self._execute_pytest(command_array, capture_output=False)
+        logger.info(f"Finished running {len(tests_to_run)} tests successfully")
+        logger.info(f'  pytest options: "{" ".join(default_options)}"')
+        logger.debug(output)

codecov_cli/runners/types.py

@@ -0,0 +1,33 @@
+from typing import Dict, List
+
+
+# This is supposed to be a TypedDict,
+# But that is Python >= 3.7 only
+# So we are not using those
+class LabelAnalysisRequestResult(dict):
+    @property
+    def present_report_labels(self) -> List[str]:
+        return self.get("present_report_labels", [])
+
+    @property
+    def absent_labels(self) -> List[str]:
+        return self.get("absent_labels", [])
+
+    @property
+    def present_diff_labels(self) -> List[str]:
+        return self.get("present_diff_labels", [])
+
+    @property
+    def global_level_labels(self) -> List[str]:
+        return self.get("global_level_labels", [])
+
+
+class LabelAnalysisRunnerInterface(object):
+    params: Dict = None
+    dry_run_runner_options: List[str] = []
+
+    def collect_tests(self) -> List[str]:
+        raise NotImplementedError()
+
+    def process_labelanalysis_result(self, result: LabelAnalysisRequestResult):
+        raise NotImplementedError()