Merge branch 'main' into revert-972-temporarily-dismiss-trial-extension-for-paid-customers

Author: adrian-codecov

docker/Dockerfile

@@ -1,7 +1,7 @@
 # syntax=docker/dockerfile:1.4
 ARG REQUIREMENTS_IMAGE
 ARG BUILD_ENV=self-hosted
-ARG BERGLAS_VERSION=2.0.2
+ARG BERGLAS_VERSION=2.0.6
 
 FROM us-docker.pkg.dev/berglas/berglas/berglas:$BERGLAS_VERSION as berglas
 

graphql_api/types/test_analytics/test_analytics.py

@@ -218,7 +218,7 @@ def generate_test_results(
             table = table.filter(pl.col("total_flaky_fail_count") > 0)
         case TestResultsFilterParameter.SKIPPED_TESTS:
             table = table.filter(
-                pl.col("total_skip_count") > 0 & pl.col("total_pass_count") == 0
+                (pl.col("total_skip_count") > 0) & (pl.col("total_pass_count") == 0)
             )
         case TestResultsFilterParameter.SLOWEST_TESTS:
             table = table.filter(
@@ -285,7 +285,7 @@ def get_test_suites(
     if term:
         testsuites = testsuites.filter(pl.col("testsuite").str.starts_with(term))
 
-    return testsuites.to_series().to_list()
+    return testsuites.to_series().drop_nulls().to_list() or []
 
 
 def get_flags(repoid: int, term: str | None = None, interval: int = 30) -> list[str]:
@@ -295,12 +295,12 @@ def get_flags(repoid: int, term: str | None = None, interval: int = 30) -> list[
     if table is None:
         return []
 
-    flags = table.select(pl.col("flags")).unique()
+    flags = table.select(pl.col("flags").explode()).unique()
 
     if term:
         flags = flags.filter(pl.col("flags").str.starts_with(term))
 
-    return flags.to_series().to_list()
+    return flags.to_series().drop_nulls().to_list() or []
 
 
 class TestResultsOrdering(TypedDict):

services/task/task.py

@@ -398,6 +398,8 @@ def send_email(
         from_addr: str | None = None,
         **kwargs,
     ):
+        # Disabling this while we fix HTML templates.
+        return
         # Templates can be found in worker/templates
         self._create_signature(
             "app.tasks.send_email.SendEmail",

upload/tests/views/test_combined_upload.py

@@ -0,0 +1,289 @@
+from unittest.mock import patch
+
+from django.conf import settings
+from django.test import override_settings
+from django.urls import reverse
+from rest_framework.test import APIClient
+from shared.django_apps.core.tests.factories import (
+    CommitFactory,
+    RepositoryFactory,
+)
+
+from reports.models import (
+    ReportSession,
+    RepositoryFlag,
+    UploadFlagMembership,
+)
+from services.archive import ArchiveService, MinioEndpoints
+from upload.views.combined_upload import CanDoCoverageUploadsPermission
+
+
+def test_get_repo(db):
+    repository = RepositoryFactory(
+        name="the_repo", author__username="codecov", author__service="github"
+    )
+    repository.save()
+    repo_slug = f"{repository.author.username}::::{repository.name}"
+    url = reverse(
+        "new_upload.combined_upload",
+        args=[repository.author.service, repo_slug],
+    )
+    client = APIClient()
+    client.credentials(HTTP_AUTHORIZATION="token " + repository.upload_token)
+    response = client.post(url, {}, format="json")
+    assert response.status_code == 400  # Bad request due to missing required fields
+    assert "commitid" in response.json()
+
+
+@patch("services.task.TaskService.upload")
+def test_get_repo_not_found(upload, db):
+    repository = RepositoryFactory(
+        name="the_repo", author__username="codecov", author__service="github"
+    )
+    repo_slug = "codecov::::wrong-repo-name"
+    url = reverse(
+        "new_upload.combined_upload",
+        args=[repository.author.service, repo_slug],
+    )
+    client = APIClient()
+    response = client.post(url, {}, format="json")
+    assert response.status_code == 401
+    assert response.json() == {"detail": "Not valid tokenless upload"}
+    assert not upload.called
+
+
+def test_deactivated_repo(db):
+    repository = RepositoryFactory(
+        name="the_repo",
+        author__username="codecov",
+        author__service="github",
+        active=True,
+        activated=False,
+    )
+    repository.save()
+    repo_slug = f"{repository.author.username}::::{repository.name}"
+    url = reverse(
+        "new_upload.combined_upload",
+        args=[repository.author.service, repo_slug],
+    )
+    client = APIClient()
+    client.credentials(HTTP_AUTHORIZATION="token " + repository.upload_token)
+    response = client.post(url, {"commit_sha": "abc123"}, format="json")
+    assert response.status_code == 400
+    assert "This repository is deactivated" in str(response.json())
+
+
+def test_combined_upload_with_errors(db):
+    repository = RepositoryFactory()
+    repo_slug = f"{repository.author.username}::::{repository.name}"
+    url = reverse(
+        "new_upload.combined_upload",
+        args=[repository.author.service, repo_slug],
+    )
+
+    client = APIClient()
+    client.credentials(HTTP_AUTHORIZATION="token " + repository.upload_token)
+
+    # Missing required fields
+    response = client.post(url, {}, format="json")
+    assert response.status_code == 400
+    assert "commitid" in response.json()
+
+    # Invalid flag format
+    response = client.post(
+        url, {"commit_sha": "abc123", "flags": "not-a-list"}, format="json"
+    )
+    assert response.status_code == 400
+    assert "flags" in response.json()
+
+
+def test_combined_upload_post(db, mocker):
+    mocker.patch.object(
+        CanDoCoverageUploadsPermission, "has_permission", return_value=True
+    )
+    presigned_put_mock = mocker.patch(
+        "services.archive.StorageService.create_presigned_put",
+        return_value="presigned put",
+    )
+    upload_task_mock = mocker.patch(
+        "upload.views.uploads.trigger_upload_task", return_value=True
+    )
+
+    repository = RepositoryFactory(
+        name="the_repo1", author__username="codecov", author__service="github"
+    )
+    commit = CommitFactory(repository=repository)
+    repository.save()
+    commit.save()
+
+    owner = repository.author
+    client = APIClient()
+    client.force_authenticate(user=owner)
+    repo_slug = f"{repository.author.username}::::{repository.name}"
+    url = reverse(
+        "new_upload.combined_upload",
+        args=[repository.author.service, repo_slug],
+    )
+    response = client.post(
+        url,
+        {
+            "branch": "branch",
+            "ci_service": "ci_service",
+            "ci_url": "ci_url",
+            "code": "code",
+            "commit_sha": commit.commitid,
+            "flags": ["flag1", "flag2"],
+            "job_code": "job_code",
+            "version": "version",
+        },
+        format="json",
+    )
+    response_json = response.json()
+    upload = ReportSession.objects.filter(
+        report__commit=commit,
+        report__code="code",
+        upload_extras={"format_version": "v1"},
+    ).first()
+    assert response.status_code == 201
+    assert all(
+        map(
+            lambda x: x in response_json.keys(),
+            ["external_id", "created_at", "raw_upload_location", "url"],
+        )
+    )
+    assert (
+        response_json.get("url")
+        == f"{settings.CODECOV_DASHBOARD_URL}/{repository.author.service}/{repository.author.username}/{repository.name}/commit/{commit.commitid}"
+    )
+
+    assert ReportSession.objects.filter(
+        report__commit=commit,
+        report__code="code",
+        upload_extras={"format_version": "v1"},
+    ).exists()
+    assert RepositoryFlag.objects.filter(
+        repository_id=repository.repoid, flag_name="flag1"
+    ).exists()
+    assert RepositoryFlag.objects.filter(
+        repository_id=repository.repoid, flag_name="flag2"
+    ).exists()
+    flag1 = RepositoryFlag.objects.filter(
+        repository_id=repository.repoid, flag_name="flag1"
+    ).first()
+    flag2 = RepositoryFlag.objects.filter(
+        repository_id=repository.repoid, flag_name="flag2"
+    ).first()
+    assert UploadFlagMembership.objects.filter(
+        report_session_id=upload.id, flag_id=flag1.id
+    ).exists()
+    assert UploadFlagMembership.objects.filter(
+        report_session_id=upload.id, flag_id=flag2.id
+    ).exists()
+    assert [flag for flag in upload.flags.all()] == [flag1, flag2]
+
+    archive_service = ArchiveService(repository)
+    assert upload.storage_path == MinioEndpoints.raw_with_upload_id.get_path(
+        version="v4",
+        date=upload.created_at.strftime("%Y-%m-%d"),
+        repo_hash=archive_service.storage_hash,
+        commit_sha=commit.commitid,
+        reportid=upload.report.external_id,
+        uploadid=upload.external_id,
+    )
+    presigned_put_mock.assert_called_with("archive", upload.storage_path, 10)
+    upload_task_mock.assert_called()
+
+
+@override_settings(SHELTER_SHARED_SECRET="shelter-shared-secret")
+def test_combined_upload_post_shelter(db, mocker):
+    mocker.patch.object(
+        CanDoCoverageUploadsPermission, "has_permission", return_value=True
+    )
+    presigned_put_mock = mocker.patch(
+        "services.archive.StorageService.create_presigned_put",
+        return_value="presigned put",
+    )
+    upload_task_mock = mocker.patch(
+        "upload.views.uploads.trigger_upload_task", return_value=True
+    )
+
+    repository = RepositoryFactory(
+        name="the_repo", author__username="codecov", author__service="github"
+    )
+    commit = CommitFactory(repository=repository)
+    repository.save()
+    commit.save()
+
+    owner = repository.author
+    client = APIClient()
+    client.force_authenticate(user=owner)
+    repo_slug = f"{repository.author.username}::::{repository.name}"
+    url = reverse(
+        "new_upload.combined_upload",
+        args=[repository.author.service, repo_slug],
+    )
+    response = client.post(
+        url,
+        {
+            "branch": "branch",
+            "ci_service": "ci_service",
+            "ci_url": "ci_url",
+            "code": "code",
+            "commit_sha": commit.commitid,
+            "flags": ["flag1", "flag2"],
+            "job_code": "job_code",
+            "storage_path": "shelter/test/path.txt",
+            "version": "version",
+        },
+        headers={
+            "X-Shelter-Token": "shelter-shared-secret",
+            "User-Agent": "codecov-cli/0.4.7",
+        },
+        format="json",
+    )
+    response_json = response.json()
+    upload = ReportSession.objects.filter(
+        report__commit=commit,
+        report__code="code",
+        upload_extras={"format_version": "v1"},
+    ).first()
+    assert response.status_code == 201
+    assert all(
+        map(
+            lambda x: x in response_json.keys(),
+            ["external_id", "created_at", "raw_upload_location", "url"],
+        )
+    )
+    assert (
+        response_json.get("url")
+        == f"{settings.CODECOV_DASHBOARD_URL}/{repository.author.service}/{repository.author.username}/{repository.name}/commit/{commit.commitid}"
+    )
+
+    assert ReportSession.objects.filter(
+        report__commit=commit,
+        report__code="code",
+        upload_extras={"format_version": "v1"},
+    ).exists()
+    assert RepositoryFlag.objects.filter(
+        repository_id=repository.repoid, flag_name="flag1"
+    ).exists()
+    assert RepositoryFlag.objects.filter(
+        repository_id=repository.repoid, flag_name="flag2"
+    ).exists()
+    flag1 = RepositoryFlag.objects.filter(
+        repository_id=repository.repoid, flag_name="flag1"
+    ).first()
+    flag2 = RepositoryFlag.objects.filter(
+        repository_id=repository.repoid, flag_name="flag2"
+    ).first()
+    assert UploadFlagMembership.objects.filter(
+        report_session_id=upload.id, flag_id=flag1.id
+    ).exists()
+    assert UploadFlagMembership.objects.filter(
+        report_session_id=upload.id, flag_id=flag2.id
+    ).exists()
+    assert [flag for flag in upload.flags.all()] == [flag1, flag2]
+
+    assert upload.storage_path == "shelter/test/path.txt"
+    presigned_put_mock.assert_called_with("archive", upload.storage_path, 10)
+    upload_task_mock.assert_called()