refactor: use PearsonImportError for imports

eox_nelp/pearson_vue/exceptions.py

@@ -89,3 +89,10 @@ class PearsonValidationError(PearsonBaseError):
     """Pearson Validation error class
     """
     exception_type = "validation-error"
+
+
+class PearsonImportError(PearsonBaseError):
+    """Pearson Import error class.
+    Error related with a failure response from Pearson Vue site.
+    """
+    exception_type = "import-error"

eox_nelp/pearson_vue/pipeline.py

@@ -28,6 +28,7 @@
 from eox_nelp.pearson_vue.exceptions import (
     PearsonAttributeError,
     PearsonBaseError,
+    PearsonImportError,
     PearsonKeyError,
     PearsonValidationError,
 )
@@ -200,41 +201,35 @@ def import_candidate_demographics(cdd_request, **kwargs):  # pylint: disable=unu
     Raises:
         Exception: If the Pearson VUE RTI service does not accept the import request.
     """
-    @audit_method(action="Import Candidate Demographics")
-    def import_candidate_demographics_request(cdd_request):
-        """This is a wrapper that allows to make audit-able the import_candidate_demographics method."""
-        api_client = PearsonRTIApiClient()
-        payload = {
-            "soapenv:Envelope": {
-                "soapenv:Header": {
-                    "wsse:Security": {
-                        "wsse:UsernameToken": {
-                            "wsse:Username": getattr(settings, "PEARSON_RTI_WSDL_USERNAME"),
-                            "wsse:Password": {
-                                "#text": getattr(settings, "PEARSON_RTI_WSDL_PASSWORD")
-                            },
+    api_client = PearsonRTIApiClient()
+    payload = {
+        "soapenv:Envelope": {
+            "soapenv:Header": {
+                "wsse:Security": {
+                    "wsse:UsernameToken": {
+                        "wsse:Username": getattr(settings, "PEARSON_RTI_WSDL_USERNAME"),
+                        "wsse:Password": {
+                            "#text": getattr(settings, "PEARSON_RTI_WSDL_PASSWORD")
                         },
                     },
                 },
-                "soapenv:Body": {
-                    "sch:cddRequest": cdd_request
-                },
             },
-        }
-        payload = update_xml_with_dict(PAYLOAD_CDD, payload)
-
-        response = api_client.import_candidate_demographics(payload)
+            "soapenv:Body": {
+                "sch:cddRequest": cdd_request
+            },
+        },
+    }
+    payload = update_xml_with_dict(PAYLOAD_CDD, payload)
 
-        if response.get("status", "error") == "accepted":
-            return response
+    response = api_client.import_candidate_demographics(payload)
 
-        logger.info("Import candidate demographics pipeline has failed with the following response: %s", response)
-        # pylint: disable=broad-exception-raised
-        raise Exception(
-            response.get("message", "Error trying to process import candidate demographics request.")
-        )
+    if response.get("status", "error") == "accepted":
+        return response
 
-    import_candidate_demographics_request(cdd_request)
+    raise PearsonImportError(
+        exception_reason=f"Import candidate demographics pipeline has failed with the following response: {response}",
+        pipe_frame=inspect.currentframe()
+    )
 
 
 def import_exam_authorization(ead_request, **kwargs):  # pylint: disable=unused-argument
@@ -256,40 +251,34 @@ def import_exam_authorization(ead_request, **kwargs):  # pylint: disable=unused-
     Raises:
         Exception: If the Pearson VUE RTI service does not accept the import request.
     """
-    @audit_method(action="Import Exam Authorization")
-    def import_exam_authorization_request(ead_request):
-        """This is a wrapper that allows to make audit-able the import_exam_authorization method."""
-        api_client = PearsonRTIApiClient()
-        payload = {
-            "soapenv:Envelope": {
-                "soapenv:Header": {
-                    "wsse:Security": {
-                        "wsse:UsernameToken": {
-                            "wsse:Username": getattr(settings, "PEARSON_RTI_WSDL_USERNAME"),
-                            "wsse:Password": {
-                                "#text": getattr(settings, "PEARSON_RTI_WSDL_PASSWORD")
-                            },
+    api_client = PearsonRTIApiClient()
+    payload = {
+        "soapenv:Envelope": {
+            "soapenv:Header": {
+                "wsse:Security": {
+                    "wsse:UsernameToken": {
+                        "wsse:Username": getattr(settings, "PEARSON_RTI_WSDL_USERNAME"),
+                        "wsse:Password": {
+                            "#text": getattr(settings, "PEARSON_RTI_WSDL_PASSWORD")
                         },
                     },
                 },
-                "soapenv:Body": {
-                    "sch:eadRequest": ead_request
-                },
             },
-        }
-        payload = update_xml_with_dict(PAYLOAD_EAD, payload)
-        response = api_client.import_exam_authorization(payload)
-
-        if response.get("status", "error") == "accepted":
-            return response
+            "soapenv:Body": {
+                "sch:eadRequest": ead_request
+            },
+        },
+    }
+    payload = update_xml_with_dict(PAYLOAD_EAD, payload)
+    response = api_client.import_exam_authorization(payload)
 
-        logger.info("Import exam authorization pipeline has failed with the following response: %s", response)
-        # pylint: disable=broad-exception-raised
-        raise Exception(
-            response.get("message", "Error trying to process import exam authorization request.")
-        )
+    if response.get("status", "error") == "accepted":
+        return response
 
-    import_exam_authorization_request(ead_request)
+    raise PearsonImportError(
+        exception_reason=f"Import exam authorization pipeline has failed with the following response: {response}",
+        pipe_frame=inspect.currentframe(),
+    )
 
 
 def get_exam_data(user_id, course_id, **kwargs):  # pylint: disable=unused-argument

eox_nelp/pearson_vue/tests/test_pipeline.py

@@ -15,7 +15,12 @@
 from eox_nelp.edxapp_wrapper.student import CourseEnrollment, anonymous_id_for_user
 from eox_nelp.pearson_vue import pipeline
 from eox_nelp.pearson_vue.constants import PAYLOAD_CDD, PAYLOAD_EAD, PAYLOAD_PING_DATABASE
-from eox_nelp.pearson_vue.exceptions import PearsonAttributeError, PearsonKeyError, PearsonValidationError
+from eox_nelp.pearson_vue.exceptions import (
+    PearsonAttributeError,
+    PearsonImportError,
+    PearsonKeyError,
+    PearsonValidationError,
+)
 from eox_nelp.pearson_vue.pipeline import (
     audit_pearson_error,
     build_cdd_request,
@@ -417,13 +422,14 @@ def test_import_candidate_demographics_failure(self, mock_update_xml_with_dict,
         when the import request is not accepted.
 
             Expected behavior:
-            - Function raises an exception.
+            - Function raises a PearsonImportError exception.
             - Exception message is the expected.
             - update_xml_with_dict was called with the right parameters.
             - import_candidate_demographics method was called with the result of update_xml_with_dict.
         """
         mock_update_xml_with_dict.return_value = 'updated_payload'
-        mock_api_client.return_value.import_candidate_demographics.return_value = {"status": "error"}
+        response_return = {"status": "error"}
+        mock_api_client.return_value.import_candidate_demographics.return_value = response_return
         input_data = {
             "cdd_request": self.cdd_request
         }
@@ -445,10 +451,13 @@ def test_import_candidate_demographics_failure(self, mock_update_xml_with_dict,
             },
         }
 
-        with self.assertRaises(Exception) as context:
+        with self.assertRaises(PearsonImportError) as context:
             import_candidate_demographics(**input_data)
 
-        self.assertEqual(str(context.exception), "Error trying to process import candidate demographics request.")
+        self.assertEqual(
+            context.exception.exception_reason,
+            f"Import candidate demographics pipeline has failed with the following response: {response_return}"
+        )
         mock_update_xml_with_dict.assert_called_once_with(PAYLOAD_CDD, expected_payload)
         mock_api_client.return_value.import_candidate_demographics.assert_called_once_with(mock_update_xml_with_dict())
 
@@ -509,13 +518,14 @@ def test_import_exam_authorization_failure(self, mock_update_xml_with_dict, mock
         Test that the import_exam_authorization function raises an exception when the import request is not accepted.
 
             Expected behavior:
-            - Function raises an exception.
+            - Function raises a PearsonImportError exception.
             - Exception message is the expected.
             - update_xml_with_dict was called with the right parameters.
             - import_exam_authorization method was called with the result of update_xml_with_dict.
         """
         mock_update_xml_with_dict.return_value = 'updated_payload'
-        mock_api_client.return_value.import_exam_authorization.return_value = {"status": "error"}
+        response_return = {"status": "error"}
+        mock_api_client.return_value.import_exam_authorization.return_value = response_return
         input_data = {
             "ead_request": self.ead_request
         }
@@ -537,10 +547,13 @@ def test_import_exam_authorization_failure(self, mock_update_xml_with_dict, mock
             },
         }
 
-        with self.assertRaises(Exception) as context:
+        with self.assertRaises(PearsonImportError) as context:
             import_exam_authorization(**input_data)
 
-        self.assertEqual(str(context.exception), "Error trying to process import exam authorization request.")
+        self.assertEqual(
+            context.exception.exception_reason,
+            f"Import exam authorization pipeline has failed with the following response: {response_return}",
+        )
         mock_update_xml_with_dict.assert_called_once_with(PAYLOAD_EAD, expected_payload)
         mock_api_client.return_value.import_exam_authorization.assert_called_once_with(mock_update_xml_with_dict())