Deprecate the "local upload" ReportResults endpoints (#1291)

Author: Swatinem

reports/tests/factories.py

@@ -6,7 +6,7 @@
 
 from graphql_api.types.enums import UploadErrorEnum
 from reports import models
-from reports.models import ReportResults, TestInstance
+from reports.models import TestInstance
 
 
 class CommitReportFactory(DjangoModelFactory):
@@ -77,19 +77,6 @@ class Meta:
     )
 
 
-class ReportResultsFactory(DjangoModelFactory):
-    class Meta:
-        model = ReportResults
-
-    report = factory.SubFactory(CommitReportFactory)
-    state = factory.Iterator(
-        [
-            ReportResults.ReportResultsStates.PENDING,
-            ReportResults.ReportResultsStates.COMPLETED,
-        ]
-    )
-
-
 class TestFactory(factory.django.DjangoModelFactory):
     class Meta:
         model = models.Test

services/task/task.py

@@ -311,17 +311,6 @@ def update_commit(self, commitid, repoid):
             kwargs=dict(commitid=commitid, repoid=repoid),
         ).apply_async()
 
-    def create_report_results(self, commitid, repoid, report_code, current_yaml=None):
-        self._create_signature(
-            "app.tasks.reports.save_report_results",
-            kwargs=dict(
-                commitid=commitid,
-                repoid=repoid,
-                report_code=report_code,
-                current_yaml=current_yaml,
-            ),
-        ).apply_async()
-
     def http_request(self, url, method="POST", headers=None, data=None, timeout=None):
         self._create_signature(
             "app.tasks.http_request.HTTPRequest",

upload/serializers.py

@@ -7,7 +7,7 @@
 
 from codecov_auth.models import Owner
 from core.models import Commit, Repository
-from reports.models import CommitReport, ReportResults, ReportSession, RepositoryFlag
+from reports.models import CommitReport, ReportSession, RepositoryFlag
 from services.task import TaskService
 
 
@@ -178,18 +178,3 @@ def create(self, validated_data: Dict[str, Any]) -> tuple[CommitReport, bool]:
                 report.save()
             return report, False
         return super().create(validated_data), True
-
-
-class ReportResultsSerializer(serializers.ModelSerializer):
-    report = CommitReportSerializer(read_only=True)
-
-    class Meta:
-        model = ReportResults
-        read_only_fields = (
-            "external_id",
-            "report",
-            "state",
-            "result",
-            "completed_at",
-        )
-        fields = read_only_fields

upload/tests/test_serializers.py

@@ -9,14 +9,12 @@
 from billing.helpers import mock_all_plans_and_tiers
 from reports.tests.factories import (
     CommitReportFactory,
-    ReportResultsFactory,
     RepositoryFlagFactory,
     UploadFactory,
 )
 from upload.serializers import (
     CommitReportSerializer,
     CommitSerializer,
-    ReportResultsSerializer,
     UploadSerializer,
 )
 
@@ -237,23 +235,3 @@ def test_commit_report_serializer(transactional_db, mocker):
         "code": report.code,
     }
     assert serializer.data == expected_data
-
-
-def test_report_results_serializer(transactional_db, mocker):
-    report_result = ReportResultsFactory.create()
-    serializer = ReportResultsSerializer(report_result)
-    expected_data = {
-        "external_id": str(report_result.external_id),
-        "report": {
-            "external_id": str(report_result.report.external_id),
-            "created_at": report_result.report.created_at.strftime(
-                "%Y-%m-%dT%H:%M:%S.%fZ"
-            ),
-            "commit_sha": report_result.report.commit.commitid,
-            "code": report_result.report.code,
-        },
-        "state": report_result.state,
-        "result": report_result.result,
-        "completed_at": report_result.completed_at,
-    }
-    assert serializer.data == expected_data

upload/tests/views/test_reports.py

@@ -10,9 +10,9 @@
     RepositoryFactory,
 )
 
-from reports.models import CommitReport, ReportResults
-from reports.tests.factories import ReportResultsFactory
+from reports.models import CommitReport
 from services.task.task import TaskService
+from upload.views.reports import EMPTY_RESPONSE
 from upload.views.uploads import CanDoCoverageUploadsPermission
 
 
@@ -336,7 +336,6 @@ def test_reports_post_code_as_default(client, db, mocker):
 
 
 def test_reports_results_post_successful(client, db, mocker):
-    mocked_task = mocker.patch("services.task.TaskService.create_report_results")
     mocker.patch.object(
         CanDoCoverageUploadsPermission, "has_permission", return_value=True
     )
@@ -362,19 +361,13 @@ def test_reports_results_post_successful(client, db, mocker):
         == f"/upload/github/codecov::::the_repo/commits/{commit.commitid}/reports/code/results"
     )
     assert response.status_code == 201
-    assert ReportResults.objects.filter(
-        report_id=commit_report.id,
-    ).exists()
-    mocked_task.assert_called_once()
 
 
 @patch("upload.helpers.jwt.decode")
 @patch("upload.helpers.PyJWKClient")
 def test_reports_results_post_successful_github_oidc_auth(
     mock_jwks_client, mock_jwt_decode, client, db, mocker
 ):
-    mocked_task = mocker.patch("services.task.TaskService.create_report_results")
-    mock_prometheus_metrics = mocker.patch("upload.metrics.API_UPLOAD_COUNTER.labels")
     mocker.patch.object(
         CanDoCoverageUploadsPermission, "has_permission", return_value=True
     )
@@ -410,22 +403,6 @@ def test_reports_results_post_successful_github_oidc_auth(
         == f"/upload/github/codecov::::the_repo/commits/{commit.commitid}/reports/code/results"
     )
     assert response.status_code == 201
-    assert ReportResults.objects.filter(
-        report_id=commit_report.id,
-    ).exists()
-    mocked_task.assert_called_once()
-    mock_prometheus_metrics.assert_called_with(
-        **{
-            "agent": "cli",
-            "version": "0.4.7",
-            "action": "coverage",
-            "endpoint": "create_report_results",
-            "repo_visibility": "private",
-            "is_using_shelter": "no",
-            "position": "end",
-            "upload_version": None,
-        },
-    )
 
 
 @pytest.mark.parametrize("private", [False, True])
@@ -449,7 +426,6 @@ def test_reports_results_post_upload_token_required_auth_check(
     branch_sent,
     upload_token_required_for_public_repos,
 ):
-    mocked_task = mocker.patch("services.task.TaskService.create_report_results")
     repository = RepositoryFactory(
         name="the_repo",
         author__username="codecov",
@@ -462,6 +438,7 @@ def test_reports_results_post_upload_token_required_auth_check(
     commit.branch = branch
     repository.save()
     commit.save()
+    commit_report.save()
 
     client = APIClient()
     url = reverse(
@@ -492,55 +469,11 @@ def test_reports_results_post_upload_token_required_auth_check(
         or authorized_by_tokenless_auth_class
     ):
         assert response.status_code == 201
-        assert ReportResults.objects.filter(
-            report_id=commit_report.id,
-        ).exists()
-        mocked_task.assert_called_once()
     else:
         assert response.status_code == 401
-        assert not ReportResults.objects.filter(
-            report_id=commit_report.id,
-        ).exists()
         assert response.json().get("detail") == "Not valid tokenless upload"
 
 
-def test_reports_results_already_exists_post_successful(client, db, mocker):
-    mocked_task = mocker.patch("services.task.TaskService.create_report_results")
-    mocker.patch.object(
-        CanDoCoverageUploadsPermission, "has_permission", return_value=True
-    )
-    repository = RepositoryFactory(
-        name="the_repo", author__username="codecov", author__service="github"
-    )
-    commit = CommitFactory(repository=repository)
-    commit_report = CommitReport.objects.create(commit=commit, code="code")
-    report_results = ReportResults.objects.create(
-        report=commit_report, state=ReportResults.ReportResultsStates.COMPLETED
-    )
-    repository.save()
-    commit_report.save()
-    report_results.save()
-
-    owner = repository.author
-    client = APIClient()
-    client.force_authenticate(user=owner)
-    url = reverse(
-        "new_upload.reports_results",
-        args=["github", "codecov::::the_repo", commit.commitid, "code"],
-    )
-    response = client.post(url, content_type="application/json", data={})
-
-    assert (
-        url
-        == f"/upload/github/codecov::::the_repo/commits/{commit.commitid}/reports/code/results"
-    )
-    assert response.status_code == 201
-    assert ReportResults.objects.filter(
-        report_id=commit_report.id, state=ReportResults.ReportResultsStates.PENDING
-    ).exists()
-    mocked_task.assert_called_once()
-
-
 def test_report_results_get_successful(client, db, mocker):
     mocker.patch.object(
         CanDoCoverageUploadsPermission, "has_permission", return_value=True
@@ -550,9 +483,8 @@ def test_report_results_get_successful(client, db, mocker):
     )
     commit = CommitFactory(repository=repository)
     commit_report = CommitReport.objects.create(commit=commit, code="code")
-    commit_report_results = ReportResultsFactory(report=commit_report)
     repository.save()
-    commit_report_results.save()
+    commit_report.save()
 
     owner = repository.author
     client = APIClient()
@@ -568,42 +500,4 @@ def test_report_results_get_successful(client, db, mocker):
         == f"/upload/github/codecov::::the_repo/commits/{commit.commitid}/reports/code/results"
     )
     assert response.status_code == 200
-    assert response.json() == {
-        "external_id": str(commit_report_results.external_id),
-        "report": {
-            "external_id": str(commit_report.external_id),
-            "created_at": commit_report.created_at.strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
-            "commit_sha": commit_report.commit.commitid,
-            "code": commit_report.code,
-        },
-        "state": commit_report_results.state,
-        "result": {},
-        "completed_at": None,
-    }
-
-
-def test_report_results_get_unsuccessful(client, db, mocker):
-    mocker.patch.object(
-        CanDoCoverageUploadsPermission, "has_permission", return_value=True
-    )
-    repository = RepositoryFactory(
-        name="the_repo", author__username="codecov", author__service="github"
-    )
-    commit = CommitFactory(repository=repository)
-    CommitReport.objects.create(commit=commit, code="code")
-    repository.save()
-
-    client = APIClient()
-    client.force_authenticate(user=OwnerFactory())
-    url = reverse(
-        "new_upload.reports_results",
-        args=["github", "codecov::::the_repo", commit.commitid, "code"],
-    )
-    response = client.get(url, content_type="application/json", data={})
-
-    assert (
-        url
-        == f"/upload/github/codecov::::the_repo/commits/{commit.commitid}/reports/code/results"
-    )
-    assert response.status_code == 400
-    assert response.json() == ["Report Results not found"]
+    assert response.json() == EMPTY_RESPONSE