fix tests

graphql_api/context.py

@@ -1,4 +1,5 @@
 from typing import Generic, TypeVar
+
 from graphql.type.definition import GraphQLResolveInfo
 
 T = TypeVar("T")

graphql_api/tests/test_coverage_analytics.py

@@ -2,26 +2,24 @@
 
 from django.test import TransactionTestCase
 from django.utils import timezone
-from freezegun import freeze_time
 
 from codecov_auth.tests.factories import OwnerFactory
-from core.models import Repository # Import the actual model, not the factory
+from core.models import Repository
 from core.tests.factories import (
  CommitFactory,
  RepositoryFactory,
 )
 
 from .helper import GraphQLTestHelper
 
-# Queries for reuse
-query_coverage_analytics = """
-query CoverageAnalytics($owner:String!, $repo: String!, $interval: MeasurementInterval!) {
+query_coverage_analytics_base_fields = """
+query CoverageAnalytics($owner:String!, $repo: String!) {
  owner(username:$owner) {
  repository(name: $repo) {
  __typename
  ... on Repository {
  name
- coverageAnalytics(interval: $interval) {
+ coverageAnalytics {
  %s
  }
  }
@@ -33,33 +31,30 @@
 }
 """
 
-default_coverage_analytics_fields = """
+default_coverage_analytics_base_fields = """
  percentCovered
  commitSha
  hits
  misses
  lines
- measurements(interval: $interval) {
- timestamp
- max
- min
- avg
- }
 """
 
 
-class TestFetchCoverageAnalytics(GraphQLTestHelper, TransactionTestCase):
+class TestFetchCoverageAnalyticsBaseFields(GraphQLTestHelper, TransactionTestCase):
  def fetch_coverage_analytics(
- self, repo_name, interval="INTERVAL_1_DAY", fields=None
+ self, repo_name, fields=None
  ):
- query = query_coverage_analytics % (fields or default_coverage_analytics_fields)
- variables = {"owner": "codecov-user", "repo": repo_name, "interval": interval}
+ query = query_coverage_analytics_base_fields % (fields or default_coverage_analytics_base_fields)
+ variables = {"owner": "codecov-user", "repo": repo_name}
  return self.gql_request(query=query, owner=self.owner, variables=variables)
 
  def setUp(self):
  self.owner = OwnerFactory(username="codecov-user")
  self.yaml = {"test": "test"}
- self.repo = RepositoryFactory(
+
+ def test_coverage_analytics_base_fields(self):
+ # Create repo, commit, and coverage data
+ repo = RepositoryFactory(
  author=self.owner,
  active=True,
  private=True,
@@ -68,102 +63,82 @@ def setUp(self):
  language="erlang",
  languages=[],
  )
-
- # Ensure the repository is saved correctly
- self.repo.save()
- self.assertTrue(
- self.repo.pk, "Repository should be saved and have a primary key."
- )
-
- @freeze_time("2021-01-01")
- def test_full_coverage_analytics(self):
- """Test with full coverage analytics fields"""
- # Create commit and coverage data
- hour_ago = timezone.make_aware(datetime.datetime(2020, 12, 31, 23, 0)) # Fixed
+ hour_ago = timezone.make_aware(datetime.datetime(2020, 12, 31, 23, 0))
  coverage_commit = CommitFactory(
- repository=self.repo,
+ repository=repo,
  totals={"c": 75, "h": 30, "m": 10, "n": 40},
  timestamp=hour_ago,
  )
- CommitFactory(repository=self.repo, totals={"c": 85})
+ CommitFactory(repository=repo, totals={"c": 85})
 
- # Ensure the repository's timestamp is updated
- self.repo.updatestamp = timezone.now() # Use timezone-aware datetime
- self.repo.save()
+ # Update the timestamp and save to db
+ repo.updatestamp = timezone.now()
+ repo.save()
+ self.assertTrue(
+ repo.pk, "Repository should be saved and have a primary key."
+ )
 
- # Query the database using the actual model (Repository)
- repo_from_db = Repository.objects.get(
- pk=self.repo.pk
- ) # Use the Repository model, not the factory
+ # Query the db using the repository model
+ repo_from_db = Repository.objects.get(pk=repo.pk)
  self.assertIsNotNone(repo_from_db.updatestamp)
 
  # Fetch the coverage analytics data
- coverage_data = self.fetch_coverage_analytics(self.repo.name)
-
- print(coverage_data)
+ coverage_analytics_data = self.fetch_coverage_analytics(repo.name)
 
+ # Define the expected response
  expected_response = {
  "__typename": "Repository",
- "name": self.repo.name,
+ "name": repo.name,
  "coverageAnalytics": {
  "percentCovered": 75,
  "commitSha": coverage_commit.commitid,
  "hits": 30,
  "misses": 10,
  "lines": 40,
- "measurements": [], # Assuming measurements are empty for now
  },
  }
- assert coverage_data["owner"]["repository"] == expected_response
-
- #
- # @freeze_time("2021-01-01")
- # def test_partial_coverage_analytics(self):
- # """Test fetching partial fields (only percentCovered)"""
- # CommitFactory(repository=self.repo, totals={"c": 75, "h": 30, "m": 10, "n": 40})
- #
- # self.repo.updatestamp = datetime.datetime.now()
- # self.repo.save()
- #
- # fields = "percentCovered"
- # coverage_data = self.fetch_coverage_analytics(self.repo.name, fields=fields)
- # assert coverage_data["owner"]["repository"]["coverageAnalytics"]["percentCovered"] == 75
- #
- # @freeze_time("2021-01-01")
- # def test_measurements_coverage_analytics(self):
- # """Test fetching only measurements subfield"""
- # CommitFactory(
- # repository=self.repo,
- # totals={"c": 75, "h": 30, "m": 10, "n": 40},
- # timestamp=datetime.datetime.now() - datetime.timedelta(hours=1),
- # )
- #
- # self.repo.updatestamp = datetime.datetime.now()
- # self.repo.save()
- #
- # fields = "measurements(interval: $interval) { timestamp max }"
- # coverage_data = self.fetch_coverage_analytics(self.repo.name, fields=fields)
- # assert coverage_data["owner"]["repository"]["coverageAnalytics"]["measurements"] == []
- #
- # def test_coverage_analytics_no_commit(self):
- # """Test case where no commits exist for coverage data"""
- # repo = RepositoryFactory(
- # author=self.owner,
- # active=True,
- # private=True,
- # name="empty-repo",
- # yaml=self.yaml,
- # language="erlang",
- # languages=[],
- # )
- # repo.save()
- #
- # coverage_data = self.fetch_coverage_analytics(repo.name)
- # assert coverage_data["owner"]["repository"]["coverageAnalytics"] == {
- # "percentCovered": None,
- # "commitSha": None,
- # "hits": None,
- # "misses": None,
- # "lines": None,
- # "measurements": [],
- # }
+
+ # Compare the actual data with the expected data
+ assert coverage_analytics_data["owner"]["repository"] == expected_response
+
+ def test_coverage_analytics_base_fields_partial(self):
+ repo = RepositoryFactory(
+ author=self.owner,
+ active=True,
+ private=True,
+ name="b",
+ yaml=self.yaml,
+ language="erlang",
+ languages=[],
+ )
+ hour_ago = timezone.make_aware(datetime.datetime(2020, 12, 31, 23, 0))
+ CommitFactory(repository=repo, totals={"c": 75, "h": 30, "m": 10, "n": 40}, timestamp=hour_ago)
+ repo.updatestamp = timezone.now()
+ repo.save()
+
+ fields = "percentCovered"
+ coverage_data = self.fetch_coverage_analytics(repo.name, fields=fields)
+ print(coverage_data)
+ assert coverage_data["owner"]["repository"]["coverageAnalytics"]["percentCovered"] == 75
+
+ def test_coverage_analytics_no_commit(self):
+ """Test case where no commits exist for coverage data"""
+ repo = RepositoryFactory(
+ author=self.owner,
+ active=True,
+ private=True,
+ name="empty-repo",
+ yaml=self.yaml,
+ language="erlang",
+ languages=[],
+ )
+ repo.save()
+
+ coverage_data = self.fetch_coverage_analytics(repo.name)
+ assert coverage_data["owner"]["repository"]["coverageAnalytics"] == {
+ "percentCovered": None,
+ "commitSha": None,
+ "hits": None,
+ "misses": None,
+ "lines": None,
+ }