perf: replace previous query for GQL test results

this commit replaces the previous django orm code with an invocation
to do a raw sql query that performs much better for repos with a large
amount of data.

one worry with this approach is the risk for sql injection

in this specific case, we're passing most of the dynamic user provided
values used in the sql through the parameters which the django docs say
are sanitized and should be used to protect against sql injection

for the user provided values that are not passed through the sql parameters
they're checked to be in a strict set of values, so we shouldn't be substituting
any unexpected strings into the query

Author: joseph-sentry

graphql_api/tests/test_test_analytics.py

@@ -167,6 +167,7 @@ def test_failed_filter_on_test_results(self) -> None:
         assert res["testResults"] == {"edges": [{"node": {"name": test2.name}}]}
 
     def test_skipped_filter_on_test_results(self) -> None:
+        # note - this test guards against division by zero errors for the failure/flake rate
         repo = RepositoryFactory(author=self.owner, active=True, private=True)
         test = TestFactory(repository=repo)
         test2 = TestFactory(repository=repo)
@@ -367,8 +368,8 @@ def test_last_duration_ordering_on_test_results(self) -> None:
         )
         assert res["testResults"] == {
             "edges": [
-                {"node": {"name": test.name, "lastDuration": 0.0}},
-                {"node": {"name": test_2.name, "lastDuration": 0.0}},
+                {"node": {"name": test.name, "lastDuration": 2.0}},
+                {"node": {"name": test_2.name, "lastDuration": 3.0}},
             ]
         }
 
@@ -402,8 +403,8 @@ def test_desc_last_duration_ordering_on_test_results(self) -> None:
         )
         assert res["testResults"] == {
             "edges": [
-                {"node": {"name": test_2.name, "lastDuration": 0.0}},
-                {"node": {"name": test.name, "lastDuration": 0.0}},
+                {"node": {"name": test_2.name, "lastDuration": 3.0}},
+                {"node": {"name": test.name, "lastDuration": 2.0}},
             ]
         }
 
@@ -924,7 +925,7 @@ def test_flake_aggregates_7_days(self) -> None:
 
         res = self.fetch_test_analytics(
             repo.name,
-            """flakeAggregates(history: INTERVAL_7_DAY) { flakeCount, flakeRate, flakeCountPercentChange, flakeRatePercentChange }""",
+            """flakeAggregates(interval: INTERVAL_7_DAY) { flakeCount, flakeRate, flakeCountPercentChange, flakeRatePercentChange }""",
         )
 
         assert res["flakeAggregates"] == {

graphql_api/tests/test_test_result.py

@@ -197,7 +197,7 @@ def test_fetch_test_result_last_duration(self) -> None:
             result["owner"]["repository"]["testAnalytics"]["testResults"]["edges"][0][
                 "node"
             ]["lastDuration"]
-            == 0.0
+            == 1.0
         )
 
     def test_fetch_test_result_avg_duration(self) -> None:

graphql_api/types/inputs/test_results_filters.graphql

@@ -3,7 +3,7 @@ input TestResultsFilters {
   parameter: TestResultsFilterParameter
   test_suites: [String!]
   flags: [String!]
-  history: MeasurementInterval
+  interval: MeasurementInterval
   term: String
 }
 

graphql_api/types/test_analytics/test_analytics.graphql

@@ -13,10 +13,10 @@ type TestAnalytics {
   ): TestResultConnection! @cost(complexity: 10, multipliers: ["first", "last"])
 
   "Test results aggregates are analytics data totals across all tests"
-  testResultsAggregates(history: MeasurementInterval): TestResultsAggregates
+  testResultsAggregates(interval: MeasurementInterval): TestResultsAggregates
 
   "Flake aggregates are flake totals across all tests"
-  flakeAggregates(history: MeasurementInterval): FlakeAggregates
+  flakeAggregates(interval: MeasurementInterval): FlakeAggregates
 }
 
 type TestResultConnection {

graphql_api/types/test_analytics/test_analytics.py

@@ -6,7 +6,6 @@
 
 from codecov.db import sync_to_async
 from core.models import Repository
-from graphql_api.helpers.connection import queryset_to_connection
 from graphql_api.types.enums import OrderingDirection, TestResultsFilterParameter
 from graphql_api.types.enums.enum_types import MeasurementInterval
 from utils.test_results import (
@@ -28,70 +27,72 @@ async def resolve_test_results(
     info: GraphQLResolveInfo,
     ordering=None,
     filters=None,
-    **kwargs,
+    first: int | None = None,
+    after: str | None = None,
+    last: int | None = None,
+    before: str | None = None,
 ):
     parameter = (
         convert_test_results_filter_parameter(filters.get("parameter"))
         if filters
         else None
     )
-    history = (
-        convert_history_to_timedelta(filters.get("history"))
+    interval = (
+        convert_interval_to_timedelta(filters.get("interval"))
         if filters
         else timedelta(days=30)
     )
 
     queryset = await sync_to_async(generate_test_results)(
-        repoid=repository.repoid,
-        history=history,
-        branch=filters.get("branch") if filters else None,
-        parameter=parameter,
-        testsuites=filters.get("test_suites") if filters else None,
-        flags=filters.get("flags") if filters else None,
-        term=filters.get("term") if filters else None,
-    )
-
-    return await queryset_to_connection(
-        queryset,
         ordering=(
-            (ordering.get("parameter"), "name")
+            (ordering.get("parameter").value, "name")
             if ordering
             else ("avg_duration", "name")
         ),
         ordering_direction=(
             ordering.get("direction") if ordering else OrderingDirection.DESC
         ),
-        **kwargs,
+        repoid=repository.repoid,
+        interval=interval,
+        first=first,
+        after=after,
+        last=last,
+        before=before,
+        branch=filters.get("branch") if filters else None,
+        parameter=parameter,
+        testsuites=filters.get("test_suites") if filters else None,
+        flags=filters.get("flags") if filters else None,
+        term=filters.get("term") if filters else None,
     )
 
+    return queryset
+
 
 @test_analytics_bindable.field("testResultsAggregates")
 async def resolve_test_results_aggregates(
     repository: Repository,
     info: GraphQLResolveInfo,
-    history: MeasurementInterval | None = None,
+    interval: MeasurementInterval | None = None,
     **_,
 ):
-    history = convert_history_to_timedelta(history)
     return await sync_to_async(generate_test_results_aggregates)(
-        repoid=repository.repoid, history=history
+        repoid=repository.repoid, interval=convert_interval_to_timedelta(interval)
     )
 
 
 @test_analytics_bindable.field("flakeAggregates")
 async def resolve_flake_aggregates(
     repository: Repository,
     info: GraphQLResolveInfo,
-    history: MeasurementInterval | None = None,
+    interval: MeasurementInterval | None = None,
     **_,
 ):
-    history = convert_history_to_timedelta(history)
     return await sync_to_async(generate_flake_aggregates)(
-        repoid=repository.repoid, history=history
+        repoid=repository.repoid, interval=convert_interval_to_timedelta(interval)
     )
 
 
-def convert_history_to_timedelta(interval: MeasurementInterval | None) -> timedelta:
+def convert_interval_to_timedelta(interval: MeasurementInterval | None) -> timedelta:
     if interval is None:
         return timedelta(days=30)
 

graphql_api/types/test_results/test_results.py

@@ -1,71 +1,58 @@
 from datetime import datetime
-from typing import TypedDict
 
 from ariadne import ObjectType
 from graphql import GraphQLResolveInfo
 
-
-class TestDict(TypedDict):
-    name: str
-    updated_at: datetime
-    commits_where_fail: int
-    failure_rate: float
-    avg_duration: float
-    last_duration: float
-    flake_rate: float
-    total_fail_count: int
-    total_skip_count: int
-    total_pass_count: int
-
+from utils.test_results import TestResultsRow
 
 test_result_bindable = ObjectType("TestResult")
 
 
 @test_result_bindable.field("name")
-def resolve_name(test: TestDict, _: GraphQLResolveInfo) -> str:
-    return test["name"].replace("\x1f", " ")
+def resolve_name(test: TestResultsRow, _: GraphQLResolveInfo) -> str:
+    return test.name.replace("\x1f", " ")
 
 
 @test_result_bindable.field("updatedAt")
-def resolve_updated_at(test: TestDict, _: GraphQLResolveInfo) -> datetime:
-    return test["updated_at"]
+def resolve_updated_at(test: TestResultsRow, _: GraphQLResolveInfo) -> datetime:
+    return test.updated_at
 
 
 @test_result_bindable.field("commitsFailed")
-def resolve_commits_failed(test: TestDict, _: GraphQLResolveInfo) -> int:
-    return test["commits_where_fail"]
+def resolve_commits_failed(test: TestResultsRow, _: GraphQLResolveInfo) -> int:
+    return test.commits_where_fail
 
 
 @test_result_bindable.field("failureRate")
-def resolve_failure_rate(test: TestDict, _: GraphQLResolveInfo) -> float:
-    return test["failure_rate"]
+def resolve_failure_rate(test: TestResultsRow, _: GraphQLResolveInfo) -> float:
+    return test.failure_rate
 
 
 @test_result_bindable.field("flakeRate")
-def resolve_flake_rate(test: TestDict, _: GraphQLResolveInfo) -> float:
-    return test["flake_rate"]
+def resolve_flake_rate(test: TestResultsRow, _: GraphQLResolveInfo) -> float:
+    return test.flake_rate
 
 
 @test_result_bindable.field("avgDuration")
-def resolve_avg_duration(test: TestDict, _: GraphQLResolveInfo) -> float:
-    return test["avg_duration"]
+def resolve_avg_duration(test: TestResultsRow, _: GraphQLResolveInfo) -> float:
+    return test.avg_duration
 
 
 @test_result_bindable.field("lastDuration")
-def resolve_last_duration(test: TestDict, _: GraphQLResolveInfo) -> float:
-    return test["last_duration"]
+def resolve_last_duration(test: TestResultsRow, _: GraphQLResolveInfo) -> float:
+    return test.last_duration
 
 
 @test_result_bindable.field("totalFailCount")
-def resolve_total_fail_count(test: TestDict, _: GraphQLResolveInfo) -> int:
-    return test["total_fail_count"]
+def resolve_total_fail_count(test: TestResultsRow, _: GraphQLResolveInfo) -> int:
+    return test.total_fail_count
 
 
 @test_result_bindable.field("totalSkipCount")
-def resolve_total_skip_count(test: TestDict, _: GraphQLResolveInfo) -> int:
-    return test["total_skip_count"]
+def resolve_total_skip_count(test: TestResultsRow, _: GraphQLResolveInfo) -> int:
+    return test.total_skip_count
 
 
 @test_result_bindable.field("totalPassCount")
-def resolve_total_pass_count(test: TestDict, _: GraphQLResolveInfo) -> int:
-    return test["total_pass_count"]
+def resolve_total_pass_count(test: TestResultsRow, _: GraphQLResolveInfo) -> int:
+    return test.total_pass_count