codecov-cli 0.2.2__tar.gz → 0.3.1__tar.gz

{codecov-cli-0.2.2/codecov_cli.egg-info → codecov-cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codecov-cli
-Version: 0.2.2
+Version: 0.3.1
 Summary: Codecov Command Line Interface
 Author: Codecov
 Author-email: support@codecov.io

codecov-cli-0.3.1/codecov_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.1"

{codecov-cli-0.2.2 → codecov-cli-0.3.1}/codecov_cli/commands/labelanalysis.py

@@ -1,7 +1,7 @@
-import json
 import logging
+import pathlib
 import time
-from typing import List
+from typing import List, Optional
 
 import click
 import requests
@@ -55,9 +55,16 @@ logger = logging.getLogger("codecovcli")
 @click.option(
     "--dry-run",
     "dry_run",
-    help="Userful during setup. This will run the label analysis, but will print the result to stdout and terminate instead of calling the runner.process_labelanalysis_result",
+    help='Print list of tests to run and options that need to be added to the test runner as a space-separated list to stdout. Format is ATS_TESTS_TO_RUN="<options> <test_1> <test_2> ... <test_n>"',
     is_flag=True,
 )
+@click.option(
+    "--dry-run-output-path",
+    "dry_run_output_path",
+    help="Prints the dry-run list into dry_run_output_path (in addition to stdout)",
+    type=pathlib.Path,
+    default=None,
+)
 @click.pass_context
 def label_analysis(
     ctx: click.Context,
@@ -67,6 +74,7 @@ def label_analysis(
     runner_name: str,
     max_wait_time: str,
     dry_run: bool,
+    dry_run_output_path: Optional[pathlib.Path],
 ):
     enterprise_url = ctx.obj.get("enterprise_url")
     logger.debug(
@@ -137,7 +145,12 @@ def label_analysis(
         # Retry it
         eid = _send_labelanalysis_request(payload, url, token_header)
         if eid is None:
-            _fallback_to_collected_labels(requested_labels, runner, dry_run=dry_run)
+            _fallback_to_collected_labels(
+                requested_labels,
+                runner,
+                dry_run=dry_run,
+                dry_run_output_path=dry_run_output_path,
+            )
             return
 
     has_result = False
@@ -151,13 +164,25 @@ def label_analysis(
         )
         resp_json = resp_data.json()
         if resp_json["state"] == "finished":
+            logger.info(
+                "Received list of tests from Codecov",
+                extra=dict(
+                    extra_log_attributes=dict(
+                        processing_errors=resp_json.get("errors", [])
+                    )
+                ),
+            )
             request_result = _potentially_calculate_absent_labels(
-                resp_data.json()["result"], requested_labels
+                resp_json["result"], requested_labels
             )
             if not dry_run:
                 runner.process_labelanalysis_result(request_result)
             else:
-                _dry_run_output(LabelAnalysisRequestResult(request_result))
+                _dry_run_output(
+                    LabelAnalysisRequestResult(request_result),
+                    runner,
+                    dry_run_output_path,
+                )
             return
         if resp_json["state"] == "error":
             logger.error(
@@ -165,7 +190,10 @@ def label_analysis(
                 extra=dict(extra_log_attributes=dict(resp_json=resp_json)),
             )
             _fallback_to_collected_labels(
-                collected_labels=requested_labels, runner=runner, dry_run=dry_run
+                collected_labels=requested_labels,
+                runner=runner,
+                dry_run=dry_run,
+                dry_run_output_path=dry_run_output_path,
             )
             return
         if max_wait_time and (time.monotonic() - start_wait) > max_wait_time:
@@ -173,7 +201,10 @@ def label_analysis(
                 f"Exceeded max waiting time of {max_wait_time} seconds. Running all tests.",
             )
             _fallback_to_collected_labels(
-                collected_labels=requested_labels, runner=runner, dry_run=dry_run
+                collected_labels=requested_labels,
+                runner=runner,
+                dry_run=dry_run,
+                dry_run_output_path=dry_run_output_path,
             )
             return
         logger.info("Waiting more time for result...")
@@ -183,14 +214,6 @@ def label_analysis(
 def _potentially_calculate_absent_labels(
     request_result, requested_labels
 ) -> LabelAnalysisRequestResult:
-    logger.info(
-        "Received list of tests from Codecov",
-        extra=dict(
-            extra_log_attributes=dict(
-                processing_errors=request_result.get("errors", [])
-            )
-        ),
-    )
     if request_result["absent_labels"]:
         # This means that Codecov already calculated everything for us
         final_result = LabelAnalysisRequestResult(request_result)
@@ -285,20 +308,23 @@ def _send_labelanalysis_request(payload, url, token_header):
     return eid
 
 
-def _dry_run_output(result: LabelAnalysisRequestResult):
-    logger.info(
-        "Not executing tests because '--dry-run' is on. List of labels selected for running below."
-    )
-    logger.info("")
-    logger.info("Label groups:")
-    logger.info(
-        "- absent_labels: Set of new labels found in HEAD that are not present in BASE"
+def _dry_run_output(
+    result: LabelAnalysisRequestResult,
+    runner: LabelAnalysisRunnerInterface,
+    dry_run_output_path: Optional[pathlib.Path],
+):
+    labels_to_run = list(
+        set(
+            result.absent_labels
+            + result.global_level_labels
+            + result.present_diff_labels
+        )
     )
-    logger.info("- present_diff_labels: Set of labels affected by the git diff")
-    logger.info("- global_level_labels: Set of labels that possibly touch global code")
-    logger.info("- present_report_labels: Set of labels previously uploaded")
-    logger.info("")
-    logger.info(json.dumps(result))
+    output = runner.dry_run_runner_options + sorted(labels_to_run)
+    if dry_run_output_path is not None:
+        with open(dry_run_output_path, "w") as fd:
+            fd.write(" ".join(output) + "\n")
+    click.echo(f"ATS_TESTS_TO_RUN=\"{' '.join(output)}\"")
 
 
 def _fallback_to_collected_labels(
@@ -306,6 +332,7 @@ def _fallback_to_collected_labels(
     runner: LabelAnalysisRunnerInterface,
     *,
     dry_run: bool = False,
+    dry_run_output_path: Optional[pathlib.Path] = None,
 ) -> dict:
     logger.info("Trying to fallback on collected labels")
     if collected_labels:
@@ -321,6 +348,8 @@ def _fallback_to_collected_labels(
         if not dry_run:
             return runner.process_labelanalysis_result(fake_response)
         else:
-            return _dry_run_output(LabelAnalysisRequestResult(fake_response))
+            return _dry_run_output(
+                LabelAnalysisRequestResult(fake_response), runner, dry_run_output_path
+            )
     logger.error("Cannot fallback to collected labels because no labels were collected")
     raise click.ClickException("Failed to get list of labels to run")

{codecov-cli-0.2.2 → codecov-cli-0.3.1}/codecov_cli/helpers/config.py

@@ -15,6 +15,6 @@ def load_cli_config(codecov_yml_path: pathlib.Path):
         with open(codecov_yml_path, "r") as file_stream:
             return yaml.safe_load(file_stream.read())
     logger.warning(
-        f"File {codecov_yml_path} not found, or is not a file. Ignoring config."
+        f"Config file {codecov_yml_path} not found, or is not a file. Ignoring config."
     )
     return None

{codecov-cli-0.2.2 → codecov-cli-0.3.1}/codecov_cli/main.py

@@ -20,6 +20,8 @@ from codecov_cli.helpers.config import load_cli_config
 from codecov_cli.helpers.logging_utils import configure_logger
 from codecov_cli.helpers.versioning_systems import get_versioning_system
 
+from . import __version__
+
 logger = logging.getLogger("codecovcli")
 
 
@@ -34,13 +36,14 @@ logger = logging.getLogger("codecovcli")
 @click.option(
     "--codecov-yml-path",
     type=click.Path(path_type=pathlib.Path),
+    default=pathlib.Path("codecov.yml"),
 )
 @click.option(
     "--enterprise-url", "--url", "-u", help="Change the upload host (Enterprise use)"
 )
 @click.option("-v", "--verbose", "verbose", help="Use verbose logging", is_flag=True)
 @click.pass_context
-@click.version_option()
+@click.version_option(__version__, prog_name="codecovcli")
 def cli(
     ctx: click.Context,
     auto_load_params_from: typing.Optional[str],
@@ -52,9 +55,7 @@ def cli(
     ctx.help_option_names = ["-h", "--help"]
     ctx.obj["ci_adapter"] = get_ci_adapter(auto_load_params_from)
     ctx.obj["versioning_system"] = get_versioning_system()
-    ctx.obj["codecov_yaml"] = (
-        load_cli_config(codecov_yml_path) if codecov_yml_path else None
-    )
+    ctx.obj["codecov_yaml"] = load_cli_config(codecov_yml_path)
     if ctx.obj["codecov_yaml"] is None:
         logger.debug("No codecov_yaml found")
     ctx.obj["enterprise_url"] = enterprise_url

{codecov-cli-0.2.2 → codecov-cli-0.3.1}/codecov_cli/runners/python_standard_runner.py

@@ -53,30 +53,21 @@ class PythonStandardRunnerConfigParams(dict):
         """
         return self.get("strict_mode", False)
 
-    @property
-    def include_curr_dir(self) -> bool:
-        """
-        Only valid for 'strict mode'
-        Account for the difference 'pytest' vs 'python -m pytest'
-        https://docs.pytest.org/en/7.1.x/how-to/usage.html#calling-pytest-through-python-m-pytest
-        """
-        return self.get("include_curr_dir", True)
-
 
 def _include_curr_dir(method):
     """
     Account for the difference 'pytest' vs 'python -m pytest'
     https://docs.pytest.org/en/7.1.x/how-to/usage.html#calling-pytest-through-python-m-pytest
+    Used only in strict_mode
     """
 
     def call_method(self, *args, **kwargs):
-        include_curr_dir = self.params.include_curr_dir
         curr_dir = getcwd()
-        if include_curr_dir:
-            path.append(curr_dir)
+        path.append(curr_dir)
+
         result = method(self, *args, **kwargs)
-        if include_curr_dir:
-            path.remove(curr_dir)
+
+        path.remove(curr_dir)
         return result
 
     return call_method
@@ -106,6 +97,9 @@ def _execute_pytest_subprocess(
 
 
 class PythonStandardRunner(LabelAnalysisRunnerInterface):
+
+    dry_run_runner_options = ["--cov-context=test"]
+
     def __init__(self, config_params: Optional[dict] = None) -> None:
         super().__init__()
         if config_params is None:
@@ -150,10 +144,25 @@ class PythonStandardRunner(LabelAnalysisRunnerInterface):
         if p.exitcode != 0 or (result != pytest.ExitCode.OK and result != 0):
             message = f"Pytest exited with non-zero code {result}."
             message += "\nThis is likely not a problem with label-analysis. Check pytest's output and options."
-            message += "\n(you can check pytest options on the logs before the test session start)"
+            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 += "\n" + output
+            else:
+                message += "\n(you can check pytest options on the logs before the test session start)"
             raise click.ClickException(message)
         return output
 
+    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
@@ -170,7 +179,14 @@ class PythonStandardRunner(LabelAnalysisRunnerInterface):
         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."
-            message += "\n(you can check pytest options on the logs before the test session start)"
+
+            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()
@@ -230,14 +246,10 @@ class PythonStandardRunner(LabelAnalysisRunnerInterface):
         ]
         command_array = default_options + tests_to_run
         logger.info(
-            "Running tests. (run in verbose mode to get list of tests executed)",
-            extra=dict(
-                extra_log_attributes=dict(
-                    pytest_options=default_options,
-                    executed_tests_count=len(tests_to_run),
-                )
-            ),
+            "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)),
@@ -246,5 +258,6 @@ class PythonStandardRunner(LabelAnalysisRunnerInterface):
             output = self._execute_pytest_strict(command_array, capture_output=False)
         else:
             output = self._execute_pytest(command_array, capture_output=False)
-        logger.info("Finished running tests successfully")
+        logger.info(f"Finished running {len(tests_to_run)} tests successfully")
+        logger.info(f"  pytest options: \"{' '.join(default_options)}\"")
         logger.debug(output)

{codecov-cli-0.2.2 → codecov-cli-0.3.1}/codecov_cli/runners/types.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import Dict, List
 
 
 # This is supposed to be a TypedDict,
@@ -23,7 +23,8 @@ class LabelAnalysisRequestResult(dict):
 
 
 class LabelAnalysisRunnerInterface(object):
-    params = None
+    params: Dict = None
+    dry_run_runner_options: List[str] = []
 
     def collect_tests(self) -> List[str]:
         raise NotImplementedError()

{codecov-cli-0.2.2 → codecov-cli-0.3.1}/codecov_cli/services/staticanalysis/analyzers/general.py

@@ -1,4 +1,5 @@
 import hashlib
+from collections import deque
 
 
 class BaseAnalyzer(object):
@@ -16,10 +17,26 @@ class BaseAnalyzer(object):
             count += 1
         return count
 
-    def _get_max_nested_conditional(self, node):
-        return (1 if node.type in self.condition_statements else 0) + max(
-            (self._get_max_nested_conditional(x) for x in node.children), default=0
-        )
+    def _get_max_nested_conditional(self, head):
+        """Iterates over all nodes in a function body and returns the max nested conditional depth.
+        Uses BFS to avoid recursion calls (so we don't throw RecursionError)
+        """
+        nodes_to_visit = deque()
+        nodes_to_visit.append([head, int(head.type in self.condition_statements)])
+        max_nested_depth = 0
+
+        while nodes_to_visit:
+            curr_node, curr_depth = nodes_to_visit.popleft()
+            max_nested_depth = max(max_nested_depth, curr_depth)
+            # Here is where the depth might change
+            # If the current node is a conditional
+            is_curr_conditional = curr_node.type in self.condition_statements
+
+            # Enqueue all child nodes of the curr_node
+            for child in curr_node.children:
+                nodes_to_visit.append([child, curr_depth + is_curr_conditional])
+
+        return max_nested_depth
 
     def _get_complexity_metrics(self, body_node):
         number_conditions = self._count_elements(

{codecov-cli-0.2.2 → codecov-cli-0.3.1/codecov_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codecov-cli
-Version: 0.2.2
+Version: 0.3.1
 Summary: Codecov Command Line Interface
 Author: Codecov
 Author-email: support@codecov.io

{codecov-cli-0.2.2 → codecov-cli-0.3.1}/codecov_cli.egg-info/requires.txt

@@ -2,7 +2,7 @@ click==8.*
 httpx==0.23.*
 ijson==3.*
 pytest==7.*
-pytest-cov==3.*
+pytest-cov>=3
 pyyaml==6.*
 responses==0.21.*
 smart-open==6.*

{codecov-cli-0.2.2 → codecov-cli-0.3.1}/setup.py

@@ -25,7 +25,7 @@ setup(
         "httpx==0.23.*",
         "ijson==3.*",
         "pytest==7.*",
-        "pytest-cov==3.*",
+        "pytest-cov>=3",
         "pyyaml==6.*",
         "responses==0.21.*",
         "smart-open==6.*",

codecov-cli-0.2.2/codecov_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.2"