def generate_user_certificates(student, course_key, course=None, insecure=False, generation_mode='batch', forced_grade=None): """ It will add the add-cert request into the xqueue. A new record will be created to track the certificate generation task. If an error occurs while adding the certificate to the queue, the task will have status 'error'. It also emits `edx.certificate.created` event for analytics. Args: student (User) course_key (CourseKey) Keyword Arguments: course (Course): Optionally provide the course object; if not provided it will be loaded. insecure - (Boolean) generation_mode - who has requested certificate generation. Its value should `batch` in case of django command and `self` if student initiated the request. forced_grade - a string indicating to replace grade parameter. if present grading will be skipped. """ xqueue = XQueueCertInterface() if insecure: xqueue.use_https = False if not course: course = modulestore().get_course(course_key, depth=0) generate_pdf = not has_html_certificates_enabled(course) cert = xqueue.add_cert(student, course_key, course=course, generate_pdf=generate_pdf, forced_grade=forced_grade) message = u'Queued Certificate Generation task for {user} : {course}' log.info(message.format(user=student.id, course=course_key)) # If cert_status is not present in certificate valid_statuses (for example unverified) then # add_cert returns None and raises AttributeError while accesing cert attributes. if cert is None: return if CertificateStatuses.is_passing_status(cert.status): emit_certificate_event( 'created', student, course_key, course, { 'user_id': student.id, 'course_id': six.text_type(course_key), 'certificate_id': cert.verify_uuid, 'enrollment_mode': cert.mode, 'generation_mode': generation_mode }) return cert.status
def generate_user_certificates(student, course_key, insecure=False, generation_mode='batch', forced_grade=None): """ It will add the add-cert request into the xqueue. A new record will be created to track the certificate generation task. If an error occurs while adding the certificate to the queue, the task will have status 'error'. It also emits `edx.certificate.created` event for analytics. This method has not yet been updated (it predates the certificates revamp). If modifying this method, see also generate_user_certificates() in generation_handler.py (which is very similar but is not called from a celery task). In the future these methods will be unified. Args: student (User) course_key (CourseKey) Keyword Arguments: insecure - (Boolean) generation_mode - who has requested certificate generation. Its value should `batch` in case of django command and `self` if student initiated the request. forced_grade - a string indicating to replace grade parameter. if present grading will be skipped. """ beta_testers_queryset = list_with_level(course_key, 'beta') if beta_testers_queryset.filter(username=student.username): log.info(f"Canceling Certificate Generation task for user {student.id} : {course_key}. User is a Beta Tester.") return xqueue = XQueueCertInterface() if insecure: xqueue.use_https = False course_overview = get_course_overview(course_key) generate_pdf = not has_html_certificates_enabled(course_overview) cert = xqueue.add_cert( student, course_key, generate_pdf=generate_pdf, forced_grade=forced_grade ) log.info(f"Queued Certificate Generation task for {student.id} : {course_key}") # If cert_status is not present in certificate valid_statuses (for example unverified) then # add_cert returns None and raises AttributeError while accessing cert attributes. if cert is None: return if CertificateStatuses.is_passing_status(cert.status): emit_certificate_event('created', student, course_key, course_overview, { 'user_id': student.id, 'course_id': str(course_key), 'certificate_id': cert.verify_uuid, 'enrollment_mode': cert.mode, 'generation_mode': generation_mode }) return cert.status
def generate_user_certificates(student, course_key, course=None, insecure=False, generation_mode='batch', forced_grade=None): """ It will add the add-cert request into the xqueue. A new record will be created to track the certificate generation task. If an error occurs while adding the certificate to the queue, the task will have status 'error'. It also emits `edx.certificate.created` event for analytics. Args: student (User) course_key (CourseKey) Keyword Arguments: course (Course): Optionally provide the course object; if not provided it will be loaded. insecure - (Boolean) generation_mode - who has requested certificate generation. Its value should `batch` in case of django command and `self` if student initiated the request. forced_grade - a string indicating to replace grade parameter. if present grading will be skipped. """ xqueue = XQueueCertInterface() if insecure: xqueue.use_https = False if not course: course = modulestore().get_course(course_key, depth=0) generate_pdf = not has_html_certificates_enabled(course) cert = xqueue.add_cert( student, course_key, course=course, generate_pdf=generate_pdf, forced_grade=forced_grade ) # If cert_status is not present in certificate valid_statuses (for example unverified) then # add_cert returns None and raises AttributeError while accesing cert attributes. if cert is None: return if CertificateStatuses.is_passing_status(cert.status): emit_certificate_event('created', student, course_key, course, { 'user_id': student.id, 'course_id': unicode(course_key), 'certificate_id': cert.verify_uuid, 'enrollment_mode': cert.mode, 'generation_mode': generation_mode }) return cert.status
def generate_user_certificates(student, course_key, course=None, insecure=False, generation_mode='batch', forced_grade=None): """ It will add the add-cert request into the xqueue. A new record will be created to track the certificate generation task. If an error occurs while adding the certificate to the queue, the task will have status 'error'. It also emits `edx.certificate.created` event for analytics. This method has not yet been updated (it predates the certificates revamp). If modifying this method, see also generate_user_certificates() in generation.py (which is very similar but is called from a celery task). In the future these methods will be unified. Args: student (User) course_key (CourseKey) Keyword Arguments: course (Course): Optionally provide the course object; if not provided it will be loaded. insecure - (Boolean) generation_mode - who has requested certificate generation. Its value should `batch` in case of django command and `self` if student initiated the request. forced_grade - a string indicating to replace grade parameter. if present grading will be skipped. """ if is_using_certificate_allowlist_and_is_on_allowlist(student, course_key): # Note that this will launch an asynchronous task, and so cannot return the certificate status. This is a # change from the older certificate code that tries to immediately create a cert. log.info( f'{course_key} is using allowlist certificates, and the user {student.id} is on its allowlist. ' f'Attempt will be made to regenerate an allowlist certificate.') return generate_allowlist_certificate_task(student, course_key) if not course: course = modulestore().get_course(course_key, depth=0) beta_testers_queryset = list_with_level(course, 'beta') if beta_testers_queryset.filter(username=student.username): message = 'Cancelling course certificate generation for user [{}] against course [{}], user is a Beta Tester.' log.info(message.format(student.username, course_key)) return xqueue = XQueueCertInterface() if insecure: xqueue.use_https = False generate_pdf = not has_html_certificates_enabled(course) cert = xqueue.add_cert(student, course_key, course=course, generate_pdf=generate_pdf, forced_grade=forced_grade) message = 'Queued Certificate Generation task for {user} : {course}' log.info(message.format(user=student.id, course=course_key)) # If cert_status is not present in certificate valid_statuses (for example unverified) then # add_cert returns None and raises AttributeError while accessing cert attributes. if cert is None: return if CertificateStatuses.is_passing_status(cert.status): emit_certificate_event( 'created', student, course_key, course, { 'user_id': student.id, 'course_id': str(course_key), 'certificate_id': cert.verify_uuid, 'enrollment_mode': cert.mode, 'generation_mode': generation_mode }) return cert.status
class XQueueCertInterfaceAddCertificateTest(ModuleStoreTestCase): """Test the "add to queue" operation of the XQueue interface. """ def setUp(self): super(XQueueCertInterfaceAddCertificateTest, self).setUp() self.user = UserFactory.create() self.course = CourseFactory.create() self.enrollment = CourseEnrollmentFactory( user=self.user, course_id=self.course.id, is_active=True, mode="honor", ) self.xqueue = XQueueCertInterface() self.user_2 = UserFactory.create() SoftwareSecurePhotoVerificationFactory.create(user=self.user_2, status='approved') def test_add_cert_callback_url(self): with mock_passing_grade(): with patch.object(XQueueInterface, 'send_to_queue') as mock_send: mock_send.return_value = (0, None) self.xqueue.add_cert(self.user, self.course.id) # Verify that the task was sent to the queue with the correct callback URL self.assertTrue(mock_send.called) __, kwargs = mock_send.call_args_list[0] actual_header = json.loads(kwargs['header']) self.assertIn('https://edx.org/update_certificate?key=', actual_header['lms_callback_url']) def test_no_create_action_in_queue_for_html_view_certs(self): """ Tests there is no certificate create message in the queue if generate_pdf is False """ with mock_passing_grade(): with patch.object(XQueueInterface, 'send_to_queue') as mock_send: self.xqueue.add_cert(self.user, self.course.id, generate_pdf=False) # Verify that add_cert method does not add message to queue self.assertFalse(mock_send.called) certificate = GeneratedCertificate.eligible_certificates.get( user=self.user, course_id=self.course.id) self.assertEqual(certificate.status, CertificateStatuses.downloadable) self.assertIsNotNone(certificate.verify_uuid) @ddt.data('honor', 'audit') @override_settings(AUDIT_CERT_CUTOFF_DATE=datetime.now(pytz.UTC) - timedelta(days=1)) def test_add_cert_with_honor_certificates(self, mode): """Test certificates generations for honor and audit modes.""" template_name = 'certificate-template-{id.org}-{id.course}.pdf'.format( id=self.course.id) mock_send = self.add_cert_to_queue(mode) if CourseMode.is_eligible_for_certificate(mode): self.assert_certificate_generated(mock_send, mode, template_name) else: self.assert_ineligible_certificate_generated(mock_send, mode) @ddt.data('credit', 'verified') def test_add_cert_with_verified_certificates(self, mode): """Test if enrollment mode is verified or credit along with valid software-secure verification than verified certificate should be generated. """ template_name = 'certificate-template-{id.org}-{id.course}-verified.pdf'.format( id=self.course.id) mock_send = self.add_cert_to_queue(mode) self.assert_certificate_generated(mock_send, 'verified', template_name) @ddt.data((True, CertificateStatuses.audit_passing), (False, CertificateStatuses.generating)) @ddt.unpack @override_settings(AUDIT_CERT_CUTOFF_DATE=datetime.now(pytz.UTC) - timedelta(days=1)) def test_ineligible_cert_whitelisted(self, disable_audit_cert, status): """ Test that audit mode students receive a certificate if DISABLE_AUDIT_CERTIFICATES feature is set to false """ # Enroll as audit CourseEnrollmentFactory(user=self.user_2, course_id=self.course.id, is_active=True, mode='audit') # Whitelist student CertificateWhitelistFactory(course_id=self.course.id, user=self.user_2) features = settings.FEATURES features['DISABLE_AUDIT_CERTIFICATES'] = disable_audit_cert with override_settings(FEATURES=features) and mock_passing_grade(): with patch.object(XQueueInterface, 'send_to_queue') as mock_send: mock_send.return_value = (0, None) self.xqueue.add_cert(self.user_2, self.course.id) certificate = GeneratedCertificate.certificate_for_student( self.user_2, self.course.id) self.assertIsNotNone(certificate) self.assertEqual(certificate.mode, 'audit') self.assertEqual(certificate.status, status) def add_cert_to_queue(self, mode): """ Dry method for course enrollment and adding request to queue. Returns a mock object containing information about the `XQueueInterface.send_to_queue` method, which can be used in other assertions. """ CourseEnrollmentFactory( user=self.user_2, course_id=self.course.id, is_active=True, mode=mode, ) with mock_passing_grade(): with patch.object(XQueueInterface, 'send_to_queue') as mock_send: mock_send.return_value = (0, None) self.xqueue.add_cert(self.user_2, self.course.id) return mock_send def assert_certificate_generated(self, mock_send, expected_mode, expected_template_name): """ Assert that a certificate was generated with the correct mode and template type. """ # Verify that the task was sent to the queue with the correct callback URL self.assertTrue(mock_send.called) __, kwargs = mock_send.call_args_list[0] actual_header = json.loads(kwargs['header']) self.assertIn('https://edx.org/update_certificate?key=', actual_header['lms_callback_url']) body = json.loads(kwargs['body']) self.assertIn(expected_template_name, body['template_pdf']) certificate = GeneratedCertificate.eligible_certificates.get( user=self.user_2, course_id=self.course.id) self.assertEqual(certificate.mode, expected_mode) def assert_ineligible_certificate_generated(self, mock_send, expected_mode): """ Assert that an ineligible certificate was generated with the correct mode. """ # Ensure the certificate was not generated self.assertFalse(mock_send.called) certificate = GeneratedCertificate.objects.get( user=self.user_2, course_id=self.course.id) self.assertIn(certificate.status, (CertificateStatuses.audit_passing, CertificateStatuses.audit_notpassing)) self.assertEqual(certificate.mode, expected_mode) @ddt.data( (CertificateStatuses.restricted, False), (CertificateStatuses.deleting, False), (CertificateStatuses.generating, True), (CertificateStatuses.unavailable, True), (CertificateStatuses.deleted, True), (CertificateStatuses.error, True), (CertificateStatuses.notpassing, True), (CertificateStatuses.downloadable, True), (CertificateStatuses.auditing, True), ) @ddt.unpack def test_add_cert_statuses(self, status, should_generate): """ Test that certificates can or cannot be generated with the given certificate status. """ with patch( 'lms.djangoapps.certificates.queue.certificate_status_for_student', Mock(return_value={'status': status})): mock_send = self.add_cert_to_queue('verified') if should_generate: self.assertTrue(mock_send.called) else: self.assertFalse(mock_send.called) @ddt.data( # Eligible and should stay that way (CertificateStatuses.downloadable, timedelta(days=-2), 'Pass', CertificateStatuses.generating), # Ensure that certs in the wrong state can be fixed by regeneration (CertificateStatuses.downloadable, timedelta(hours=-1), 'Pass', CertificateStatuses.audit_passing), # Ineligible and should stay that way (CertificateStatuses.audit_passing, timedelta(hours=-1), 'Pass', CertificateStatuses.audit_passing), # As above (CertificateStatuses.audit_notpassing, timedelta(hours=-1), 'Pass', CertificateStatuses.audit_passing), # As above (CertificateStatuses.audit_notpassing, timedelta(hours=-1), None, CertificateStatuses.audit_notpassing), ) @ddt.unpack @override_settings(AUDIT_CERT_CUTOFF_DATE=datetime.now(pytz.UTC) - timedelta(days=1)) def test_regen_audit_certs_eligibility(self, status, created_delta, grade, expected_status): """ Test that existing audit certificates remain eligible even if cert generation is re-run. """ # Create an existing audit enrollment and certificate CourseEnrollmentFactory( user=self.user_2, course_id=self.course.id, is_active=True, mode=CourseMode.AUDIT, ) created_date = datetime.now(pytz.UTC) + created_delta with freezegun.freeze_time(created_date): GeneratedCertificateFactory( user=self.user_2, course_id=self.course.id, grade='1.0', status=status, mode=GeneratedCertificate.MODES.audit, ) # Run grading/cert generation again with mock_passing_grade(letter_grade=grade): with patch.object(XQueueInterface, 'send_to_queue') as mock_send: mock_send.return_value = (0, None) self.xqueue.add_cert(self.user_2, self.course.id) self.assertEqual( GeneratedCertificate.objects.get(user=self.user_2, course_id=self.course.id).status, expected_status) def test_regen_cert_with_pdf_certificate(self): """ Test that regenerating PDF certifcate log warning message and certificate status remains unchanged. """ download_url = 'http://www.example.com/certificate.pdf' # Create an existing verifed enrollment and certificate CourseEnrollmentFactory( user=self.user_2, course_id=self.course.id, is_active=True, mode=CourseMode.VERIFIED, ) GeneratedCertificateFactory(user=self.user_2, course_id=self.course.id, grade='1.0', status=CertificateStatuses.downloadable, mode=GeneratedCertificate.MODES.verified, download_url=download_url) self._assert_pdf_cert_generation_dicontinued_logs(download_url) def test_add_cert_with_existing_pdf_certificate(self): """ Test that add certifcate for existing PDF certificate log warning message and certificate status remains unchanged. """ download_url = 'http://www.example.com/certificate.pdf' # Create an existing verifed enrollment and certificate CourseEnrollmentFactory( user=self.user_2, course_id=self.course.id, is_active=True, mode=CourseMode.VERIFIED, ) GeneratedCertificateFactory(user=self.user_2, course_id=self.course.id, grade='1.0', status=CertificateStatuses.downloadable, mode=GeneratedCertificate.MODES.verified, download_url=download_url) self._assert_pdf_cert_generation_dicontinued_logs(download_url, add_cert=True) def _assert_pdf_cert_generation_dicontinued_logs(self, download_url, add_cert=False): """Assert PDF certificate generation discontinued logs.""" with LogCapture(LOGGER.name) as log: if add_cert: self.xqueue.add_cert(self.user_2, self.course.id) else: self.xqueue.regen_cert(self.user_2, self.course.id) log.check_present( (LOGGER.name, 'WARNING', (u"PDF certificate generation discontinued, canceling " u"PDF certificate generation for student {student_id} " u"in course '{course_id}' " u"with status '{status}' " u"and download_url '{download_url}'.").format( student_id=self.user_2.id, course_id=six.text_type(self.course.id), status=CertificateStatuses.downloadable, download_url=download_url)))
class XQueueCertInterfaceAddCertificateTest(ModuleStoreTestCase): """Test the "add to queue" operation of the XQueue interface. """ shard = 1 def setUp(self): super(XQueueCertInterfaceAddCertificateTest, self).setUp() self.user = UserFactory.create() self.course = CourseFactory.create() self.enrollment = CourseEnrollmentFactory( user=self.user, course_id=self.course.id, is_active=True, mode="honor", ) self.xqueue = XQueueCertInterface() self.user_2 = UserFactory.create() SoftwareSecurePhotoVerificationFactory.create(user=self.user_2, status='approved') def test_add_cert_callback_url(self): with mock_passing_grade(): with patch.object(XQueueInterface, 'send_to_queue') as mock_send: mock_send.return_value = (0, None) self.xqueue.add_cert(self.user, self.course.id) # Verify that the task was sent to the queue with the correct callback URL self.assertTrue(mock_send.called) __, kwargs = mock_send.call_args_list[0] actual_header = json.loads(kwargs['header']) self.assertIn('https://edx.org/update_certificate?key=', actual_header['lms_callback_url']) def test_no_create_action_in_queue_for_html_view_certs(self): """ Tests there is no certificate create message in the queue if generate_pdf is False """ with mock_passing_grade(): with patch.object(XQueueInterface, 'send_to_queue') as mock_send: self.xqueue.add_cert(self.user, self.course.id, generate_pdf=False) # Verify that add_cert method does not add message to queue self.assertFalse(mock_send.called) certificate = GeneratedCertificate.eligible_certificates.get(user=self.user, course_id=self.course.id) self.assertEqual(certificate.status, CertificateStatuses.downloadable) self.assertIsNotNone(certificate.verify_uuid) @ddt.data('honor', 'audit') @override_settings(AUDIT_CERT_CUTOFF_DATE=datetime.now(pytz.UTC) - timedelta(days=1)) def test_add_cert_with_honor_certificates(self, mode): """Test certificates generations for honor and audit modes.""" template_name = 'certificate-template-{id.org}-{id.course}.pdf'.format( id=self.course.id ) mock_send = self.add_cert_to_queue(mode) if CourseMode.is_eligible_for_certificate(mode): self.assert_certificate_generated(mock_send, mode, template_name) else: self.assert_ineligible_certificate_generated(mock_send, mode) @ddt.data('credit', 'verified') def test_add_cert_with_verified_certificates(self, mode): """Test if enrollment mode is verified or credit along with valid software-secure verification than verified certificate should be generated. """ template_name = 'certificate-template-{id.org}-{id.course}-verified.pdf'.format( id=self.course.id ) mock_send = self.add_cert_to_queue(mode) self.assert_certificate_generated(mock_send, 'verified', template_name) def test_ineligible_cert_whitelisted(self): """Test that audit mode students can receive a certificate if they are whitelisted.""" # Enroll as audit CourseEnrollmentFactory( user=self.user_2, course_id=self.course.id, is_active=True, mode='audit' ) # Whitelist student CertificateWhitelistFactory(course_id=self.course.id, user=self.user_2) # Generate certs with mock_passing_grade(): with patch.object(XQueueInterface, 'send_to_queue') as mock_send: mock_send.return_value = (0, None) self.xqueue.add_cert(self.user_2, self.course.id) # Assert cert generated correctly self.assertTrue(mock_send.called) certificate = GeneratedCertificate.certificate_for_student(self.user_2, self.course.id) self.assertIsNotNone(certificate) self.assertEqual(certificate.mode, 'audit') def add_cert_to_queue(self, mode): """ Dry method for course enrollment and adding request to queue. Returns a mock object containing information about the `XQueueInterface.send_to_queue` method, which can be used in other assertions. """ CourseEnrollmentFactory( user=self.user_2, course_id=self.course.id, is_active=True, mode=mode, ) with mock_passing_grade(): with patch.object(XQueueInterface, 'send_to_queue') as mock_send: mock_send.return_value = (0, None) self.xqueue.add_cert(self.user_2, self.course.id) return mock_send def assert_certificate_generated(self, mock_send, expected_mode, expected_template_name): """ Assert that a certificate was generated with the correct mode and template type. """ # Verify that the task was sent to the queue with the correct callback URL self.assertTrue(mock_send.called) __, kwargs = mock_send.call_args_list[0] actual_header = json.loads(kwargs['header']) self.assertIn('https://edx.org/update_certificate?key=', actual_header['lms_callback_url']) body = json.loads(kwargs['body']) self.assertIn(expected_template_name, body['template_pdf']) certificate = GeneratedCertificate.eligible_certificates.get(user=self.user_2, course_id=self.course.id) self.assertEqual(certificate.mode, expected_mode) def assert_ineligible_certificate_generated(self, mock_send, expected_mode): """ Assert that an ineligible certificate was generated with the correct mode. """ # Ensure the certificate was not generated self.assertFalse(mock_send.called) certificate = GeneratedCertificate.objects.get( user=self.user_2, course_id=self.course.id ) self.assertIn(certificate.status, (CertificateStatuses.audit_passing, CertificateStatuses.audit_notpassing)) self.assertEqual(certificate.mode, expected_mode) @ddt.data( (CertificateStatuses.restricted, False), (CertificateStatuses.deleting, False), (CertificateStatuses.generating, True), (CertificateStatuses.unavailable, True), (CertificateStatuses.deleted, True), (CertificateStatuses.error, True), (CertificateStatuses.notpassing, True), (CertificateStatuses.downloadable, True), (CertificateStatuses.auditing, True), ) @ddt.unpack def test_add_cert_statuses(self, status, should_generate): """ Test that certificates can or cannot be generated with the given certificate status. """ with patch( 'lms.djangoapps.certificates.queue.certificate_status_for_student', Mock(return_value={'status': status}) ): mock_send = self.add_cert_to_queue('verified') if should_generate: self.assertTrue(mock_send.called) else: self.assertFalse(mock_send.called) @ddt.data( # Eligible and should stay that way ( CertificateStatuses.downloadable, timedelta(days=-2), 'Pass', CertificateStatuses.generating ), # Ensure that certs in the wrong state can be fixed by regeneration ( CertificateStatuses.downloadable, timedelta(hours=-1), 'Pass', CertificateStatuses.audit_passing ), # Ineligible and should stay that way ( CertificateStatuses.audit_passing, timedelta(hours=-1), 'Pass', CertificateStatuses.audit_passing ), # As above ( CertificateStatuses.audit_notpassing, timedelta(hours=-1), 'Pass', CertificateStatuses.audit_passing ), # As above ( CertificateStatuses.audit_notpassing, timedelta(hours=-1), None, CertificateStatuses.audit_notpassing ), ) @ddt.unpack @override_settings(AUDIT_CERT_CUTOFF_DATE=datetime.now(pytz.UTC) - timedelta(days=1)) def test_regen_audit_certs_eligibility(self, status, created_delta, grade, expected_status): """ Test that existing audit certificates remain eligible even if cert generation is re-run. """ # Create an existing audit enrollment and certificate CourseEnrollmentFactory( user=self.user_2, course_id=self.course.id, is_active=True, mode=CourseMode.AUDIT, ) created_date = datetime.now(pytz.UTC) + created_delta with freezegun.freeze_time(created_date): GeneratedCertificateFactory( user=self.user_2, course_id=self.course.id, grade='1.0', status=status, mode=GeneratedCertificate.MODES.audit, ) # Run grading/cert generation again with mock_passing_grade(letter_grade=grade): with patch.object(XQueueInterface, 'send_to_queue') as mock_send: mock_send.return_value = (0, None) self.xqueue.add_cert(self.user_2, self.course.id) self.assertEqual( GeneratedCertificate.objects.get(user=self.user_2, course_id=self.course.id).status, expected_status )