fix: Include start/end dates for external course run

course_discovery/apps/api/tests/test_utils.py

@@ -116,16 +116,19 @@ def make_studio_data(self, run, add_pacing=True, add_schedule=True, team=None, a
         }
         if add_pacing:
             data['pacing_type'] = run.pacing_type
-        if add_schedule:
-            data['schedule'] = {
-                'start': serialize_datetime(run.start),
-                'end': serialize_datetime(run.end),
-            }
-        if add_enrollment_dates:
-            data['schedule'] = {
-                'enrollment_start': serialize_datetime(run.enrollment_start),
-                'enrollment_end': serialize_datetime(run.enrollment_end),
-            }
+
+        if add_schedule or add_enrollment_dates:
+            data['schedule'] = {}
+            if add_schedule:
+                data['schedule'].update({
+                    'start': serialize_datetime(run.start),
+                    'end': serialize_datetime(run.end),
+                })
+            if add_enrollment_dates:
+                data['schedule'].update({
+                    'enrollment_start': serialize_datetime(run.enrollment_start),
+                    'enrollment_end': serialize_datetime(run.enrollment_end),
+                })
         return data
 
     def test_create_rerun(self):
@@ -194,7 +197,7 @@ def test_generate_data_for_studio_api__external_course_enrollment_dates(self):
         exec_ed_type = CourseTypeFactory(slug=CourseType.EXECUTIVE_EDUCATION_2U)
         run = CourseRunFactory(course=CourseFactory(type=exec_ed_type))
         with mock.patch('course_discovery.apps.api.utils.logger') as mock_logger:
-            expected_data = self.make_studio_data(run, add_pacing=False, add_schedule=False, add_enrollment_dates=True)
+            expected_data = self.make_studio_data(run, add_pacing=False, add_schedule=True, add_enrollment_dates=True)
             output_data = StudioAPI.generate_data_for_studio_api(run, False)
             assert output_data == expected_data
         mock_logger.info.assert_called_with(
@@ -208,14 +211,35 @@ def test_generate_data_for_studio_api__external_course_missing_enrollment_dates(
         exec_ed_type = CourseTypeFactory(slug=CourseType.EXECUTIVE_EDUCATION_2U)
         run = CourseRunFactory(course=CourseFactory(type=exec_ed_type), enrollment_start=None, enrollment_end=None)
         with mock.patch('course_discovery.apps.api.utils.logger') as mock_logger:
-            expected_data = self.make_studio_data(run, add_pacing=False, add_schedule=False)
+            expected_data = self.make_studio_data(run, add_pacing=False, add_schedule=True, add_enrollment_dates=False)
             output_data = StudioAPI.generate_data_for_studio_api(run, False)
             assert output_data == expected_data
 
         with self.assertRaises(AssertionError):
-            mock_logger.info.assert_called_with(
-                f'Enrollment information added to data {output_data} for course run {run.key}'
-            )
+            mock_logger.info.assert_called()
+
+    def test_generate_data_for_studio_api__non_external_course_no_start_end_on_update(self):
+        """Test that start/end are NOT included when updating a non-external course."""
+        run = CourseRunFactory()  # Default: non-external
+        expected_data = self.make_studio_data(run, add_pacing=False, add_schedule=False, add_enrollment_dates=True)
+        with mock.patch('course_discovery.apps.api.utils.logger') as mock_logger:
+            output_data = StudioAPI.generate_data_for_studio_api(run, creating=False)
+            self.assertEqual(output_data, expected_data)
+        mock_logger.info.assert_called_with(
+            f'Enrollment information added to data {output_data} for course run {run.key}'
+        )
+
+    def test_generate_data_for_studio_api__external_course_start_end_on_update(self):
+        """Test that start/end are included for external course on update."""
+        exec_ed_type = CourseTypeFactory(slug=CourseType.EXECUTIVE_EDUCATION_2U)
+        run = CourseRunFactory(course=CourseFactory(type=exec_ed_type))
+        expected_data = self.make_studio_data(run, add_pacing=False, add_schedule=True, add_enrollment_dates=True)
+        with mock.patch('course_discovery.apps.api.utils.logger') as mock_logger:
+            output_data = StudioAPI.generate_data_for_studio_api(run, creating=False)
+            self.assertEqual(output_data, expected_data)
+        mock_logger.info.assert_called_with(
+            f'Enrollment information added to data {output_data} for course run {run.key}'
+        )
 
     def test_calculate_course_run_key_run_value_with_multiple_runs_per_trimester(self):
         start = datetime.datetime(2017, 2, 1)

course_discovery/apps/api/utils.py

@@ -253,10 +253,11 @@ def calculate_course_run_key_run_value(cls, course_num, start):
     def generate_data_for_studio_api(cls, course_run, creating, user=None):
         editors = [editor.user for editor in course_run.course.editors.all()]
         key = CourseKey.from_string(course_run.key)
-
+        is_external = course_run.course.is_external_course
         # start, end, and pacing are not sent on updates - Studio is where users edit them
-        start = course_run.start if creating else None
-        end = course_run.end if creating else None
+        # Include start and end only if creating or if it's an external course during update
+        start = course_run.start if creating or is_external else None
+        end = course_run.end if creating or is_external else None
         pacing = course_run.pacing_type if creating else None
         enrollment_start = course_run.enrollment_start
         enrollment_end = course_run.enrollment_end
@@ -300,10 +301,12 @@ def generate_data_for_studio_api(cls, course_run, creating, user=None):
             # But when the course run is created, in Studio or Discovery, the enrollment dates are not taken as input.
             # It is better to keep the flow consistent across places.
             # Allow sending enrollment start and end dates as part of Update only.
-            data['schedule'] = {
+            # Using setdefault + update avoids overwriting and prevents KeyErrors.
+            data.setdefault('schedule', {})
+            data['schedule'].update({
                 'enrollment_start': serialize_datetime(course_run.enrollment_start),
                 'enrollment_end': serialize_datetime(course_run.enrollment_end),
-            }
+            })
             logger.info(f"Enrollment information added to data {data} for course run {course_run.key}")
 
         return data

course_discovery/apps/course_metadata/data_loaders/csv_loader.py

@@ -481,6 +481,8 @@ def update_course_run_api_request_data(self, course_run_data, course_run, course
             'prices': self.get_pricing_representation(course_run_data['verified_price'], course_type),
             'staff': staff_uuids,
             'draft': is_draft,
+            'start': self.get_formatted_datetime_string(f"{course_run_data['start_date']} {course_run_data['start_time']}"),  # pylint: disable=line-too-long
+            'end': self.get_formatted_datetime_string(f"{course_run_data['end_date']} {course_run_data['end_time']}"),
 
             'weeks_to_complete': course_run_data['length'],
             'min_effort': course_run_data['minimum_effort'],

course_discovery/apps/course_metadata/data_loaders/tests/test_csv_loader.py

@@ -7,6 +7,7 @@
 from tempfile import NamedTemporaryFile
 from unittest import mock
 
+import pytz
 import responses
 from ddt import data, ddt, unpack
 from edx_toggles.toggles.testutils import override_waffle_switch
@@ -159,6 +160,53 @@ def test_invalid_course_run_type(self, jwt_decode_patch):  # pylint: disable=unu
                     assert Course.objects.count() == 0
                     assert CourseRun.objects.count() == 0
 
+    @responses.activate
+    def test_course_run_update_start_and_end_dates(self, jwt_decode_patch):  # pylint: disable=unused-argument
+        """
+        Verify that 'start_date' and 'end_date' from CSV correctly update
+        the published CourseRun after CSV ingestion.
+        """
+        self._setup_prerequisites(self.partner)
+        self.mock_studio_calls(self.partner)
+        self.mock_ecommerce_publication(self.partner)
+        self.mock_image_response()
+        course = CourseFactory(
+            key=self.COURSE_KEY,
+            partner=self.partner,
+            type=self.course_type,
+            draft=True
+        )
+        CourseRunFactory(
+            course=course,
+            key=self.COURSE_RUN_KEY,
+            type=self.course_run_type,
+            status='published',
+            draft=True,
+            start=datetime.datetime(2030, 1, 1, tzinfo=pytz.UTC),
+            end=datetime.datetime(2030, 12, 31, tzinfo=pytz.UTC)
+        )
+        csv_data = copy.deepcopy(mock_data.VALID_COURSE_AND_COURSE_RUN_CSV_DICT)
+        csv_data.update({
+            "start_date": "01/01/2035",
+            "start_time": "09:30",
+            "end_date": "12/31/2035",
+            "end_time": "17:45"
+        })
+        expected_start = datetime.datetime(2035, 1, 1, 9, 30, tzinfo=pytz.UTC)
+        expected_end = datetime.datetime(2035, 12, 31, 17, 45, tzinfo=pytz.UTC)
+        with NamedTemporaryFile() as csv_file:
+            csv_file = self._write_csv(csv_file, [csv_data])
+            with mock.patch.object(CSVDataLoader, 'call_course_api', self.mock_call_course_api):
+                loader = CSVDataLoader(
+                    self.partner,
+                    csv_path=csv_file.name,
+                    product_source=self.source.slug
+                )
+                loader.ingest()
+        course_run = CourseRun.objects.get(key=self.COURSE_RUN_KEY, draft=False)
+        assert course_run.start == expected_start, f"Expected start {expected_start}, got {course_run.start}"
+        assert course_run.end == expected_end, f"Expected end {expected_end}, got {course_run.end}"
+
     @responses.activate
     def test_image_download_failure(self, jwt_decode_patch):  # pylint: disable=unused-argument
         """