def test_without_cert(self): with override_waffle_switch(AUTO_CERTIFICATE_GENERATION, active=True): with mock.patch( 'lms.djangoapps.certificates.signals.generate_certificate_task', return_value=None) as mock_cert_task: grade_factory = CourseGradeFactory() with mock_passing_grade(): grade_factory.update(self.user, self.course) mock_cert_task.assert_called_with(self.user, self.course_key)
def test_cert_already_generated(self): with mock.patch( 'lms.djangoapps.certificates.signals.generate_certificate.apply_async', return_value=None) as mock_generate_certificate_apply_async: grade_factory = CourseGradeFactory() # Create the certificate GeneratedCertificateFactory( user=self.user, course_id=self.course.id, status=CertificateStatuses.downloadable) # Certs are not re-fired after passing with mock_passing_grade(): grade_factory.update(self.user, self.course) mock_generate_certificate_apply_async.assert_not_called()
def test_cert_already_generated_unverified(self): with override_waffle_switch(AUTO_CERTIFICATE_GENERATION, active=True): GeneratedCertificateFactory(user=self.user, course_id=self.course.id, status=CertificateStatuses.unverified) with mock.patch( 'lms.djangoapps.certificates.signals.generate_certificate_task', return_value=None) as mock_cert_task: grade_factory = CourseGradeFactory() with mock_passing_grade(): grade_factory.update(self.user, self.course) mock_cert_task.assert_called_with(self.user, self.course_key)
def test_cert_already_generated(self): with mock.patch( 'lms.djangoapps.certificates.signals.generate_certificate.apply_async', return_value=None ) as mock_generate_certificate_apply_async: grade_factory = CourseGradeFactory() # Create the certificate GeneratedCertificate.eligible_certificates.create( user=self.user, course_id=self.course.id, status=CertificateStatuses.downloadable ) # Certs are not re-fired after passing with mock_passing_grade(): grade_factory.update(self.user, self.course) mock_generate_certificate_apply_async.assert_not_called()
def test_cert_generation_on_passing_instructor_paced(self): with mock.patch( 'lms.djangoapps.certificates.signals.generate_certificate.apply_async', return_value=None) as mock_generate_certificate_apply_async: with override_waffle_switch(AUTO_CERTIFICATE_GENERATION_SWITCH, active=True): grade_factory = CourseGradeFactory() # Not passing grade_factory.update(self.user, self.ip_course) mock_generate_certificate_apply_async.assert_not_called() # Certs fired after passing with mock_passing_grade(): grade_factory.update(self.user, self.ip_course) mock_generate_certificate_apply_async.assert_called_with( countdown=CERTIFICATE_DELAY_SECONDS, kwargs={ 'student': six.text_type(self.user.id), 'course_key': six.text_type(self.ip_course.id), })
def test_cert_generation_on_passing_instructor_paced(self): with mock.patch( 'lms.djangoapps.certificates.signals.generate_certificate.apply_async', return_value=None ) as mock_generate_certificate_apply_async: with waffle.waffle().override(waffle.AUTO_CERTIFICATE_GENERATION, active=True): grade_factory = CourseGradeFactory() # Not passing grade_factory.update(self.user, self.ip_course) mock_generate_certificate_apply_async.assert_not_called() # Certs fired after passing with mock_passing_grade(): grade_factory.update(self.user, self.ip_course) mock_generate_certificate_apply_async.assert_called_with( countdown=CERTIFICATE_DELAY_SECONDS, kwargs={ 'student': unicode(self.user.id), 'course_key': unicode(self.ip_course.id), } )
def setUp(self): super(LearnerTrackChangeCertsTest, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments self.course_one = CourseFactory.create(self_paced=True) self.user_one = UserFactory.create() self.enrollment_one = CourseEnrollmentFactory( user=self.user_one, course_id=self.course_one.id, is_active=True, mode='verified', ) self.user_two = UserFactory.create() self.course_two = CourseFactory.create(self_paced=False) self.enrollment_two = CourseEnrollmentFactory( user=self.user_two, course_id=self.course_two.id, is_active=True, mode='verified') with mock_passing_grade(): grade_factory = CourseGradeFactory() grade_factory.update(self.user_one, self.course_one) grade_factory.update(self.user_two, self.course_two)
def setUp(self): super().setUp() self.course_one = CourseFactory.create(self_paced=True) self.user_one = UserFactory.create() self.enrollment_one = CourseEnrollmentFactory( user=self.user_one, course_id=self.course_one.id, is_active=True, mode='verified', ) self.user_two = UserFactory.create() self.course_two = CourseFactory.create(self_paced=False) self.enrollment_two = CourseEnrollmentFactory( user=self.user_two, course_id=self.course_two.id, is_active=True, mode='verified') with mock_passing_grade(): grade_factory = CourseGradeFactory() grade_factory.update(self.user_one, self.course_one) grade_factory.update(self.user_two, self.course_two)
def setUp(self): super(LearnerTrackChangeCertsTest, self).setUp() self.course_one = CourseFactory.create(self_paced=True) self.user_one = UserFactory.create() self.enrollment_one = CourseEnrollmentFactory( user=self.user_one, course_id=self.course_one.id, is_active=True, mode='verified', ) self.user_two = UserFactory.create() self.course_two = CourseFactory.create(self_paced=False) self.enrollment_two = CourseEnrollmentFactory( user=self.user_two, course_id=self.course_two.id, is_active=True, mode='verified' ) with mock_passing_grade(): grade_factory = CourseGradeFactory() grade_factory.update(self.user_one, self.course_one) grade_factory.update(self.user_two, self.course_two)
class TestGradeUcursosView(GradeTestBase): def setUp(self): super(TestGradeUcursosView, self).setUp() self.grade_factory = CourseGradeFactory() with patch('student.models.cc.User.save'): # staff user self.client_instructor = Client() self.client_student = Client() self.client_anonymous = Client() self.user_instructor = UserFactory( username='******', password='******', email='*****@*****.**', is_staff=True) role = CourseInstructorRole(self.course.id) role.add_users(self.user_instructor) self.client_instructor.login( username='******', password='******') self.student = UserFactory( username='******', password='******', email='*****@*****.**') self.student_2 = UserFactory( username='******', password='******', email='*****@*****.**') # Enroll the student in the course CourseEnrollmentFactory( user=self.student, course_id=self.course.id, mode='honor') CourseEnrollmentFactory( user=self.student_2, course_id=self.course.id, mode='honor') self.client_student.login( username='******', password='******') # Create and Enroll data researcher user self.data_researcher_user = UserFactory( username='******', password='******', email='*****@*****.**') CourseEnrollmentFactory( user=self.data_researcher_user, course_id=self.course.id, mode='audit') CourseAccessRoleFactory( course_id=self.course.id, user=self.data_researcher_user, role='data_researcher', org=self.course.id.org ) self.client_data_researcher = Client() self.assertTrue(self.client_data_researcher.login(username='******', password='******')) def test_get_user_grade(self): """ Verify method get_user_grade() work correctly """ with mock_get_score(1, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(1, 4): percent = GradeUcursosView().get_user_grade(self.student, self.course.id, 'gradeucursos_total', False) self.assertEqual(percent, {'Prom':0.25}) def test_round_half_up(self): """ Verify method grade_percent_scaled() work correctly """ grades = [1,1.1,1.1,1.2,1.2,1.3,1.3,1.4,1.4,1.5,1.5,1.6,1.6,1.7,1.7,1.8,1.8,1.9,1.9,2,2,2.1,2.1,2.2,2.2,2.3,2.3,2.4,2.4,2.5,2.5,2.6,2.6,2.7,2.7,2.8,2.8,2.9,2.9,3,3,3.1,3.1,3.2,3.2,3.3,3.3,3.4,3.4,3.5,3.5,3.6,3.6,3.7,3.7,3.8,3.8,3.9,3.9,4,4,4.1,4.2,4.2,4.3,4.4,4.5,4.5,4.6,4.7,4.8,4.8,4.9,5,5.1,5.1,5.2,5.3,5.4,5.4,5.5,5.6,5.7,5.7,5.8,5.9,6,6,6.1,6.2,6.3,6.3,6.4,6.5,6.6,6.6,6.7,6.8,6.9,6.9,7] for i in range(101): self.assertEqual(GradeUcursosView().grade_percent_scaled(i/100,0.6), grades[i]) def test_grade_percent_ucursos_scaled(self): """ Verify method grade_percent_ucursos_scaled() work correctly """ for i in range(101): grade_percent = i/100 grade_percent_50 = GradeUcursosView().grade_percent_ucursos_scaled(grade_percent,0.6) grade_scaled_1 = GradeUcursosView().grade_percent_scaled(grade_percent,0.6) grade_scaled_2 = GradeUcursosView().grade_percent_scaled(grade_percent_50,0.5) self.assertEqual(grade_scaled_1,grade_scaled_2) for i in range(101): grade_percent = i/100 grade_percent_50 = GradeUcursosView().grade_percent_ucursos_scaled(grade_percent,0.7) grade_scaled_1 = GradeUcursosView().grade_percent_scaled(grade_percent,0.7) grade_scaled_2 = GradeUcursosView().grade_percent_scaled(grade_percent_50,0.5) self.assertEqual(grade_scaled_1,grade_scaled_2) def test_gradeucursos_get(self): """ Test gradeucursos view """ response = self.client_instructor.get(reverse('gradeucursos-export:data')) request = response.request self.assertEqual(response.status_code, 405) def test_gradeucursos_post(self): """ Test gradeucursos post normal process """ with mock_get_score(1, 2): self.grade_factory.update(self.student, self.course, force_update_subsections=True) self.grade_factory.update(self.student_2, self.course, force_update_subsections=True) try: from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='09472337K') except ImportError: self.skipTest("import error uchileedxlogin") post_data = { 'grade_type': 'seven_scale', 'curso': str(self.course.id), 'instructor_tab': 'false', 'assig_type': 'gradeucursos_total', 'is_resumen': 'false' } #grade cutoff 50% response = self.client_instructor.post(reverse('gradeucursos-export:data'), post_data) r = json.loads(response._container[0].decode()) self.assertEqual(response.status_code, 200) self.assertEqual(r['status'] , 'Generating') response2 = self.client_instructor.post(reverse('gradeucursos-export:data'), post_data) r2 = json.loads(response2._container[0].decode()) self.assertEqual(response2.status_code, 200) self.assertEqual(r2['status'] , 'Generated') report_grade, _ = GradeUcursosView().get_grade_report(post_data['curso'], post_data['grade_type'], 'gradeucursos_total', False) self.assertTrue(report_grade is not None) self.assertEqual(len(report_grade), 2) self.assertEqual(report_grade[0], ['9472337-K', self.student.username, '', {'Prom':4.0}]) obs = 'Usuario {} no tiene rut asociado en la plataforma.'.format(self.student_2.username) self.assertEqual(report_grade[1], ['', self.student_2.username, obs, {'Prom':4.0}]) def test_gradeucursos_post_data_researcher(self): """ Test gradeucursos post normal process with data researcher role """ with mock_get_score(1, 2): self.grade_factory.update(self.student, self.course, force_update_subsections=True) self.grade_factory.update(self.student_2, self.course, force_update_subsections=True) try: from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='09472337K') except ImportError: self.skipTest("import error uchileedxlogin") post_data = { 'grade_type': 'seven_scale', 'curso': str(self.course.id) } #grade cutoff 50% response = self.client_data_researcher.post(reverse('gradeucursos-export:data'), post_data) r = json.loads(response._container[0].decode()) self.assertEqual(response.status_code, 200) self.assertEqual(r['status'] , 'Generating') response2 = self.client_data_researcher.post(reverse('gradeucursos-export:data'), post_data) r2 = json.loads(response2._container[0].decode()) self.assertEqual(response2.status_code, 200) self.assertEqual(r2['status'] , 'Generated') report_grade, _ = GradeUcursosView().get_grade_report(post_data['curso'], post_data['grade_type'], 'gradeucursos_total', False) self.assertTrue(report_grade is not None) self.assertEqual(len(report_grade), 2) self.assertEqual(report_grade[0], ['9472337-K', self.student.username, '', {'Prom':4.0}]) obs = 'Usuario {} no tiene rut asociado en la plataforma.'.format(self.student_2.username) self.assertEqual(report_grade[1], ['', self.student_2.username, obs, {'Prom':4.0}]) def test_gradeucursos_post_from_instructor_tab(self): """ Test gradeucursos post from instructor tab normal process """ try: from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='09472337K') except ImportError: self.skipTest("import error uchileedxlogin") task_input = { 'grade_type': 'seven_scale', 'course_id': str(self.course.id), 'instructor_tab': True, 'assig_type': 'gradeucursos_total', 'is_resumen': False } with patch('lms.djangoapps.instructor_task.tasks_helper.runner._get_current_task'): result = task_get_data( None, None, self.course.id, task_input, 'EOL_GRADE_UCURSOS' ) report_store = ReportStore.from_config(config_name='GRADES_DOWNLOAD') report_csv_filename = report_store.links_for(self.course.id)[0][0] report_path = report_store.path_to(self.course.id, report_csv_filename) self.assertTrue('_notas_estudiantes_' in report_csv_filename) self.assertTrue('_notas_estudiantes_' in report_path) def test_gradeucursos_post_from_instructor_tab_assig_type(self): """ Test gradeucursos post from instructor tab normal process with assignament """ self.skipTest("disabled temporarily") try: from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='09472337K') except ImportError: self.skipTest("import error uchileedxlogin") task_input = { 'grade_type': 'seven_scale', 'course_id': str(self.course.id), 'instructor_tab': True, 'assig_type': 'Homework', 'is_resumen': False } with patch('lms.djangoapps.instructor_task.tasks_helper.runner._get_current_task'): result = task_get_data( None, None, self.course.id, task_input, 'EOL_GRADE_UCURSOS' ) report_store = ReportStore.from_config(config_name='GRADES_DOWNLOAD') report_csv_filename = report_store.links_for(self.course.id)[0][0] report_path = report_store.path_to(self.course.id, report_csv_filename) self.assertTrue('_notas_estudiantes_' in report_csv_filename) self.assertTrue('_notas_estudiantes_' in report_path) def test_gradeucursos_post_from_instructor_tab_assig_type_data(self): """ Test gradeucursos post from instructor tab normal process with assignament """ try: from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='09472337K') except ImportError: self.skipTest("import error uchileedxlogin") post_data = { 'grade_type': 'seven_scale', 'curso': str(self.course.id), 'instructor_tab': 'true', 'assig_type': 'gradeucursos_total', 'is_resumen': 'false' } #grade cutoff 50% report_grade, _ = GradeUcursosView().get_grade_report(post_data['curso'], post_data['grade_type'], 'gradeucursos_total', False) self.assertTrue(report_grade is not None) self.assertEqual(len(report_grade), 2) self.assertEqual(report_grade[0], ['9472337-K', self.student.username, '', {'Prom':1.0}]) obs = 'Usuario {} no tiene rut asociado en la plataforma.'.format(self.student_2.username) self.assertEqual(report_grade[1], ['', self.student_2.username, obs, {'Prom':1.0}]) def test_gradeucursos_post_from_instructor_tab_is_resumen(self): """ Test gradeucursos post from instructor tab normal process with is_resumen params """ self.skipTest("disabled temporarily") with mock_get_score(1, 2): self.grade_factory.update(self.student, self.course, force_update_subsections=True) self.grade_factory.update(self.student_2, self.course, force_update_subsections=True) try: from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='09472337K') except ImportError: self.skipTest("import error uchileedxlogin") task_input = { 'grade_type': 'seven_scale', 'course_id': str(self.course.id), 'instructor_tab': True, 'assig_type': 'Homework', 'is_resumen': True } with patch('lms.djangoapps.instructor_task.tasks_helper.runner._get_current_task'): result = task_get_data( None, None, self.course.id, task_input, 'EOL_GRADE_UCURSOS' ) report_store = ReportStore.from_config(config_name='GRADES_DOWNLOAD') report_csv_filename = report_store.links_for(self.course.id)[0][0] report_path = report_store.path_to(self.course.id, report_csv_filename) self.assertTrue('_notas_estudiantes_' in report_csv_filename) self.assertTrue('_notas_estudiantes_' in report_path) def test_gradeucursos_post_from_instructor_tab_is_resumen_data(self): """ Test gradeucursos post from instructor tab normal process with is_resumen params """ with mock_get_score(1, 2): self.grade_factory.update(self.student, self.course, force_update_subsections=True) self.grade_factory.update(self.student_2, self.course, force_update_subsections=True) try: from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='09472337K') except ImportError: self.skipTest("import error uchileedxlogin") post_data = { 'grade_type': 'seven_scale', 'curso': str(self.course.id) } #grade cutoff 50% report_grade, headers = GradeUcursosView().get_grade_report(post_data['curso'], post_data['grade_type'], 'gradeucursos_total', True) self.assertTrue(report_grade is not None) self.assertEqual(len(report_grade), 2) result = OrderedDict([('Homework', 50.0), ('NoCredit', 0.0), ('Prom', 4.0)]) self.assertEqual(report_grade[0], ['9472337-K', self.student.username, '', result]) obs = 'Usuario {} no tiene rut asociado en la plataforma.'.format(self.student_2.username) self.assertEqual(report_grade[1], ['', self.student_2.username, obs, result]) def test_gradeucursos_post_from_instructor_tab_wrong_assig_type(self): """ Test gradeucursos post from instructor tab wrong assignament type """ self.skipTest("disabled temporarily") try: from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='09472337K') except ImportError: self.skipTest("import error uchileedxlogin") post_data = { 'grade_type': 'seven_scale', 'curso': str(self.course.id), 'instructor_tab': 'true', 'assig_type': 'asdasdsads', 'is_resumen': 'false' } response = self.client_data_researcher.post(reverse('gradeucursos-export:data'), post_data) r = json.loads(response._container[0].decode()) self.assertEqual(response.status_code, 200) self.assertEqual(r['status'] , 'Error') self.assertTrue(r['error_assig_type']) def test_gradeucursos_post_not_logged(self): """ Test gradeucursos get when user is not logged """ response = self.client_anonymous.post(reverse('gradeucursos-export:data')) self.assertEqual(response.status_code, 404) def test_gradeucursos_post_course_no_exists(self): """ Test gradeucursos post when course_id no exists """ post_data = { 'grade_type': 'seven_scale', 'curso': 'course-v1:eol+test+2021' } #grade cutoff 50% response = self.client_instructor.post(reverse('gradeucursos-export:data'), post_data) self.assertEqual(response.status_code, 200) r = json.loads(response._container[0].decode()) self.assertTrue(r['error_curso']) def test_gradeucursos_post_wrong_course_id(self): """ Test gradeucursos post when course_id is not CourseKey """ post_data = { 'grade_type': 'seven_scale', 'curso': 'asdasd' } #grade cutoff 50% response = self.client_instructor.post(reverse('gradeucursos-export:data'), post_data) self.assertEqual(response.status_code, 200) r = json.loads(response._container[0].decode()) self.assertTrue(r['error_curso']) def test_gradeucursos_post_empty_course_id(self): """ Test gradeucursos post when course_id is empty """ post_data = { 'grade_type': 'seven_scale', 'curso': '' } #grade cutoff 50% response = self.client_instructor.post(reverse('gradeucursos-export:data'), post_data) self.assertEqual(response.status_code, 200) r = json.loads(response._container[0].decode()) self.assertTrue(r['empty_course']) def test_gradeucursos_post_wrong_scale_grade(self): """ Test gradeucursos post when dont exists grade_type in GRADE_TYPE_LIST """ post_data = { 'grade_type': 'wrong_scale', 'curso': str(self.course.id) } #grade cutoff 50% response = self.client_instructor.post(reverse('gradeucursos-export:data'), post_data) self.assertEqual(response.status_code, 200) r = json.loads(response._container[0].decode()) self.assertTrue(r['error_grade_type']) def test_gradeucursos_post_wrong_is_resumen(self): """ Test gradeucursos post when is_resumen is not boolean type """ self.skipTest("disabled temporarily") post_data = { 'grade_type': 'wrong_scale', 'curso': str(self.course.id), 'is_resumen': 'hello world!' } #grade cutoff 50% response = self.client_instructor.post(reverse('gradeucursos-export:data'), post_data) self.assertEqual(response.status_code, 200) r = json.loads(response._container[0].decode()) self.assertTrue(r['error_is_resumen']) def test_gradeucursos_post_user_dont_have_permission(self): """ Test gradeucursos post when user dont have permission to export """ post_data = { 'grade_type': 'seven_scale', 'curso': str(self.course.id) } #grade cutoff 50% response = self.client_student.post(reverse('gradeucursos-export:data'), post_data) self.assertEqual(response.status_code, 200) r = json.loads(response._container[0].decode()) self.assertTrue(r['user_permission']) @patch('gradeucursos.views.GradeUcursosView.get_grade_cutoff') def test_gradeucursos_post_grade_cutoff_not_defined(self, grade): """ Test gradeucursos post when grade cutoff is not defined """ grade.return_value = None post_data = { 'grade_type': 'seven_scale', 'curso': str(self.course.id) } response = self.client_instructor.post(reverse('gradeucursos-export:data'), post_data) self.assertEqual(response.status_code, 200) r = json.loads(response._container[0].decode()) self.assertTrue(r['error_grade_cutoff']) def test_gradeucursos_post_uchileedxlogin_not_installed(self): """ Test gradeucursos post when uchileedxlogin is not installed """ post_data = { 'grade_type': 'seven_scale', 'curso': str(self.course.id) } try: from uchileedxlogin.models import EdxLoginUser self.skipTest("this test check if validate_data function verify EdxLoginUser model") except ImportError: response = self.client_instructor.post(reverse('gradeucursos-export:data'), post_data) self.assertEqual(response.status_code, 200) r = json.loads(response._container[0].decode()) self.assertTrue(r['error_model']) @patch('gradeucursos.views.GradeUcursosView.get_grade_cutoff') def test_gradeucurso_post_grade_cutoff_not_defined_in_report(self, grade): """ Test gradeucursos post when grade cutoff is not defined """ grade.side_effect = [0.5, None, 0.5] try: from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='09472337K') except ImportError: self.skipTest("import error uchileedxlogin") post_data = { 'grade_type': 'seven_scale', 'curso': str(self.course.id), 'instructor_tab': 'false', 'assig_type': 'gradeucursos_total', 'is_resumen': 'false' } #grade cutoff 50% response = self.client_instructor.post(reverse('gradeucursos-export:data'), post_data) response_export = self.client_instructor.post(reverse('gradeucursos-export:data'), post_data) r = json.loads(response._container[0].decode()) self.assertEqual(response.status_code, 200) self.assertEqual(r['status'] , 'Generating') r2 = json.loads(response_export._container[0].decode()) self.assertTrue(r2['report_error']) @patch('gradeucursos.views.GradeUcursosView.get_grade_cutoff') def test_gradeucursos_post_from_instructor_tab_grade_cutoff_not_defined_in_report(self, grade): """ Test gradeucursos post from instructor tab when grade cutoff is not defined """ grade.return_value = None try: from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='09472337K') except ImportError: self.skipTest("import error uchileedxlogin") task_input = { 'grade_type': 'seven_scale', 'course_id': str(self.course.id), 'instructor_tab': True, 'assig_type': 'gradeucursos_total', 'is_resumen': False } with patch('lms.djangoapps.instructor_task.tasks_helper.runner._get_current_task'): result = task_get_data( None, None, self.course.id, task_input, 'EOL_GRADE_UCURSOS' ) report_store = ReportStore.from_config(config_name='GRADES_DOWNLOAD') report_csv_filename = report_store.links_for(self.course.id)[0][0] report_path = report_store.path_to(self.course.id, report_csv_filename) self.assertTrue('_Error_notas_estudiantes_' in report_csv_filename) self.assertTrue('_Error_notas_estudiantes_' in report_path)
class TestCorfoGenerateView(GradeTestBase): def setUp(self): super(TestCorfoGenerateView, self).setUp() self.grade_factory = CourseGradeFactory() CorfoCodeMappingContent.objects.create(id_content=200, content='testtest') with patch('common.djangoapps.student.models.cc.User.save'): # staff user self.client = Client() user = UserFactory( username='******', password='******', email='*****@*****.**', is_staff=True) self.client.login(username='******', password='******') CourseEnrollmentFactory( user=user, course_id=self.course.id) # user no enrolled self.user_unenroll = UserFactory( username='******', password='******', email='*****@*****.**', is_staff=True) self.client_unenroll = Client() self.client_unenroll.login(username='******', password='******') # user student self.student_client = Client() self.student = UserFactory( username='******', password='******', email='*****@*****.**') CourseEnrollmentFactory( user=self.student, course_id=self.course.id) self.assertTrue( self.student_client.login( username='******', password='******')) def test_user_course_passed(self): """ Verify method user_course_passed() work correctly """ with mock_get_score(1, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(1, 4): passed, percent = user_course_passed(self.student, self.course.id) self.assertEqual(percent, 0.25) self.assertFalse(passed) def test_round_half_up(self): """ Verify method grade_percent_scaled() work correctly """ grades = [1,1.1,1.1,1.2,1.2,1.3,1.3,1.4,1.4,1.5,1.5,1.6,1.6,1.7,1.7,1.8,1.8,1.9,1.9,2,2,2.1,2.1,2.2,2.2,2.3,2.3,2.4,2.4,2.5,2.5,2.6,2.6,2.7,2.7,2.8,2.8,2.9,2.9,3,3,3.1,3.1,3.2,3.2,3.3,3.3,3.4,3.4,3.5,3.5,3.6,3.6,3.7,3.7,3.8,3.8,3.9,3.9,4,4,4.1,4.2,4.2,4.3,4.4,4.5,4.5,4.6,4.7,4.8,4.8,4.9,5,5.1,5.1,5.2,5.3,5.4,5.4,5.5,5.6,5.7,5.7,5.8,5.9,6,6,6.1,6.2,6.3,6.3,6.4,6.5,6.6,6.6,6.7,6.8,6.9,6.9,7] for i in range(101): self.assertEqual(grade_percent_scaled(i/100,0.6), grades[i]) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") def test_generate_code_request(self): """ test views.generate_code(request) without user data """ data = generate_code(self.student, str(self.course.id), 3093, 200) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 0) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") def test_generate_code_request_user_with_code(self): """ test views.generate_code(request) when user already have code """ id_content = 200 mapp_content = CorfoCodeMappingContent.objects.get(id_content=id_content) corfouser = CorfoCodeUser.objects.create(user=self.student, mapping_content=mapp_content, code='U1CODASDFGH', corfo_save=True) with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'success') self.assertEqual(data['code'], corfouser.code) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_generate_code_request_fail_token(self, post): """ test views.generate_code(request) when get toket failed """ id_content = 200 post.side_effect = [namedtuple("Request", ["status_code"])(400)] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 1) mapp_content = CorfoCodeMappingContent.objects.get(id_content=id_content) corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content=mapp_content) self.assertFalse(corfouser.corfo_save) self.assertTrue(corfouser.code != '') @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_generate_code_request_user_no_rut(self, post): """ test views.generate_code(request) when user dont have edxloginuser.rut """ id_content = 200 resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data)] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 2) mapp_content = CorfoCodeMappingContent.objects.get(id_content=id_content) corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content=mapp_content) self.assertFalse(corfouser.corfo_save) self.assertTrue(corfouser.code != '') @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_generate_code_request_user_no_passport(self, post): """ test views.generate_code(request) when user dont have rut or passport """ try: from unittest.case import SkipTest from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='CA09472337K') except ImportError: self.skipTest("import error uchileedxlogin") id_content = 200 resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data)] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 2) mapp_content = CorfoCodeMappingContent.objects.get(id_content=id_content) corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content=mapp_content) self.assertFalse(corfouser.corfo_save) self.assertTrue(corfouser.code != '') @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_generate_code_request_user_wrong_rut(self, post): """ test views.generate_code(request) when user have wrong edxloginuser.rut """ try: from unittest.case import SkipTest from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='0947P2337K') except ImportError: self.skipTest("import error uchileedxlogin") id_content = 200 resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data), namedtuple("Request", ["status_code", "json"])] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 2) mapp_content = CorfoCodeMappingContent.objects.get(id_content=id_content) corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content=mapp_content) self.assertFalse(corfouser.corfo_save) self.assertTrue(corfouser.code != '') @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_generate_code_request_validate_fail(self, post): """ test views.generate_code(request) when post validate failed """ try: from unittest.case import SkipTest from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='009472337K') except ImportError: self.skipTest("import error uchileedxlogin") id_content = 200 post_data = { 'Data': 0, 'Message': None, 'Status': 0, 'Success': True } resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data), namedtuple("Request", ["status_code", "json", 'text'])(400, lambda:post_data,'error')] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 3) mapp_content = CorfoCodeMappingContent.objects.get(id_content=id_content) corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content=mapp_content) self.assertFalse(corfouser.corfo_save) self.assertTrue(corfouser.code != '') @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_generate_code_request_validate_wrong_data(self, post): """ test views.generate_code(request) when post validate with wrong data """ try: from unittest.case import SkipTest from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='009472337K') except ImportError: self.skipTest("import error uchileedxlogin") id_content = 200 post_data = { 'Data': None, 'Message': 'asdfgh', 'Status': -4, 'Success': False } resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data), namedtuple("Request", ["status_code", "json", 'text'])(200, lambda:post_data, 'error')] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 4) mapp_content = CorfoCodeMappingContent.objects.get(id_content=id_content) corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content=mapp_content) self.assertFalse(corfouser.corfo_save) self.assertTrue(corfouser.code != '') @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") def test_generate_code_request_wrong_course(self): """ test views.generate_code(request) wrong course """ id_content = 200 data = generate_code(self.student, 'asd', 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 5) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") def test_generate_code_request_wrong_id_institution(self): """ test views.generate_code(request) wrong id_institution """ id_content = 200 data = generate_code(self.student, str(self.course.id), 3090, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 5) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") def test_generate_code_request_wrong_id_institution_string(self): """ test views.generate_code(request) wrong id_institution """ id_content = 200 data = generate_code(self.student, str(self.course.id), 'asd', id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 5) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") def test_generate_code_request_no_id_content(self): """ test views.generate_code(request) without id_content """ id_content = '' data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 5) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") def test_generate_code_request_no_mapping(self): """ test views.generate_code(request) when CorfoCodeMappingContent.DoesNotExist """ id_content = 404 data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 5) @override_settings(CORFOGENERATE_URL_TOKEN="") @override_settings(CORFOGENERATE_CLIENT_ID="") @override_settings(CORFOGENERATE_CLIENT_SECRET="") @override_settings(CORFOGENERATE_URL_VALIDATE="") def test_generate_code_request_no_settings(self): """ test views.generate_code(request) when settings no configurate """ id_content = 200 data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 5) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch("corfogeneratecode.views.user_course_passed") def test_generate_code_request_passed_none(self, passed): """ test views.generate_code(request) when get user_course_passed failed """ passed.return_value = None, None id_content = 200 data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 6) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch("corfogeneratecode.views.get_grade_cutoff") @patch('requests.post') def test_generate_code_request_grade_cutoff_none(self, post, grade_cutoff): """ test views.generate_code(request) when get_grade_cutoff failed """ try: from unittest.case import SkipTest from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='009472337K') except ImportError: self.skipTest("import error uchileedxlogin") grade_cutoff.return_value = None id_content = 200 resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data)] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 7) mapp_content = CorfoCodeMappingContent.objects.get(id_content=id_content) corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content=mapp_content) self.assertFalse(corfouser.corfo_save) self.assertTrue(corfouser.code != '') @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_generate_code_success(self, post): """ test views.generate_code(request) success process """ CorfoCodeInstitution.objects.create(id_institution=3094) try: from unittest.case import SkipTest from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='009472337K') except ImportError: self.skipTest("import error uchileedxlogin") id_content = 200 post_data = { 'Data': 0, 'Message': None, 'Status': 0, 'Success': True } resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data) ,namedtuple("Request", ["status_code", "json"])(200, lambda:post_data)] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'success') corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content__id_content=id_content) self.assertEqual(data['code'], corfouser.code) self.assertTrue(corfouser.corfo_save) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_generate_code_success_with_passport(self, post): """ test views.generate_code(request) success process """ CorfoCodeInstitution.objects.create(id_institution=3094) try: from unittest.case import SkipTest from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='P09472337K') except ImportError: self.skipTest("import error uchileedxlogin") id_content = 200 post_data = { 'Data': 0, 'Message': None, 'Status': 0, 'Success': True } resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data) ,namedtuple("Request", ["status_code", "json"])(200, lambda:post_data)] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'success') corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content__id_content=id_content) self.assertEqual(data['code'], corfouser.code) self.assertTrue(corfouser.corfo_save) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_generate_code_request_validate_no_id_institution(self, post): """ test views.generate_code(request) when post validate without id_institution """ try: from unittest.case import SkipTest from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='009472337K') except ImportError: self.skipTest("import error uchileedxlogin") id_content = 200 post_data = {"Message":"An error has occurred."} resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data), namedtuple("Request", ["status_code", "json"])(200, lambda:post_data)] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): data = generate_code(self.student, str(self.course.id), 3093, id_content) self.assertEqual(data['result'], 'error') self.assertEqual(data['status'], 3) mapp_content = CorfoCodeMappingContent.objects.get(id_content=id_content) corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content=mapp_content) self.assertFalse(corfouser.corfo_save) self.assertTrue(corfouser.code != '')
class TestCorfoGenerateXBlock(GradeTestBase): def make_an_xblock(cls, **kw): """ Helper method that creates a CorfoGenerateXBlock """ course = cls.course runtime = Mock( course_id=course.id, user_is_staff=False, service=Mock( return_value=Mock(_catalog={}), ), ) scope_ids = Mock() field_data = DictFieldData(kw) xblock = CorfoGenerateXBlock(runtime, field_data, scope_ids) xblock.xmodule_runtime = runtime xblock.location = course.location xblock.course_id = course.id xblock.category = 'corfogeneratecode' return xblock def setUp(self): super(TestCorfoGenerateXBlock, self).setUp() CorfoCodeMappingContent.objects.create(id_content=200, content='testtest') self.grade_factory = CourseGradeFactory() self.xblock = self.make_an_xblock() with patch('common.djangoapps.student.models.cc.User.save'): # staff user self.client = Client() user = UserFactory( username='******', password='******', email='*****@*****.**', is_staff=True) self.client.login(username='******', password='******') CourseEnrollmentFactory( user=user, course_id=self.course.id) # user student self.student_client = Client() self.student = UserFactory( username='******', password='******', email='*****@*****.**') CourseEnrollmentFactory( user=self.student, course_id=self.course.id) self.assertTrue( self.student_client.login( username='******', password='******')) def test_user_course_passed(self): """ Verify method user_course_passed() work correctly """ with mock_get_score(1, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(1, 4): self.xblock.scope_ids.user_id = self.student.id passed = self.xblock.user_course_passed() self.assertFalse(passed) def test_validate_field_data(self): """ Verify if default xblock is created correctly """ self.assertEqual(self.xblock.display_name, 'Corfo Generate Code') self.assertEqual(self.xblock.display_title, '') self.assertEqual(self.xblock.id_content, 0) self.assertEqual(self.xblock.id_institution, 3093) self.assertEqual(self.xblock.content, '') def test_edit_block_studio(self): """ Verify submit studio edits is working """ request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = True data = json.dumps({'display_name': 'testname', "id_content": '200', "content": 'testtest', 'display_title': 'testtitle'}) request.body = data.encode() response = self.xblock.studio_submit(request) self.assertEqual(self.xblock.display_name, 'testname') self.assertEqual(self.xblock.display_title, 'testtitle') self.assertEqual(self.xblock.id_content, 200) self.assertEqual(self.xblock.id_institution, 3093) self.assertEqual(self.xblock.content, 'testtest') def test_edit_block_studio_2(self): """ Verify submit studio edits is working with CorfoCodeInstitution """ CorfoCodeInstitution.objects.create(id_institution=3090, institution='NVIDIA') request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = True data = json.dumps({'display_name': 'testname', "id_content": '200', 'id_institution': '3090', "content": 'testtest', 'display_title': 'testtitle'}) request.body = data.encode() response = self.xblock.studio_submit(request) self.assertEqual(self.xblock.display_name, 'testname') self.assertEqual(self.xblock.display_title, 'testtitle') self.assertEqual(self.xblock.id_content, 200) self.assertEqual(self.xblock.id_institution, 3090) self.assertEqual(self.xblock.content, 'testtest') def test_fail_edit_block_studio(self): """ Verify submit studio edits when CorfoCodeMappingContent.DoesNotExist """ request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = True data = json.dumps({'display_name': 'testname', "id_content": '202', "content": 'testtest', 'display_title': 'testtitle'}) request.body = data.encode() response = self.xblock.studio_submit(request) self.assertEqual(self.xblock.display_name, 'Corfo Generate Code') self.assertEqual(self.xblock.display_title, '') self.assertEqual(self.xblock.id_content, 0) self.assertEqual(self.xblock.content, '') self.assertEqual(self.xblock.id_institution, 3093) def test_fail_edit_block_studio_2(self): """ Verify submit studio edits when CorfoCodeInstitution.DoesNotExist """ request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = True data = json.dumps({'display_name': 'testname', "id_content": '200', 'id_institution': '3000', "content": 'testtest', 'display_title': 'testtitle'}) request.body = data.encode() response = self.xblock.studio_submit(request) self.assertEqual(self.xblock.display_name, 'Corfo Generate Code') self.assertEqual(self.xblock.display_title, '') self.assertEqual(self.xblock.id_content, 0) self.assertEqual(self.xblock.content, '') self.assertEqual(self.xblock.id_institution, 3093) def test_edit_block_studio_string_id_content(self): """ Verify submit studio edits when id_content is not a number(Integer) """ request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = True data = json.dumps({'display_name': 'testname', "id_content": 'aa', "content": 'testtest', 'display_title': 'testtitle'}) request.body = data.encode() response = self.xblock.studio_submit(request) self.assertEqual(self.xblock.display_name, 'Corfo Generate Code') self.assertEqual(self.xblock.display_title, '') self.assertEqual(self.xblock.id_content, 0) self.assertEqual(self.xblock.content, '') self.assertEqual(self.xblock.id_institution, 3093) def test_edit_block_studio_string_id_institution(self): """ Verify submit studio edits when id_institution is not a number(Integer) """ request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = True data = json.dumps({'display_name': 'testname', "id_content": '200', 'id_institution': 'asd', "content": 'testtest', 'display_title': 'testtitle'}) request.body = data.encode() response = self.xblock.studio_submit(request) self.assertEqual(self.xblock.display_name, 'Corfo Generate Code') self.assertEqual(self.xblock.display_title, '') self.assertEqual(self.xblock.id_content, 0) self.assertEqual(self.xblock.content, '') self.assertEqual(self.xblock.id_institution, 3093) def test_student_view(self): """ Verify context in student_view """ self.xblock.scope_ids.user_id = self.student.id response = self.xblock.get_context() self.assertEqual(response['passed'], False) self.assertEqual(response['code'], '') self.assertEqual(response['corfo_save'], False) def test_student_view_user_not_passed_course(self): """ Verify context in student_view when user has not passed the course """ with mock_get_score(1, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(1, 4): self.xblock.scope_ids.user_id = self.student.id response = self.xblock.get_context() self.assertEqual(response['passed'], False) self.assertEqual(response['code'], '') self.assertEqual(response['user_rut'], '') self.assertEqual(response['corfo_save'], False) def test_student_view_user_passed_course_without_code(self): """ Verify context in student_view when user has passed the course and dont have code """ with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): self.xblock.scope_ids.user_id = self.student.id response = self.xblock.get_context() self.assertEqual(response['passed'], True) self.assertEqual(response['code'], '') self.assertEqual(response['user_rut'], '') self.assertEqual(response['corfo_save'], False) def test_student_view_user_passed_course_with_code(self): """ Verify context in student_view when user has passed the course and have code """ mapp_content = CorfoCodeMappingContent.objects.get(id_content=200, content='testtest') corfouser = CorfoCodeUser.objects.create(user=self.student, mapping_content=mapp_content, code='U1CODASDFGH') with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): self.xblock.scope_ids.user_id = self.student.id self.xblock.id_content = 200 response = self.xblock.get_context() self.assertEqual(response['passed'], True) self.assertEqual(response['code'], corfouser.code) self.assertEqual(response['user_rut'], '') self.assertEqual(response['corfo_save'], False) def test_student_view_user_passed_course_with_corfo_save(self): """ Verify context in student_view when user has passed the course and have corfo_save """ mapp_content = CorfoCodeMappingContent.objects.get(id_content=200, content='testtest') corfouser = CorfoCodeUser.objects.create(user=self.student, mapping_content=mapp_content, code='U1CODASDFGH', corfo_save=True) with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): self.xblock.scope_ids.user_id = self.student.id self.xblock.id_content = 200 response = self.xblock.get_context() self.assertEqual(response['passed'], True) self.assertEqual(response['code'], corfouser.code) self.assertEqual(response['user_rut'], '') self.assertEqual(response['corfo_save'], True) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_block_generate_code(self, post): """ Verify generate_code() is working """ try: from unittest.case import SkipTest from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='009472337K') except ImportError: self.skipTest("import error uchileedxlogin") request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = True data = json.dumps({'display_name': 'testname', "id_content": '200', "content": 'testtest', 'display_title': 'testtitle'}) request.body = data.encode() response = self.xblock.studio_submit(request) self.assertEqual(self.xblock.display_name, 'testname') self.assertEqual(self.xblock.display_title, 'testtitle') self.assertEqual(self.xblock.id_content, 200) self.assertEqual(self.xblock.id_institution, 3093) self.assertEqual(self.xblock.content, 'testtest') CorfoCodeInstitution.objects.create(id_institution=self.xblock.id_institution) post_data = { 'Data': 0, 'Message': None, 'Status': 0, 'Success': True } resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data) ,namedtuple("Request", ["status_code", "json"])(200, lambda:post_data)] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = False self.xblock.scope_ids.user_id = self.student.id data = json.dumps({}) request.body = data.encode() response = self.xblock.generate_code(request) data = json.loads(response._app_iter[0].decode()) self.assertEqual(data['result'], 'success') corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content__id_content=self.xblock.id_content) self.assertEqual(data['code'], corfouser.code) self.assertTrue(corfouser.corfo_save) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_block_generate_code_with_passport(self, post): """ Verify generate_code() is working whern user have passport """ try: from unittest.case import SkipTest from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='P009472337K') except ImportError: self.skipTest("import error uchileedxlogin") request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = True data = json.dumps({'display_name': 'testname', "id_content": '200', "content": 'testtest', 'display_title': 'testtitle'}) request.body = data.encode() response = self.xblock.studio_submit(request) self.assertEqual(self.xblock.display_name, 'testname') self.assertEqual(self.xblock.display_title, 'testtitle') self.assertEqual(self.xblock.id_content, 200) self.assertEqual(self.xblock.id_institution, 3093) self.assertEqual(self.xblock.content, 'testtest') CorfoCodeInstitution.objects.create(id_institution=self.xblock.id_institution) post_data = { 'Data': 0, 'Message': None, 'Status': 0, 'Success': True } resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data) ,namedtuple("Request", ["status_code", "json"])(200, lambda:post_data)] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = False self.xblock.scope_ids.user_id = self.student.id data = json.dumps({}) request.body = data.encode() response = self.xblock.generate_code(request) data = json.loads(response._app_iter[0].decode()) self.assertEqual(data['result'], 'success') corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content__id_content=self.xblock.id_content) self.assertEqual(data['code'], corfouser.code) self.assertTrue(corfouser.corfo_save) @override_settings(CORFOGENERATE_URL_TOKEN="aaaaa") @override_settings(CORFOGENERATE_CLIENT_ID="aaaaa") @override_settings(CORFOGENERATE_CLIENT_SECRET="aaaaa") @override_settings(CORFOGENERATE_URL_VALIDATE="aaaaa") @patch('requests.post') def test_block_generate_code_no_passport(self, post): """ Verify generate_code() is working """ try: from unittest.case import SkipTest from uchileedxlogin.models import EdxLoginUser EdxLoginUser.objects.create(user=self.student, run='CA009472337K') except ImportError: self.skipTest("import error uchileedxlogin") request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = True data = json.dumps({'display_name': 'testname', "id_content": '200', "content": 'testtest', 'display_title': 'testtitle'}) request.body = data.encode() response = self.xblock.studio_submit(request) self.assertEqual(self.xblock.display_name, 'testname') self.assertEqual(self.xblock.display_title, 'testtitle') self.assertEqual(self.xblock.id_content, 200) self.assertEqual(self.xblock.id_institution, 3093) self.assertEqual(self.xblock.content, 'testtest') CorfoCodeInstitution.objects.create(id_institution=self.xblock.id_institution) resp_data = { "access_token": "IE742SAsEMadiliCt1w582TMnvj98aDyS6L7BXSFP84vto914p77nX", "token_type": "Bearer", "expires_in": 3599, "scope": "resource.READ" } post.side_effect = [namedtuple("Request", ["status_code", "json"])(200, lambda:resp_data) ,] with mock_get_score(3, 4): self.grade_factory.update(self.student, self.course, force_update_subsections=True) with mock_get_score(3, 4): request = TestRequest() request.method = 'POST' self.xblock.xmodule_runtime.user_is_staff = False self.xblock.scope_ids.user_id = self.student.id data = json.dumps({}) request.body = data.encode() response = self.xblock.generate_code(request) data = json.loads(response._app_iter[0].decode()) self.assertEqual(data['result'], 'error') corfouser = CorfoCodeUser.objects.get(user=self.student, mapping_content__id_content=self.xblock.id_content) self.assertTrue('code' not in data) self.assertFalse(corfouser.corfo_save)