Revcert changes to next_start_date (will be done in subsequent PR)

Author: mbertrand

learning_resources/etl/loaders.py

@@ -46,6 +46,7 @@
     Video,
     VideoChannel,
     VideoPlaylist,
+    now_in_utc,
 )
 from learning_resources.utils import (
     add_parent_topics_to_learning_resource,
@@ -138,12 +139,11 @@ def load_run_dependent_values(
     Returns:
         tuple[datetime.time | None, list[Decimal], str]: date, prices, and availability
     """
+    now = now_in_utc()
     best_run = resource.best_run
     if resource.published and best_run:
-        resource.next_start_date = (
-            max(filter(None, [best_run.start_date, best_run.enrollment_start]))
-            if best_run.start_date or best_run.enrollment_start
-            else None
+        resource.next_start_date = max(
+            best_run.start_date or best_run.enrollment_start or now, now
         )
         resource.availability = best_run.availability
         resource.prices = (

learning_resources/etl/loaders_test.py

@@ -1,6 +1,6 @@
 """Tests for ETL loaders"""
 
-from datetime import datetime, timedelta
+from datetime import timedelta
 from decimal import Decimal
 from pathlib import Path
 
@@ -382,7 +382,7 @@ def test_load_program_bad_platform(mocker):
 @pytest.mark.parametrize("delivery", [LearningResourceDelivery.hybrid.name, None])
 @pytest.mark.parametrize("has_upcoming_run", [True, False])
 @pytest.mark.parametrize("has_departments", [True, False])
-def test_load_course(  # noqa: PLR0913, PLR0912, PLR0915
+def test_load_course(  # noqa: PLR0913,PLR0912,PLR0915, C901
     mock_upsert_tasks,
     course_exists,
     is_published,
@@ -498,9 +498,10 @@ def test_load_course(  # noqa: PLR0913, PLR0912, PLR0915
     assert result.professional is True
 
     if is_published and is_run_published and not blocklisted:
-        assert result.next_start_date == start_date
-    else:
-        assert result.next_start_date is None
+        if has_upcoming_run:
+            assert result.next_start_date == start_date
+        else:
+            assert result.next_start_date.date() == now.date()
     assert result.prices == (
         [Decimal("0.00"), Decimal("49.00")]
         if is_run_published and result.certification
@@ -1747,17 +1748,15 @@ def test_load_run_dependent_values(certification):
     course = LearningResourceFactory.create(
         is_course=True, certification=certification, runs=[]
     )
-    assert course.runs.count() == 0
     closest_date = now_in_utc() + timedelta(days=1)
     furthest_date = now_in_utc() + timedelta(days=2)
-    best_run = LearningResourceRunFactory.create(
+    run = LearningResourceRunFactory.create(
         learning_resource=course,
         published=True,
         availability=Availability.dated.name,
         prices=[Decimal("0.00"), Decimal("20.00")],
         resource_prices=LearningResourcePriceFactory.create_batch(2),
         start_date=closest_date,
-        enrollment_start=None,
         location="Portland, ME",
         duration="3 - 4 weeks",
         min_weeks=3,
@@ -1773,7 +1772,6 @@ def test_load_run_dependent_values(certification):
         prices=[Decimal("0.00"), Decimal("50.00")],
         resource_prices=LearningResourcePriceFactory.create_batch(2),
         start_date=furthest_date,
-        enrollment_start=None,
         location="Portland, OR",
         duration="7 - 9 weeks",
         min_weeks=7,
@@ -1783,23 +1781,15 @@ def test_load_run_dependent_values(certification):
         max_weekly_hours=19,
     )
     result = load_run_dependent_values(course)
-    course.refresh_from_db()
-    assert (
-        result.prices == course.prices == ([] if not certification else best_run.prices)
-    )
-    assert (
-        result.next_start_date
-        == course.next_start_date
-        == best_run.start_date
-        == closest_date
-    )
+    assert result.next_start_date == course.next_start_date == closest_date
+    assert result.prices == course.prices == ([] if not certification else run.prices)
     assert (
         list(result.resource_prices)
         == list(course.resource_prices.all())
-        == ([] if not certification else list(best_run.resource_prices.all()))
+        == ([] if not certification else list(run.resource_prices.all()))
     )
     assert result.availability == course.availability == Availability.dated.name
-    assert result.location == course.location == best_run.location
+    assert result.location == course.location == run.location
     for key in [
         "duration",
         "time_commitment",
@@ -1808,7 +1798,7 @@ def test_load_run_dependent_values(certification):
         "min_weekly_hours",
         "max_weekly_hours",
     ]:
-        assert getattr(result, key) == getattr(course, key) == getattr(best_run, key)
+        assert getattr(result, key) == getattr(course, key) == getattr(run, key)
 
 
 def test_load_run_dependent_values_resets_next_start_date():
@@ -1839,43 +1829,6 @@ def test_load_run_dependent_values_resets_next_start_date():
     assert course.next_start_date is None
 
 
-@pytest.mark.parametrize(
-    ("start_dt", "enrollnment_start", "expected_next"),
-    [
-        ("2025-01-01T10:00:00Z", "2024-12-15T10:00:00Z", "2025-01-01T10:00:00Z"),
-        ("2025-01-01T10:00:00Z", None, "2025-01-01T10:00:00Z"),
-        (None, "2024-12-15T10:00:00Z", "2024-12-15T10:00:00Z"),
-        (None, None, None),
-    ],
-)
-def test_load_run_dependent_values_next_start_date(
-    start_dt, enrollnment_start, expected_next
-):
-    """Test that next_start_date is correctly set from the best_run"""
-    course = LearningResourceFactory.create(is_course=True, published=True, runs=[])
-
-    # Create multiple runs with different start dates
-    LearningResourceRunFactory.create(
-        learning_resource=course,
-        published=True,
-        start_date=datetime.fromisoformat(start_dt) if start_dt else None,
-        enrollment_start=datetime.fromisoformat(enrollnment_start)
-        if enrollnment_start
-        else None,
-    )
-
-    # Call load_run_dependent_values
-    result = load_run_dependent_values(course)
-
-    # Refresh course from database
-    course.refresh_from_db()
-
-    # Verify that next_start_date matches the earliest run's start date
-    assert result.next_start_date == (
-        datetime.fromisoformat(expected_next) if expected_next else None
-    )
-
-
 @pytest.mark.parametrize(
     ("is_scholar_course", "tag_counts", "expected_score"),
     [