codecov-cli 11.0.0__py3-none-any.whl

codecov_cli/services/commit/__init__.py

@@ -0,0 +1,86 @@
+import logging
+import os
+import typing
+
+from codecov_cli.helpers.config import CODECOV_INGEST_URL
+from codecov_cli.helpers.encoder import encode_slug
+from codecov_cli.helpers.request import (
+    get_token_header,
+    log_warnings_and_errors_if_any,
+    send_post_request,
+)
+
+logger = logging.getLogger("codecovcli")
+
+
+def create_commit_logic(
+    commit_sha: str,
+    parent_sha: typing.Optional[str],
+    pr: typing.Optional[str],
+    branch: typing.Optional[str],
+    slug: typing.Optional[str],
+    token: typing.Optional[str],
+    service: typing.Optional[str],
+    enterprise_url: typing.Optional[str] = None,
+    fail_on_error: bool = False,
+    args: dict = None,
+):
+    encoded_slug = encode_slug(slug)
+    sending_result = send_commit_data(
+        commit_sha=commit_sha,
+        parent_sha=parent_sha,
+        pr=pr,
+        branch=branch,
+        slug=encoded_slug,
+        token=token,
+        service=service,
+        enterprise_url=enterprise_url,
+        args=args,
+    )
+
+    log_warnings_and_errors_if_any(sending_result, "Commit creating", fail_on_error)
+    return sending_result
+
+
+def send_commit_data(
+    commit_sha,
+    parent_sha,
+    pr,
+    branch,
+    slug,
+    token,
+    service,
+    enterprise_url,
+    args,
+):
+    # Old versions of the GHA use this env var instead of the regular branch
+    # argument to provide an unprotected branch name
+    if tokenless := os.environ.get("TOKENLESS"):
+        branch = tokenless
+
+    if branch and ":" in branch:
+        logger.info(f"Creating a commit for an unprotected branch: {branch}")
+    elif token is None:
+        logger.warning(
+            f"Branch `{branch}` is protected but no token was provided\nFor information on Codecov upload tokens, see https://docs.codecov.com/docs/codecov-tokens"
+        )
+    else:
+        logger.info(f"Using token to create a commit for protected branch `{branch}`")
+
+    headers = get_token_header(token)
+
+    data = {
+        "branch": branch,
+        "cli_args": args,
+        "commitid": commit_sha,
+        "parent_commit_id": parent_sha,
+        "pullid": pr,
+    }
+
+    upload_url = enterprise_url or CODECOV_INGEST_URL
+    url = f"{upload_url}/upload/{service}/{slug}/commits"
+    return send_post_request(
+        url=url,
+        data=data,
+        headers=headers,
+    )

codecov_cli/services/commit/base_picking.py

@@ -0,0 +1,24 @@
+import logging
+
+from codecov_cli.helpers.config import CODECOV_API_URL
+from codecov_cli.helpers.request import (
+    get_token_header,
+    log_warnings_and_errors_if_any,
+    send_put_request,
+)
+
+logger = logging.getLogger("codecovcli")
+
+
+def base_picking_logic(base_sha, pr, slug, token, service, enterprise_url, args):
+    data = {
+        "cli_args": args,
+        "user_provided_base_sha": base_sha,
+    }
+    headers = get_token_header(token)
+    upload_url = enterprise_url or CODECOV_API_URL
+    url = f"{upload_url}/api/v1/{service}/{slug}/pulls/{pr}"
+    sending_result = send_put_request(url=url, data=data, headers=headers)
+
+    log_warnings_and_errors_if_any(sending_result, "Base picking")
+    return sending_result

codecov_cli/services/empty_upload/__init__.py

@@ -0,0 +1,42 @@
+import json
+import logging
+
+from codecov_cli.helpers.config import CODECOV_API_URL
+from codecov_cli.helpers.encoder import encode_slug
+from codecov_cli.helpers.request import (
+    get_token_header,
+    log_warnings_and_errors_if_any,
+    send_post_request,
+)
+
+logger = logging.getLogger("codecovcli")
+
+
+def empty_upload_logic(
+    commit_sha,
+    slug,
+    token,
+    git_service,
+    enterprise_url,
+    fail_on_error,
+    should_force,
+    args,
+):
+    encoded_slug = encode_slug(slug)
+    headers = get_token_header(token)
+    upload_url = enterprise_url or CODECOV_API_URL
+    url = f"{upload_url}/upload/{git_service}/{encoded_slug}/commits/{commit_sha}/empty-upload"
+    sending_result = send_post_request(
+        url=url,
+        headers=headers,
+        data={
+            "cli_args": args,
+            "should_force": should_force,
+        },
+    )
+    log_warnings_and_errors_if_any(sending_result, "Empty Upload", fail_on_error)
+    if sending_result.status_code == 200:
+        response_json = json.loads(sending_result.text)
+        logger.info(response_json.get("result"))
+        logger.info(f"Non ignored files {response_json.get('non_ignored_files')}")
+    return sending_result

codecov_cli/services/report/__init__.py

@@ -0,0 +1,169 @@
+import json
+import logging
+import time
+import typing
+
+import requests
+
+from codecov_cli.helpers import request
+from codecov_cli.helpers.config import CODECOV_API_URL, CODECOV_INGEST_URL
+from codecov_cli.helpers.encoder import encode_slug
+from codecov_cli.helpers.request import (
+    get_token_header,
+    log_warnings_and_errors_if_any,
+    request_result,
+    send_post_request,
+)
+
+logger = logging.getLogger("codecovcli")
+MAX_NUMBER_TRIES = 3
+
+
+def create_report_logic(
+    commit_sha: str,
+    code: str,
+    slug: str,
+    service: str,
+    token: typing.Optional[str],
+    enterprise_url: str,
+    pull_request_number: int,
+    fail_on_error: bool = False,
+    args: typing.Union[dict, None] = None,
+):
+    encoded_slug = encode_slug(slug)
+    sending_result = send_create_report_request(
+        commit_sha,
+        code,
+        service,
+        token,
+        encoded_slug,
+        enterprise_url,
+        pull_request_number,
+        args,
+    )
+    log_warnings_and_errors_if_any(sending_result, "Report creating", fail_on_error)
+    return sending_result
+
+
+def send_create_report_request(
+    commit_sha,
+    code,
+    service,
+    token,
+    encoded_slug,
+    enterprise_url,
+    pull_request_number,
+    args,
+):
+    data = {
+        "cli_args": args,
+        "code": code,
+    }
+    headers = get_token_header(token)
+    upload_url = enterprise_url or CODECOV_INGEST_URL
+    url = f"{upload_url}/upload/{service}/{encoded_slug}/commits/{commit_sha}/reports"
+    return send_post_request(url=url, headers=headers, data=data)
+
+
+def create_report_results_logic(
+    commit_sha: str,
+    code: str,
+    slug: str,
+    service: str,
+    token: typing.Optional[str],
+    enterprise_url: str,
+    fail_on_error: bool = False,
+    args: typing.Union[dict, None] = None,
+):
+    encoded_slug = encode_slug(slug)
+    sending_result = send_reports_result_request(
+        commit_sha=commit_sha,
+        report_code=code,
+        encoded_slug=encoded_slug,
+        service=service,
+        token=token,
+        enterprise_url=enterprise_url,
+        args=args,
+    )
+
+    log_warnings_and_errors_if_any(
+        sending_result, "Report results creating", fail_on_error
+    )
+    return sending_result
+
+
+def send_reports_result_request(
+    commit_sha,
+    report_code,
+    encoded_slug,
+    service,
+    token,
+    enterprise_url,
+    args,
+):
+    data = {
+        "cli_args": args,
+    }
+    headers = get_token_header(token)
+    upload_url = enterprise_url or CODECOV_API_URL
+    url = f"{upload_url}/upload/{service}/{encoded_slug}/commits/{commit_sha}/reports/{report_code}/results"
+    return send_post_request(url=url, data=data, headers=headers)
+
+
+def send_reports_result_get_request(
+    commit_sha,
+    report_code,
+    encoded_slug,
+    service,
+    token,
+    enterprise_url,
+    fail_on_error=False,
+):
+    headers = get_token_header(token)
+    upload_url = enterprise_url or CODECOV_API_URL
+    url = f"{upload_url}/upload/{service}/{encoded_slug}/commits/{commit_sha}/reports/{report_code}/results"
+    number_tries = 0
+    while number_tries < MAX_NUMBER_TRIES:
+        resp = request.get(url=url, headers=headers)
+        response_obj = request_result(resp)
+        response_content = json.loads(response_obj.text)
+
+        # if response_status is 400 and higher
+        if response_obj.error:
+            log_warnings_and_errors_if_any(
+                response_obj, "Getting report results", fail_on_error
+            )
+            return response_obj
+
+        state = response_content.get("state").lower()
+        if state == "error":
+            logger.error(
+                "An error occurred while processing the report. Please try again later.",
+                extra=dict(
+                    extra_log_attributes=dict(
+                        response_status_code=response_obj.status_code,
+                        state=response_content.get("state"),
+                        result=response_content.get("result"),
+                    )
+                ),
+            )
+            return response_obj
+        elif state == "pending":
+            logger.info("Report with the given code is still being processed.")
+        elif state == "completed":
+            logger.info(
+                "Finished processing report results",
+                extra=dict(
+                    extra_log_attributes=dict(
+                        state=response_content.get("result")["state"],
+                        message=response_content.get("result")["message"],
+                    )
+                ),
+            )
+            return response_obj
+        else:
+            logger.error("Please try again later.")
+            return response_obj
+        time.sleep(5)
+        number_tries += 1
+    return response_obj

codecov_cli/services/upload/__init__.py

@@ -0,0 +1,169 @@
+import logging
+import typing
+from pathlib import Path
+
+import click
+
+from codecov_cli.fallbacks import FallbackFieldEnum
+from codecov_cli.helpers.ci_adapters.base import CIAdapterBase
+from codecov_cli.helpers.request import log_warnings_and_errors_if_any
+from codecov_cli.helpers.versioning_systems import VersioningSystemInterface
+from codecov_cli.helpers.upload_type import ReportType
+from codecov_cli.plugins import select_preparation_plugins
+from codecov_cli.services.upload.file_finder import select_file_finder
+from codecov_cli.services.upload.legacy_upload_sender import LegacyUploadSender
+from codecov_cli.services.upload.network_finder import select_network_finder
+from codecov_cli.services.upload.upload_collector import UploadCollector
+from codecov_cli.services.upload.upload_sender import UploadSender
+from codecov_cli.services.upload_completion import upload_completion_logic
+from codecov_cli.types import RequestResult
+
+logger = logging.getLogger("codecovcli")
+
+
+def do_upload_logic(
+    cli_config: typing.Dict,
+    versioning_system: VersioningSystemInterface,
+    ci_adapter: CIAdapterBase,
+    upload_coverage: bool = False,
+    *,
+    args: dict = None,
+    branch: typing.Optional[str],
+    build_code: typing.Optional[str],
+    build_url: typing.Optional[str],
+    commit_sha: str,
+    disable_file_fixes: bool = False,
+    disable_search: bool = False,
+    dry_run: bool = False,
+    enterprise_url: typing.Optional[str],
+    env_vars: typing.Dict[str, str],
+    fail_on_error: bool = False,
+    files_search_exclude_folders: typing.List[Path],
+    files_search_explicitly_listed_files: typing.List[Path],
+    files_search_root_folder: Path,
+    flags: typing.List[str],
+    gcov_args: typing.Optional[str],
+    gcov_executable: typing.Optional[str],
+    gcov_ignore: typing.Optional[str],
+    gcov_include: typing.Optional[str],
+    git_service: typing.Optional[str],
+    handle_no_reports_found: bool = False,
+    job_code: typing.Optional[str],
+    name: typing.Optional[str],
+    network_filter: typing.Optional[str],
+    network_prefix: typing.Optional[str],
+    network_root_folder: Path,
+    parent_sha: typing.Optional[str] = None,
+    plugin_names: typing.List[str],
+    pull_request_number: typing.Optional[str],
+    recurse_submodules: bool = False,
+    report_code: str,
+    slug: typing.Optional[str],
+    swift_project: typing.Optional[str],
+    token: typing.Optional[str],
+    report_type: ReportType = ReportType.COVERAGE,
+    use_legacy_uploader: bool = False,
+):
+    plugin_config = {
+        "folders_to_ignore": files_search_exclude_folders,
+        "gcov_args": gcov_args,
+        "gcov_executable": gcov_executable,
+        "gcov_ignore": gcov_ignore,
+        "gcov_include": gcov_include,
+        "project_root": files_search_root_folder,
+        "swift_project": swift_project,
+    }
+    if report_type == ReportType.COVERAGE:
+        preparation_plugins = select_preparation_plugins(
+            cli_config, plugin_names, plugin_config
+        )
+    elif report_type == ReportType.TEST_RESULTS:
+        preparation_plugins = []
+    file_selector = select_file_finder(
+        files_search_root_folder,
+        files_search_exclude_folders,
+        files_search_explicitly_listed_files,
+        disable_search,
+        report_type,
+    )
+    network_finder = select_network_finder(
+        versioning_system,
+        recurse_submodules=recurse_submodules,
+        network_filter=network_filter,
+        network_prefix=network_prefix,
+        network_root_folder=network_root_folder,
+    )
+    collector = UploadCollector(
+        preparation_plugins,
+        network_finder,
+        file_selector,
+        disable_file_fixes,
+        plugin_config,
+    )
+    try:
+        upload_data = collector.generate_upload_data(report_type)
+    except click.ClickException as exp:
+        if handle_no_reports_found:
+            logger.info(
+                "No coverage reports found. Triggering notifications without uploading."
+            )
+            upload_completion_logic(
+                commit_sha=commit_sha,
+                slug=slug,
+                token=token,
+                git_service=git_service,
+                enterprise_url=enterprise_url,
+                fail_on_error=fail_on_error,
+            )
+            return RequestResult(
+                error=None,
+                warnings=None,
+                status_code=200,
+                text="No coverage reports found. Triggering notifications without uploading.",
+            )
+        else:
+            raise exp
+    if use_legacy_uploader:
+        sender = LegacyUploadSender()
+    else:
+        sender = UploadSender()
+    logger.debug(f"Selected uploader to use: {type(sender)}")
+    ci_service = (
+        ci_adapter.get_fallback_value(FallbackFieldEnum.service)
+        if ci_adapter is not None
+        else None
+    )
+
+    if not dry_run:
+        sending_result = sender.send_upload_data(
+            upload_data=upload_data,
+            commit_sha=commit_sha,
+            token=token,
+            env_vars=env_vars,
+            report_code=report_code,
+            report_type=report_type,
+            name=name,
+            branch=branch,
+            slug=slug,
+            pull_request_number=pull_request_number,
+            build_code=build_code,
+            build_url=build_url,
+            job_code=job_code,
+            flags=flags,
+            ci_service=ci_service,
+            git_service=git_service,
+            enterprise_url=enterprise_url,
+            parent_sha=parent_sha,
+            upload_coverage=upload_coverage,
+            args=args,
+        )
+    else:
+        logger.info("dry-run option activated. NOT sending data to Codecov.")
+        sending_result = RequestResult(
+            error=None,
+            warnings=None,
+            status_code=200,
+            text="Data NOT sent to Codecov because of dry-run option",
+        )
+    log_warnings_and_errors_if_any(sending_result, "Upload", fail_on_error)
+    return sending_result