Ignore edx failures variable usage

courses/api.py

@@ -137,7 +137,7 @@ def create_run_enrollments(  # noqa: C901
     runs,
     *,
     change_status=None,
-    keep_failed_enrollments=False,
+    keep_failed_enrollments=None,
     mode=EDX_DEFAULT_ENROLLMENT_MODE,
 ):
     """
@@ -156,13 +156,19 @@ def create_run_enrollments(  # noqa: C901
         change_status (str): The status of the enrollment
         keep_failed_enrollments: (boolean): If True, keeps the local enrollment record
             in the database even if the enrollment fails in edX.
+            If None, defaults to the value of the IGNORE_EDX_FAILURES feature flag.
         mode (str): The course mode
 
     Returns:
         (list of CourseRunEnrollment, bool): A list of enrollment objects that were successfully
             created in mitxonline, paired with a boolean indicating whether or not the edX enrollment API call was successful
             for all of the given course runs
     """
+    if keep_failed_enrollments is None:
+        keep_failed_enrollments = settings.FEATURES.get(
+            features.IGNORE_EDX_FAILURES, False
+        )
+
     successful_enrollments = []
 
     def send_enrollment_emails():
@@ -328,7 +334,7 @@ def downgrade_learner(enrollment):
 def deactivate_run_enrollment(
     run_enrollment,
     change_status,
-    keep_failed_enrollments=False,  # noqa: FBT002
+    keep_failed_enrollments=None,
 ):
     """
     Helper method to deactivate a CourseRunEnrollment
@@ -338,13 +344,19 @@ def deactivate_run_enrollment(
         change_status (str): The change status to set on the enrollment when deactivating
         keep_failed_enrollments: (boolean): If True, keeps the local enrollment record
             in the database even if the enrollment fails in edX.
+            If None, defaults to the value of the IGNORE_EDX_FAILURES feature flag.
 
     Returns:
         CourseRunEnrollment: The deactivated enrollment
     """
     from ecommerce.models import Line  # noqa: PLC0415
     from hubspot_sync.task_helpers import sync_hubspot_line_by_line_id  # noqa: PLC0415
 
+    if keep_failed_enrollments is None:
+        keep_failed_enrollments = settings.FEATURES.get(
+            features.IGNORE_EDX_FAILURES, False
+        )
+
     try:
         unenroll_edx_course_run(run_enrollment)
     except Exception:  # pylint: disable=broad-except

courses/api_test.py

@@ -14,6 +14,7 @@
 import pytest
 import responses
 import reversion
+from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.test import RequestFactory
 from edx_api.course_detail import CourseDetail, CourseMode, CourseModes
@@ -2628,3 +2629,124 @@ def test_program_certificate_verifiable_credentials_signing_payload(
     }
 
     assert payload == expected_payload
+
+
+@pytest.mark.parametrize(
+    "keep_failed_enrollments,flag_enabled,expected_behavior",  # noqa: PT006
+    [
+        (
+            None,
+            True,
+            True,
+        ),  # Feature flag enabled, parameter None -> keep failed enrollments
+        (
+            None,
+            False,
+            False,
+        ),  # Feature flag disabled, parameter None -> don't keep failed enrollments
+        (True, False, True),  # Explicit True overrides feature flag being False
+        (False, True, False),  # Explicit False overrides feature flag being True
+    ],
+)
+def test_create_run_enrollments_feature_flag(
+    mocker,
+    user,
+    keep_failed_enrollments,
+    flag_enabled,
+    expected_behavior,
+):
+    """
+    Test that create_run_enrollments respects the IGNORE_EDX_FAILURES feature flag
+    when keep_failed_enrollments parameter is None.
+    """
+
+    num_runs = 2
+    runs = CourseRunFactory.create_batch(num_runs)
+
+    # Mock the feature flag
+    mocker.patch.dict(
+        settings.FEATURES,
+        {"IGNORE_EDX_FAILURES": flag_enabled},
+    )
+
+    # Mock the edX enrollment to fail
+    exception_cls = EdxApiEnrollErrorException
+    inner_exception = MockHttpError()
+    mocker.patch(
+        "courses.api.enroll_in_edx_course_runs",
+        side_effect=exception_cls(user, runs[0], inner_exception),
+    )
+    mocker.patch("courses.api.log.exception")
+    mocker.patch("courses.api.mail_api.send_course_run_enrollment_email")
+
+    successful_enrollments, edx_request_success = create_run_enrollments(
+        user,
+        runs,
+        keep_failed_enrollments=keep_failed_enrollments,
+    )
+
+    # Verify behavior based on expected_behavior flag
+    expected_enrollments = num_runs if expected_behavior else 0
+    assert len(successful_enrollments) == expected_enrollments
+    assert edx_request_success is False
+
+
+@pytest.mark.parametrize(
+    "keep_failed_enrollments,flag_enabled,expected_behavior",  # noqa: PT006
+    [
+        (
+            None,
+            True,
+            True,
+        ),  # Feature flag enabled, parameter None -> keep failed enrollments
+        (
+            None,
+            False,
+            False,
+        ),  # Feature flag disabled, parameter None -> don't keep failed enrollments
+        (True, False, True),  # Explicit True overrides feature flag being False
+        (False, True, False),  # Explicit False overrides feature flag being True
+    ],
+)
+def test_deactivate_run_enrollment_feature_flag(
+    mocker,
+    keep_failed_enrollments,
+    flag_enabled,
+    expected_behavior,
+):
+    """
+    Test that deactivate_run_enrollment respects the IGNORE_EDX_FAILURES feature flag
+    when keep_failed_enrollments parameter is None.
+    """
+
+    # Create test enrollment
+    enrollment = CourseRunEnrollmentFactory()
+
+    # Mock the feature flag
+    mocker.patch.dict(
+        settings.FEATURES,
+        {"IGNORE_EDX_FAILURES": flag_enabled},
+    )
+
+    # Mock the unenroll to fail
+    mocker.patch(
+        "courses.api.unenroll_edx_course_run",
+        side_effect=Exception("edX API failure"),
+    )
+    mocker.patch("courses.api.log.exception")
+
+    result = deactivate_run_enrollment(
+        enrollment,
+        change_status=ENROLL_CHANGE_STATUS_UNENROLLED,
+        keep_failed_enrollments=keep_failed_enrollments,
+    )
+
+    # Verify behavior based on expected_behavior flag
+    # When flag is enabled (expected_behavior=True), enrollment should be deactivated despite failure
+    # When flag is disabled (expected_behavior=False), function returns None
+    if expected_behavior:
+        assert result is not None
+        assert not result.active
+        assert result.change_status == ENROLL_CHANGE_STATUS_UNENROLLED
+    else:
+        assert result is None

courses/serializers/v1/courses.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
+from django.conf import settings
 from drf_spectacular.utils import (
     extend_schema_field,
     extend_schema_serializer,
     inline_serializer,
 )
-from mitol.olposthog.features import is_enabled
 from rest_framework import serializers
 from rest_framework.exceptions import ValidationError
 
@@ -181,7 +181,9 @@ def create(self, validated_data):
         successful_enrollments, _ = create_run_enrollments(
             user,
             [run],
-            keep_failed_enrollments=is_enabled(features.IGNORE_EDX_FAILURES),
+            keep_failed_enrollments=settings.FEATURES.get(
+                features.IGNORE_EDX_FAILURES, False
+            ),
         )
         return successful_enrollments
 

courses/serializers/v2/courses.py

@@ -4,8 +4,8 @@
 
 import logging
 
+from django.conf import settings
 from drf_spectacular.utils import extend_schema_field, extend_schema_serializer
-from mitol.olposthog.features import is_enabled
 from rest_framework import serializers
 from rest_framework.exceptions import ValidationError
 
@@ -328,7 +328,9 @@ def create(self, validated_data):
         successful_enrollments, _ = create_run_enrollments(
             user,
             [run],
-            keep_failed_enrollments=is_enabled(features.IGNORE_EDX_FAILURES),
+            keep_failed_enrollments=settings.FEATURES.get(
+                features.IGNORE_EDX_FAILURES, False
+            ),
         )
         return successful_enrollments
 

courses/views/v1/__init__.py

@@ -4,6 +4,7 @@
 from typing import Tuple, Union  # noqa: UP035
 
 import django_filters
+from django.conf import settings
 from django.contrib.auth.models import User
 from django.contrib.contenttypes.models import ContentType
 from django.db import transaction
@@ -344,7 +345,9 @@ def post(self, request):
         _, edx_request_success = create_run_enrollments(
             user=user,
             runs=[run],
-            keep_failed_enrollments=is_enabled(features.IGNORE_EDX_FAILURES),
+            keep_failed_enrollments=settings.FEATURES.get(
+                features.IGNORE_EDX_FAILURES, False
+            ),
         )
 
         def respond(data, status=True):  # noqa: FBT002
@@ -355,7 +358,9 @@ def respond(data, status=True):  # noqa: FBT002
                 return Response("Ok" if status else "Fail")
             return HttpResponseRedirect(data)
 
-        if edx_request_success or is_enabled(features.IGNORE_EDX_FAILURES):
+        if edx_request_success or settings.FEATURES.get(
+            features.IGNORE_EDX_FAILURES, False
+        ):
             resp = respond(reverse("user-dashboard"))
             cookie_value = {
                 "type": USER_MSG_TYPE_ENROLLED,
@@ -441,7 +446,9 @@ def destroy(self, request, *args, **kwargs):  # noqa: ARG002
         deactivated_enrollment = deactivate_run_enrollment(
             enrollment,
             change_status=ENROLL_CHANGE_STATUS_UNENROLLED,
-            keep_failed_enrollments=is_enabled(features.IGNORE_EDX_FAILURES),
+            keep_failed_enrollments=settings.FEATURES.get(
+                features.IGNORE_EDX_FAILURES, False
+            ),
         )
         if deactivated_enrollment is None:
             return Response(status=status.HTTP_400_BAD_REQUEST)

courses/views/v2/__init__.py

@@ -2,9 +2,10 @@
 Course API Views version 2
 """
 
-import contextlib
+import logging
 
 import django_filters
+from django.conf import settings
 from django.db.models import Count, Prefetch, Q
 from django.http import JsonResponse
 from django.shortcuts import get_object_or_404
@@ -70,6 +71,8 @@
 from openedx.api import sync_enrollments_with_edx
 from openedx.constants import EDX_ENROLLMENT_AUDIT_MODE, EDX_ENROLLMENT_VERIFIED_MODE
 
+log = logging.getLogger(__name__)
+
 
 class Pagination(PageNumberPagination):
     """Paginator class for infinite loading"""
@@ -513,8 +516,18 @@ def get_serializer_context(self):
     def list(self, request, *args, **kwargs):
         """List user enrollments with optional sync."""
         if is_enabled(features.SYNC_ON_DASHBOARD_LOAD):
-            with contextlib.suppress(Exception):
+            ignore_edx_failures = settings.FEATURES.get(
+                features.IGNORE_EDX_FAILURES, False
+            )
+            try:
                 sync_enrollments_with_edx(self.request.user)
+            except Exception:  # pylint: disable=broad-except
+                log.exception(
+                    "Failed to sync enrollments with edX for user: %s",
+                    self.request.user.id,
+                )
+                if not ignore_edx_failures:
+                    raise
         return super().list(request, *args, **kwargs)
 
     @extend_schema(
@@ -535,7 +548,9 @@ def destroy(self, request, *args, **kwargs):  # noqa: ARG002
         deactivated_enrollment = deactivate_run_enrollment(
             enrollment,
             change_status=ENROLL_CHANGE_STATUS_UNENROLLED,
-            keep_failed_enrollments=is_enabled(features.IGNORE_EDX_FAILURES),
+            keep_failed_enrollments=settings.FEATURES.get(
+                features.IGNORE_EDX_FAILURES, False
+            ),
         )
         if deactivated_enrollment is None:
             return Response(status=status.HTTP_400_BAD_REQUEST)