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)
