Merge pull request #61 from codecov/dana/base-picking-command

implement base picking command

Author: dana-yaish

codecov_cli/commands/base_picking.py

@@ -0,0 +1,75 @@
+import logging
+import typing
+import uuid
+
+import click
+
+from codecov_cli.fallbacks import CodecovOption, FallbackFieldEnum
+from codecov_cli.helpers.encoder import slug_without_subgroups_is_invalid
+from codecov_cli.services.commit.base_picking import base_picking_logic
+
+logger = logging.getLogger("codecovcli")
+
+
+@click.command()
+@click.option(
+    "--base-sha",
+    help="Base commit SHA (with 40 chars)",
+    cls=CodecovOption,
+    fallback_field=FallbackFieldEnum.commit_sha,
+    required=True,
+)
+@click.option(
+    "--pr",
+    help="Pull Request id to associate commit with",
+    cls=CodecovOption,
+    fallback_field=FallbackFieldEnum.pull_request_number,
+)
+@click.option(
+    "--slug",
+    cls=CodecovOption,
+    fallback_field=FallbackFieldEnum.slug,
+    help="owner/repo slug",
+    envvar="CODECOV_SLUG",
+)
+@click.option(
+    "-t",
+    "--token",
+    help="Codecov upload token",
+    type=click.UUID,
+    envvar="CODECOV_TOKEN",
+)
+@click.option(
+    "--service",
+    cls=CodecovOption,
+    fallback_field=FallbackFieldEnum.service,
+    help="Specify the service provider of the repo e.g. github",
+)
+@click.pass_context
+def pr_base_picking(
+    ctx,
+    base_sha: str,
+    pr: typing.Optional[int],
+    slug: typing.Optional[str],
+    token: typing.Optional[uuid.UUID],
+    service: typing.Optional[str],
+):
+    logger.debug(
+        "Starting base picking process",
+        extra=dict(
+            extra_log_attributes=dict(
+                pr=pr,
+                slug=slug,
+                token=token,
+                service=service,
+            )
+        ),
+    )
+
+    if slug_without_subgroups_is_invalid(slug):
+        logger.error(
+            "Slug is invalid. Slug should be in the form of owner_username/repo_name"
+        )
+        return
+
+    base_picking_logic(base_sha, pr, slug, token, service)

codecov_cli/helpers/encoder.py

@@ -1,7 +1,29 @@
+import re
+
+slug_without_subgroups_regex = re.compile(r"[^/\s]+\/[^/\s]+$")
+slug_with_subgroups_regex = re.compile(r"[^/\s]+(\/[^/\s]+)+$")
+
+
 def encode_slug(slug: str):
-    if "/" not in slug:
+    if slug_with_subgroups_is_invalid(slug):
         raise ValueError("The provided slug is invalid")
     owner, repo = slug.rsplit("/", 1)
     encoded_owner = ":::".join(owner.split("/"))
     encoded_slug = "::::".join([encoded_owner, repo])
     return encoded_slug
+
+
+def slug_without_subgroups_is_invalid(slug: str):
+    """
+    Checks if slug is in the form of owner/repo
+    Returns True if it's invalid, otherwise return False
+    """
+    return not slug or not slug_without_subgroups_regex.match(slug)
+
+
+def slug_with_subgroups_is_invalid(slug: str):
+    """
+    Checks if slug is in the form of owner/repo or owner/subgroup/repo
+    Returns True if it's invalid, otherwise return False
+    """
+    return not slug or not slug_with_subgroups_regex.match(slug)

codecov_cli/main.py

@@ -5,6 +5,7 @@
 import click
 import yaml
 
+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.get_report_results import get_report_results
@@ -60,6 +61,7 @@ def cli(
 cli.add_command(create_report)
 cli.add_command(create_report_results)
 cli.add_command(get_report_results)
+cli.add_command(pr_base_picking)
 cli.add_command(label_analysis)
 cli.add_command(static_analysis)
 

codecov_cli/services/commit/base_picking.py

@@ -0,0 +1,17 @@
+import logging
+
+from codecov_cli.helpers.request import log_warnings_and_errors_if_any, send_put_request
+
+logger = logging.getLogger("codecovcli")
+
+
+def base_picking_logic(base_sha, pr, slug, token, service):
+    data = {
+        "user_provided_base_sha": base_sha,
+    }
+    headers = {"Authorization": f"token {token.hex}"}
+    url = f"https://api.codecov.io/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

tests/helpers/test_encoder.py

@@ -1,21 +1,55 @@
 import pytest
 
-from codecov_cli.helpers.encoder import encode_slug
+from codecov_cli.helpers.encoder import encode_slug, slug_without_subgroups_is_invalid
 
 
-def test_invalid_slug():
-    slug = "invalid-slug"
+@pytest.mark.parametrize(
+    "slug",
+    [
+        ("invalid_slug"),
+        (""),
+        ("/"),
+        ("//"),
+        ("///"),
+        ("random string"),
+        (None),
+    ],
+)
+def test_encode_invalid_slug(slug):
     with pytest.raises(ValueError) as ex:
         encode_slug(slug)
 
 
-def test_owner_repo_slug():
-    slug = "owner/repo"
-    encoded_slug = encode_slug(slug)
-    assert encoded_slug == "owner::::repo"
+@pytest.mark.parametrize(
+    "slug, encoded_slug",
+    [
+        ("owner/repo", "owner::::repo"),
+        ("owner/subgroup/repo", "owner:::subgroup::::repo"),
+    ],
+)
+def test_encode_valid_slug(slug, encoded_slug):
+    expected_encoded_slug = encode_slug(slug)
+    assert expected_encoded_slug == encoded_slug
+
 
+@pytest.mark.parametrize(
+    "slug",
+    [
+        ("invalid_slug"),
+        (""),
+        ("/"),
+        ("//"),
+        ("///"),
+        ("random string"),
+        ("owner/subgroup/repo"),
+        ("owner//repo"),
+        (None),
+    ],
+)
+def test_invalid_slug(slug):
+    assert slug_without_subgroups_is_invalid(slug)
 
-def test_owner_with_subgroups_slug():
-    slug = "owner/subgroup/repo"
-    encoded_slug = encode_slug(slug)
-    assert encoded_slug == "owner:::subgroup::::repo"
+
+def test_valid_slug():
+    slug = "owner/repo"
+    assert not slug_without_subgroups_is_invalid(slug)

tests/test_base_picking.py

@@ -0,0 +1,137 @@
+import uuid
+
+from click.testing import CliRunner
+
+from codecov_cli.commands.base_picking import pr_base_picking
+from codecov_cli.main import cli
+from codecov_cli.types import RequestError, RequestResult, RequestResultWarning
+from tests.test_helpers import parse_outstreams_into_log_lines
+
+
+def test_base_picking_command(mocker):
+    mocked_response = mocker.patch(
+        "codecov_cli.services.commit.base_picking.send_put_request",
+        return_value=RequestResult(status_code=200, error=None, warnings=[], text=""),
+    )
+    token = uuid.uuid4()
+    runner = CliRunner()
+    result = runner.invoke(
+        pr_base_picking,
+        [
+            "-t",
+            token,
+            "--pr",
+            "11",
+            "--base-sha",
+            "9a6902ee94c18e8e27561ce316b16d75a02c7bc1",
+            "--service",
+            "github",
+            "--slug",
+            "owner/repo",
+        ],
+    )
+    assert result.exit_code == 0
+    mocked_response.assert_called_once()
+
+
+def test_base_picking_command_slug_invalid(mocker):
+    token = uuid.uuid4()
+    runner = CliRunner()
+    result = runner.invoke(
+        pr_base_picking,
+        [
+            "-t",
+            token,
+            "--pr",
+            "11",
+            "--base-sha",
+            "9a6902ee94c18e8e27561ce316b16d75a02c7bc1",
+            "--service",
+            "github",
+            "--slug",
+            "owner-repo",
+        ],
+    )
+    assert result.exit_code == 0
+    assert (
+        "error",
+        "Slug is invalid. Slug should be in the form of owner_username/repo_name",
+    ) in parse_outstreams_into_log_lines(result.output)
+
+
+def test_base_picking_command_warnings(mocker):
+    mocked_response = mocker.patch(
+        "codecov_cli.services.commit.base_picking.send_put_request",
+        return_value=RequestResult(
+            error=None,
+            warnings=[RequestResultWarning(message="some random warning")],
+            status_code=200,
+            text="",
+        ),
+    )
+    token = uuid.uuid4()
+    runner = CliRunner()
+    result = runner.invoke(
+        pr_base_picking,
+        [
+            "-t",
+            token,
+            "--pr",
+            "11",
+            "--base-sha",
+            "9a6902ee94c18e8e27561ce316b16d75a02c7bc1",
+            "--service",
+            "github",
+            "--slug",
+            "owner/repo",
+        ],
+    )
+    assert result.exit_code == 0
+    assert (
+        "info",
+        "Base picking process had 1 warning",
+    ) in parse_outstreams_into_log_lines(result.output)
+    assert (
+        "warning",
+        "Warning 1: some random warning",
+    ) in parse_outstreams_into_log_lines(result.output)
+    mocked_response.assert_called_once()
+
+
+def test_base_picking_command_error(mocker):
+    mocked_response = mocker.patch(
+        "codecov_cli.services.commit.base_picking.send_put_request",
+        return_value=RequestResult(
+            status_code=401,
+            error=RequestError(
+                code="HTTP Error 401",
+                description="Unauthorized",
+                params={},
+            ),
+            warnings=[],
+            text="",
+        ),
+    )
+    token = uuid.uuid4()
+    runner = CliRunner()
+    result = runner.invoke(
+        pr_base_picking,
+        [
+            "-t",
+            token,
+            "--pr",
+            "11",
+            "--base-sha",
+            "9a6902ee94c18e8e27561ce316b16d75a02c7bc1",
+            "--service",
+            "github",
+            "--slug",
+            "owner/repo",
+        ],
+    )
+    mocked_response.assert_called_once()
+    assert result.exit_code == 0
+    assert (
+        "error",
+        "Base picking failed: Unauthorized",
+    ) in parse_outstreams_into_log_lines(result.output)

tests/test_codecov_cli.py

@@ -13,5 +13,6 @@ def test_existing_commands():
         "do-upload",
         "get-report-results",
         "label-analysis",
+        "pr-base-picking",
         "static-analysis",
     ]