codecov-cli 0.1.8__tar.gz → 0.1.9__tar.gz

{codecov-cli-0.1.8/codecov_cli.egg-info → codecov-cli-0.1.9}/PKG-INFO

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

codecov-cli-0.1.9/codecov_cli/commands/empty_upload.py

@@ -0,0 +1,66 @@
+import logging
+import typing
+import uuid
+
+import click
+
+from codecov_cli.fallbacks import CodecovOption, FallbackFieldEnum
+from codecov_cli.helpers.git import GitService
+from codecov_cli.services.empty_upload import empty_upload_logic
+
+logger = logging.getLogger("codecovcli")
+
+
+@click.command()
+@click.option(
+    "-C",
+    "--sha",
+    "--commit-sha",
+    "commit_sha",
+    help="Commit SHA (with 40 chars)",
+    cls=CodecovOption,
+    fallback_field=FallbackFieldEnum.commit_sha,
+    required=True,
+)
+@click.option(
+    "-r",
+    "--slug",
+    "slug",
+    cls=CodecovOption,
+    fallback_field=FallbackFieldEnum.slug,
+    help="owner/repo slug used instead of the private repo token in Self-hosted",
+    envvar="CODECOV_SLUG",
+)
+@click.option(
+    "-t",
+    "--token",
+    help="Codecov upload token",
+    type=click.UUID,
+    envvar="CODECOV_TOKEN",
+)
+@click.option(
+    "--git-service",
+    cls=CodecovOption,
+    fallback_field=FallbackFieldEnum.git_service,
+    type=click.Choice(service.value for service in GitService),
+)
+@click.pass_context
+def empty_upload(
+    ctx,
+    commit_sha: str,
+    slug: typing.Optional[str],
+    token: typing.Optional[uuid.UUID],
+    git_service: typing.Optional[str],
+):
+    logger.debug(
+        "Starting empty upload process",
+        extra=dict(
+            extra_log_attributes=dict(
+                commit_sha=commit_sha,
+                slug=slug,
+                token=token,
+                service=git_service,
+            )
+        ),
+    )
+    return empty_upload_logic(commit_sha, slug, token, git_service)

{codecov-cli-0.1.8 → codecov-cli-0.1.9}/codecov_cli/commands/labelanalysis.py

@@ -6,6 +6,7 @@ import requests
 
 from codecov_cli.fallbacks import CodecovOption, FallbackFieldEnum
 from codecov_cli.runners import get_runner
+from codecov_cli.runners.types import LabelAnalysisRequestResult
 
 logger = logging.getLogger("codecovcli")
 
@@ -86,12 +87,14 @@ def label_analysis(
                 logger.info(
                     "Could not get set of tests to run. Falling back to running all collected tests."
                 )
-                fake_response = {
-                    "present_report_labels": [],
-                    "absent_labels": requested_labels,
-                    "present_diff_labels": [],
-                    "global_level_labels": [],
-                }
+                fake_response = LabelAnalysisRequestResult(
+                    {
+                        "present_report_labels": [],
+                        "absent_labels": requested_labels,
+                        "present_diff_labels": [],
+                        "global_level_labels": [],
+                    }
+                )
                 return runner.process_labelanalysis_result(fake_response)
             raise click.ClickException("Sorry. Codecov is having problems")
         if response.status_code >= 400:
@@ -119,7 +122,9 @@ def label_analysis(
         )
         resp_json = resp_data.json()
         if resp_json["state"] == "finished":
-            runner.process_labelanalysis_result(resp_data.json()["result"])
+            runner.process_labelanalysis_result(
+                LabelAnalysisRequestResult(resp_data.json()["result"])
+            )
             return
         if resp_json["state"] == "error":
             logger.error(
@@ -128,12 +133,14 @@ def label_analysis(
             )
             if requested_labels:
                 logger.info("Using requested labels as tests to run")
-                fake_response = {
-                    "present_report_labels": [],
-                    "absent_labels": requested_labels,
-                    "present_diff_labels": [],
-                    "global_level_labels": [],
-                }
+                fake_response = LabelAnalysisRequestResult(
+                    {
+                        "present_report_labels": [],
+                        "absent_labels": requested_labels,
+                        "present_diff_labels": [],
+                        "global_level_labels": [],
+                    }
+                )
                 return runner.process_labelanalysis_result(fake_response)
             return
         logger.info("Waiting more time for result")

{codecov-cli-0.1.8 → codecov-cli-0.1.9}/codecov_cli/main.py

@@ -7,6 +7,7 @@ import click
 from codecov_cli.commands.base_picking import pr_base_picking
 from codecov_cli.commands.commit import create_commit
 from codecov_cli.commands.create_report_result import create_report_results
+from codecov_cli.commands.empty_upload import empty_upload
 from codecov_cli.commands.get_report_results import get_report_results
 from codecov_cli.commands.labelanalysis import label_analysis
 from codecov_cli.commands.report import create_report
@@ -61,6 +62,7 @@ cli.add_command(get_report_results)
 cli.add_command(pr_base_picking)
 cli.add_command(label_analysis)
 cli.add_command(static_analysis)
+cli.add_command(empty_upload)
 
 
 def run():

{codecov-cli-0.1.8 → codecov-cli-0.1.9}/codecov_cli/runners/dan_runner.py

@@ -1,5 +1,5 @@
 import subprocess
-from typing import List, TypedDict, Union
+from typing import List, Optional, Union
 
 from codecov_cli.runners.types import (
     LabelAnalysisRequestResult,
@@ -7,20 +7,25 @@ from codecov_cli.runners.types import (
 )
 
 
-class DoAnythingNowConfigParams(TypedDict):
-    collect_tests_command: Union[List[str], str]
-    process_labelanalysis_result_command: Union[List[str], str]
+class DoAnythingNowConfigParams(dict):
+    @property
+    def collect_tests_command(self) -> Union[List[str], str]:
+        return self.get("collect_tests_command", None)
+
+    @property
+    def process_labelanalysis_result_command(self) -> Union[List[str], str]:
+        return self.get("process_labelanalysis_result_command", None)
 
 
 class DoAnythingNowRunner(LabelAnalysisRunnerInterface):
-    def __init__(self, config_params: DoAnythingNowConfigParams = None) -> None:
+    def __init__(self, config_params: Optional[dict] = None) -> None:
         super().__init__()
         if config_params is None:
-            config_params = DoAnythingNowConfigParams()
-        self.params = config_params
+            config_params = {}
+        self.params = DoAnythingNowConfigParams(config_params)
 
     def collect_tests(self) -> List[str]:
-        command = self.params.get("collect_tests_command", None)
+        command = self.params.collect_tests_command
         if command is None:
             raise Exception(
                 "DAN runner missing 'collect_tests_command' configuration value"
@@ -28,7 +33,7 @@ class DoAnythingNowRunner(LabelAnalysisRunnerInterface):
         return subprocess.run(command, check=True, capture_output=True).stdout.decode()
 
     def process_labelanalysis_result(self, result: LabelAnalysisRequestResult):
-        command = self.params.get("process_labelanalysis_result_command", None)
+        command = self.params.process_labelanalysis_result_command
         if command is None:
             raise Exception(
                 "DAN runner missing 'process_labelanalysis_result_command' configuration value"

{codecov-cli-0.1.8 → codecov-cli-0.1.9}/codecov_cli/runners/python_standard_runner.py

@@ -1,10 +1,11 @@
 import logging
+import random
 from contextlib import redirect_stdout
 from io import StringIO, TextIOWrapper
 from multiprocessing import Queue, get_context
 from os import getcwd
 from sys import path, stdout
-from typing import List, TypedDict
+from typing import List, Optional
 
 import pytest
 
@@ -16,16 +17,23 @@ from codecov_cli.runners.types import (
 logger = logging.getLogger("codecovcli")
 
 
-class PythonStandardRunnerConfigParams(TypedDict):
-    collect_tests_options: List[str]
-    # include_dirs is to account for the difference described in
-    # https://docs.pytest.org/en/7.1.x/how-to/usage.html#calling-pytest-through-python-m-pytest
-    include_curr_dir: bool
+class PythonStandardRunnerConfigParams(dict):
+    @property
+    def collect_tests_options(self) -> List[str]:
+        return self.get("collect_tests_options", [])
+
+    @property
+    def include_curr_dir(self) -> bool:
+        """ "
+        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):
     def call_method(self, *args, **kwargs):
-        include_curr_dir = self.params["include_curr_dir"]
+        include_curr_dir = self.params.include_curr_dir
         curr_dir = getcwd()
         if include_curr_dir:
             path.append(curr_dir)
@@ -61,15 +69,11 @@ def _execute_pytest_subprocess(
 
 
 class PythonStandardRunner(LabelAnalysisRunnerInterface):
-    def __init__(self, config_params: PythonStandardRunnerConfigParams = None) -> None:
+    def __init__(self, config_params: Optional[dict] = None) -> None:
         super().__init__()
-        default_config: PythonStandardRunnerConfigParams = {
-            "collect_tests_options": [],
-            "include_curr_dir": True,
-        }
         if config_params is None:
-            config_params = PythonStandardRunnerConfigParams()
-        self.params = {**default_config, **config_params}
+            config_params = {}
+        self.params = PythonStandardRunnerConfigParams(config_params)
 
     @_include_curr_dir
     def _execute_pytest(
@@ -102,7 +106,7 @@ class PythonStandardRunner(LabelAnalysisRunnerInterface):
 
     def collect_tests(self):
         default_options = ["-q", "--collect-only"]
-        extra_args = self.params["collect_tests_options"]
+        extra_args = self.params.collect_tests_options
         options_to_use = default_options + extra_args
         logger.debug(
             "Collecting tests",
@@ -143,6 +147,12 @@ class PythonStandardRunner(LabelAnalysisRunnerInterface):
                 ),
             )
 
+        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])),
+            )
         command_array = default_options + [
             label.split("[")[0] if "[" in label else label for label in all_labels
         ]

codecov-cli-0.1.9/codecov_cli/runners/types.py

@@ -0,0 +1,32 @@
+from typing import 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 = None
+
+    def collect_tests(self) -> List[str]:
+        raise NotImplementedError()
+
+    def process_labelanalysis_result(self, result: LabelAnalysisRequestResult):
+        raise NotImplementedError()

codecov-cli-0.1.9/codecov_cli/services/empty_upload/__init__.py

@@ -0,0 +1,19 @@
+import logging
+
+from codecov_cli.helpers.encoder import encode_slug
+from codecov_cli.helpers.request import (
+    get_token_header_or_fail,
+    log_warnings_and_errors_if_any,
+    send_post_request,
+)
+
+logger = logging.getLogger("codecovcli")
+
+
+def empty_upload_logic(commit_sha, slug, token, git_service):
+    encoded_slug = encode_slug(slug)
+    headers = get_token_header_or_fail(token)
+    url = f"https://api.codecov.io/upload/{git_service}/{encoded_slug}/commits/{commit_sha}/empty-upload"
+    sending_result = send_post_request(url=url, headers=headers)
+    log_warnings_and_errors_if_any(sending_result, "Empty Upload")
+    return sending_result

{codecov-cli-0.1.8 → codecov-cli-0.1.9/codecov_cli.egg-info}/PKG-INFO

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

{codecov-cli-0.1.8 → codecov-cli-0.1.9}/codecov_cli.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ codecov_cli/commands/__init__.py
 codecov_cli/commands/base_picking.py
 codecov_cli/commands/commit.py
 codecov_cli/commands/create_report_result.py
+codecov_cli/commands/empty_upload.py
 codecov_cli/commands/get_report_results.py
 codecov_cli/commands/labelanalysis.py
 codecov_cli/commands/report.py
@@ -60,6 +61,7 @@ codecov_cli/runners/types.py
 codecov_cli/services/__init__.py
 codecov_cli/services/commit/__init__.py
 codecov_cli/services/commit/base_picking.py
+codecov_cli/services/empty_upload/__init__.py
 codecov_cli/services/report/__init__.py
 codecov_cli/services/staticanalysis/__init__.py
 codecov_cli/services/staticanalysis/exceptions.py

{codecov-cli-0.1.8 → codecov-cli-0.1.9}/setup.py

@@ -10,7 +10,7 @@ with open(path.join(here, "README.md"), encoding="utf-8") as f:
 
 setup(
     name="codecov-cli",
-    version="0.1.8",
+    version="0.1.9",
     packages=find_packages(exclude=["contrib", "docs", "tests*"]),
     description="Codecov Command Line Interface",
     long_description=long_description,

codecov-cli-0.1.8/codecov_cli/runners/types.py

@@ -1,18 +0,0 @@
-from typing import List, TypedDict
-
-
-class LabelAnalysisRequestResult(TypedDict):
-    present_report_labels: List[str]
-    absent_labels: List[str]
-    present_diff_labels: List[str]
-    global_level_labels: List[str]
-
-
-class LabelAnalysisRunnerInterface(object):
-    params = None
-
-    def collect_tests(self) -> List[str]:
-        raise NotImplementedError()
-
-    def process_labelanalysis_result(self, result: LabelAnalysisRequestResult):
-        raise NotImplementedError()