Skip to content

E
edx-platform
Commit a2fa59cd by Matt Drayer
Options

Merge pull request #10308 from edx/ziafazal/SOL-1332 

SOL-1332: use a generic function to check if entrance_exam feature is enabled or not
parents 487a894f 9bb6f6e8
Showing with 350 additions and 348 deletions
cms/djangoapps/contentstore/views/course.py
...@@ -67,8 +67,7 @@ from contentstore.tasks import rerun_course ...@@ -67,8 +67,7 @@ from contentstore.tasks import rerun_course
from contentstore.views.entrance_exam import ( from contentstore.views.entrance_exam import (
create_entrance_exam, create_entrance_exam,
update_entrance_exam, update_entrance_exam,
delete_entrance_exam, delete_entrance_exam
is_entrance_exams_enabled
) )
from .library import LIBRARIES_ENABLED from .library import LIBRARIES_ENABLED
...@@ -89,7 +88,8 @@ from student.auth import has_course_author_access ...@@ -89,7 +88,8 @@ from student.auth import has_course_author_access
from util.milestones_helpers import ( from util.milestones_helpers import (
set_prerequisite_courses, set_prerequisite_courses,
is_valid_course_key, is_valid_course_key,
is_prerequisite_courses_enabled is_prerequisite_courses_enabled,
is_entrance_exams_enabled
) )
log = logging.getLogger(__name__) log = logging.getLogger(__name__)
...@@ -983,7 +983,7 @@ def settings_handler(request, course_key_string): ...@@ -983,7 +983,7 @@ def settings_handler(request, course_key_string):
# feature-specific settings and handle them accordingly # feature-specific settings and handle them accordingly
# We have to be careful that we're only executing the following logic if we actually # We have to be careful that we're only executing the following logic if we actually
# need to create or delete an entrance exam from the specified course # need to create or delete an entrance exam from the specified course
if settings.FEATURES.get('ENTRANCE_EXAMS', False): if is_entrance_exams_enabled():
course_entrance_exam_present = course_module.entrance_exam_enabled course_entrance_exam_present = course_module.entrance_exam_enabled
entrance_exam_enabled = request.json.get('entrance_exam_enabled', '') == 'true' entrance_exam_enabled = request.json.get('entrance_exam_enabled', '') == 'true'
ee_min_score_pct = request.json.get('entrance_exam_minimum_score_pct', None) ee_min_score_pct = request.json.get('entrance_exam_minimum_score_pct', None)
......
cms/djangoapps/contentstore/views/entrance_exam.py
...@@ -54,13 +54,6 @@ def check_feature_enabled(feature_name): ...@@ -54,13 +54,6 @@ def check_feature_enabled(feature_name):
return _check_feature_enabled return _check_feature_enabled
def is_entrance_exams_enabled():
"""
Returns a boolean indicating entrance exam feature is enable or not.
"""
return settings.FEATURES.get('ENTRANCE_EXAMS', False)
@login_required @login_required
@ensure_csrf_cookie @ensure_csrf_cookie
@check_feature_enabled(feature_name='ENTRANCE_EXAMS') @check_feature_enabled(feature_name='ENTRANCE_EXAMS')
......
cms/djangoapps/contentstore/views/helpers.py
...@@ -22,6 +22,7 @@ from xmodule.tabs import StaticTab ...@@ -22,6 +22,7 @@ from xmodule.tabs import StaticTab
from contentstore.utils import reverse_course_url, reverse_library_url, reverse_usage_url from contentstore.utils import reverse_course_url, reverse_library_url, reverse_usage_url
from models.settings.course_grading import CourseGradingModel from models.settings.course_grading import CourseGradingModel
from util.milestones_helpers import is_entrance_exams_enabled
__all__ = ['edge', 'event', 'landing'] __all__ = ['edge', 'event', 'landing']
...@@ -226,7 +227,7 @@ def create_xblock(parent_locator, user, category, display_name, boilerplate=None ...@@ -226,7 +227,7 @@ def create_xblock(parent_locator, user, category, display_name, boilerplate=None
# Entrance Exams: Chapter module positioning # Entrance Exams: Chapter module positioning
child_position = None child_position = None
if settings.FEATURES.get('ENTRANCE_EXAMS', False): if is_entrance_exams_enabled():
if category == 'chapter' and is_entrance_exam: if category == 'chapter' and is_entrance_exam:
fields['is_entrance_exam'] = is_entrance_exam fields['is_entrance_exam'] = is_entrance_exam
fields['in_entrance_exam'] = True # Inherited metadata, all children will have it fields['in_entrance_exam'] = True # Inherited metadata, all children will have it
...@@ -250,7 +251,7 @@ def create_xblock(parent_locator, user, category, display_name, boilerplate=None ...@@ -250,7 +251,7 @@ def create_xblock(parent_locator, user, category, display_name, boilerplate=None
) )
# Entrance Exams: Grader assignment # Entrance Exams: Grader assignment
if settings.FEATURES.get('ENTRANCE_EXAMS', False): if is_entrance_exams_enabled():
course_key = usage_key.course_key course_key = usage_key.course_key
course = store.get_course(course_key) course = store.get_course(course_key)
if hasattr(course, 'entrance_exam_enabled') and course.entrance_exam_enabled: if hasattr(course, 'entrance_exam_enabled') and course.entrance_exam_enabled:
......
cms/djangoapps/contentstore/views/item.py
...@@ -38,6 +38,7 @@ from django.contrib.auth.models import User ...@@ -38,6 +38,7 @@ from django.contrib.auth.models import User
from util.date_utils import get_default_time_display from util.date_utils import get_default_time_display
from util.json_request import expect_json, JsonResponse from util.json_request import expect_json, JsonResponse
from util.milestones_helpers import is_entrance_exams_enabled
from student.auth import has_studio_write_access, has_studio_read_access from student.auth import has_studio_write_access, has_studio_read_access
from contentstore.utils import ( from contentstore.utils import (
...@@ -89,7 +90,7 @@ def _filter_entrance_exam_grader(graders): ...@@ -89,7 +90,7 @@ def _filter_entrance_exam_grader(graders):
views/controls like the 'Grade as' dropdown that allows a course author to select views/controls like the 'Grade as' dropdown that allows a course author to select
the grader type for a given section of a course the grader type for a given section of a course
""" """
if settings.FEATURES.get('ENTRANCE_EXAMS', False): if is_entrance_exams_enabled():
graders = [grader for grader in graders if grader.get('type') != u'Entrance Exam'] graders = [grader for grader in graders if grader.get('type') != u'Entrance Exam']
return graders return graders
......
cms/djangoapps/contentstore/views/tests/test_entrance_exam.py
...@@ -20,257 +20,257 @@ from util import milestones_helpers ...@@ -20,257 +20,257 @@ from util import milestones_helpers
from xmodule.modulestore.django import modulestore from xmodule.modulestore.django import modulestore
@patch.dict(settings.FEATURES, {'ENTRANCE_EXAMS': True})
class EntranceExamHandlerTests(CourseTestCase): class EntranceExamHandlerTests(CourseTestCase):
""" """
Base test class for create, save, and delete Base test class for create, save, and delete
""" """
if settings.FEATURES.get('ENTRANCE_EXAMS', False): def setUp(self):
def setUp(self): """
""" Shared scaffolding for individual test runs
Shared scaffolding for individual test runs """
""" super(EntranceExamHandlerTests, self).setUp()
super(EntranceExamHandlerTests, self).setUp() self.course_key = self.course.id
self.course_key = self.course.id self.usage_key = self.course.location
self.usage_key = self.course.location self.course_url = '/course/{}'.format(unicode(self.course.id))
self.course_url = '/course/{}'.format(unicode(self.course.id)) self.exam_url = '/course/{}/entrance_exam/'.format(unicode(self.course.id))
self.exam_url = '/course/{}/entrance_exam/'.format(unicode(self.course.id)) milestones_helpers.seed_milestone_relationship_types()
milestones_helpers.seed_milestone_relationship_types() self.milestone_relationship_types = milestones_helpers.get_milestone_relationship_types()
self.milestone_relationship_types = milestones_helpers.get_milestone_relationship_types()
def test_contentstore_views_entrance_exam_post(self): def test_contentstore_views_entrance_exam_post(self):
""" """
Unit Test: test_contentstore_views_entrance_exam_post Unit Test: test_contentstore_views_entrance_exam_post
""" """
resp = self.client.post(self.exam_url, {}, http_accept='application/json') resp = self.client.post(self.exam_url, {}, http_accept='application/json')
self.assertEqual(resp.status_code, 201) self.assertEqual(resp.status_code, 201)
resp = self.client.get(self.exam_url) resp = self.client.get(self.exam_url)
self.assertEqual(resp.status_code, 200) self.assertEqual(resp.status_code, 200)
# Reload the test course now that the exam module has been added # Reload the test course now that the exam module has been added
self.course = modulestore().get_course(self.course.id) self.course = modulestore().get_course(self.course.id)
metadata = CourseMetadata.fetch_all(self.course) metadata = CourseMetadata.fetch_all(self.course)
self.assertTrue(metadata['entrance_exam_enabled']) self.assertTrue(metadata['entrance_exam_enabled'])
self.assertIsNotNone(metadata['entrance_exam_minimum_score_pct']) self.assertIsNotNone(metadata['entrance_exam_minimum_score_pct'])
self.assertIsNotNone(metadata['entrance_exam_id']['value']) self.assertIsNotNone(metadata['entrance_exam_id']['value'])
self.assertTrue(len(milestones_helpers.get_course_milestones(unicode(self.course.id)))) self.assertTrue(len(milestones_helpers.get_course_milestones(unicode(self.course.id))))
content_milestones = milestones_helpers.get_course_content_milestones( content_milestones = milestones_helpers.get_course_content_milestones(
unicode(self.course.id), unicode(self.course.id),
metadata['entrance_exam_id']['value'], metadata['entrance_exam_id']['value'],
self.milestone_relationship_types['FULFILLS'] self.milestone_relationship_types['FULFILLS']
) )
self.assertTrue(len(content_milestones)) self.assertTrue(len(content_milestones))
def test_contentstore_views_entrance_exam_post_new_sequential_confirm_grader(self): def test_contentstore_views_entrance_exam_post_new_sequential_confirm_grader(self):
""" """
Unit Test: test_contentstore_views_entrance_exam_post Unit Test: test_contentstore_views_entrance_exam_post
""" """
resp = self.client.post(self.exam_url, {}, http_accept='application/json') resp = self.client.post(self.exam_url, {}, http_accept='application/json')
self.assertEqual(resp.status_code, 201) self.assertEqual(resp.status_code, 201)
resp = self.client.get(self.exam_url) resp = self.client.get(self.exam_url)
self.assertEqual(resp.status_code, 200) self.assertEqual(resp.status_code, 200)
# Reload the test course now that the exam module has been added # Reload the test course now that the exam module has been added
self.course = modulestore().get_course(self.course.id) self.course = modulestore().get_course(self.course.id)
# Add a new child sequential to the exam module # Add a new child sequential to the exam module
# Confirm that the grader type is 'Entrance Exam' # Confirm that the grader type is 'Entrance Exam'
chapter_locator_string = json.loads(resp.content).get('locator') chapter_locator_string = json.loads(resp.content).get('locator')
# chapter_locator = UsageKey.from_string(chapter_locator_string) # chapter_locator = UsageKey.from_string(chapter_locator_string)
seq_data = { seq_data = {
'category': "sequential", 'category': "sequential",
'display_name': "Entrance Exam Subsection", 'display_name': "Entrance Exam Subsection",
'parent_locator': chapter_locator_string, 'parent_locator': chapter_locator_string,
} }
resp = self.client.ajax_post(reverse_url('xblock_handler'), seq_data) resp = self.client.ajax_post(reverse_url('xblock_handler'), seq_data)
seq_locator_string = json.loads(resp.content).get('locator') seq_locator_string = json.loads(resp.content).get('locator')
seq_locator = UsageKey.from_string(seq_locator_string) seq_locator = UsageKey.from_string(seq_locator_string)
section_grader_type = CourseGradingModel.get_section_grader_type(seq_locator) section_grader_type = CourseGradingModel.get_section_grader_type(seq_locator)
self.assertEqual(GRADER_TYPES['ENTRANCE_EXAM'], section_grader_type['graderType']) self.assertEqual(GRADER_TYPES['ENTRANCE_EXAM'], section_grader_type['graderType'])
def test_contentstore_views_entrance_exam_get(self): def test_contentstore_views_entrance_exam_get(self):
""" """
Unit Test: test_contentstore_views_entrance_exam_get Unit Test: test_contentstore_views_entrance_exam_get
""" """
resp = self.client.post( resp = self.client.post(
self.exam_url, self.exam_url,
{'entrance_exam_minimum_score_pct': settings.ENTRANCE_EXAM_MIN_SCORE_PCT}, {'entrance_exam_minimum_score_pct': settings.ENTRANCE_EXAM_MIN_SCORE_PCT},
http_accept='application/json' http_accept='application/json'
) )
self.assertEqual(resp.status_code, 201) self.assertEqual(resp.status_code, 201)
resp = self.client.get(self.exam_url) resp = self.client.get(self.exam_url)
self.assertEqual(resp.status_code, 200) self.assertEqual(resp.status_code, 200)
def test_contentstore_views_entrance_exam_delete(self): def test_contentstore_views_entrance_exam_delete(self):
""" """
Unit Test: test_contentstore_views_entrance_exam_delete Unit Test: test_contentstore_views_entrance_exam_delete
""" """
resp = self.client.post(self.exam_url, {}, http_accept='application/json') resp = self.client.post(self.exam_url, {}, http_accept='application/json')
self.assertEqual(resp.status_code, 201) self.assertEqual(resp.status_code, 201)
resp = self.client.get(self.exam_url) resp = self.client.get(self.exam_url)
self.assertEqual(resp.status_code, 200) self.assertEqual(resp.status_code, 200)
resp = self.client.delete(self.exam_url) resp = self.client.delete(self.exam_url)
self.assertEqual(resp.status_code, 204) self.assertEqual(resp.status_code, 204)
resp = self.client.get(self.exam_url) resp = self.client.get(self.exam_url)
self.assertEqual(resp.status_code, 404) self.assertEqual(resp.status_code, 404)
user = User.objects.create( user = User.objects.create(
username='test_user', username='test_user',
email='test_user@edx.org', email='test_user@edx.org',
is_active=True, is_active=True,
) )
user.set_password('test') user.set_password('test')
user.save() user.save()
milestones = milestones_helpers.get_course_milestones(unicode(self.course_key)) milestones = milestones_helpers.get_course_milestones(unicode(self.course_key))
self.assertEqual(len(milestones), 1) self.assertEqual(len(milestones), 1)
milestone_key = '{}.{}'.format(milestones[0]['namespace'], milestones[0]['name']) milestone_key = '{}.{}'.format(milestones[0]['namespace'], milestones[0]['name'])
paths = milestones_helpers.get_course_milestones_fulfillment_paths( paths = milestones_helpers.get_course_milestones_fulfillment_paths(
unicode(self.course_key), unicode(self.course_key),
milestones_helpers.serialize_user(user) milestones_helpers.serialize_user(user)
) )
# What we have now is a course milestone requirement and no valid fulfillment # What we have now is a course milestone requirement and no valid fulfillment
# paths for the specified user. The LMS is going to have to ignore this situation, # paths for the specified user. The LMS is going to have to ignore this situation,
# because we can't confidently prevent it from occuring at some point in the future. # because we can't confidently prevent it from occuring at some point in the future.
# milestone_key_1 = # milestone_key_1 =
self.assertEqual(len(paths[milestone_key]), 0) self.assertEqual(len(paths[milestone_key]), 0)
# Re-adding an entrance exam to the course should fix the missing link # Re-adding an entrance exam to the course should fix the missing link
# It wipes out any old entrance exam artifacts and inserts a new exam course chapter/module # It wipes out any old entrance exam artifacts and inserts a new exam course chapter/module
resp = self.client.post(self.exam_url, {}, http_accept='application/json') resp = self.client.post(self.exam_url, {}, http_accept='application/json')
self.assertEqual(resp.status_code, 201) self.assertEqual(resp.status_code, 201)
resp = self.client.get(self.exam_url) resp = self.client.get(self.exam_url)
self.assertEqual(resp.status_code, 200) self.assertEqual(resp.status_code, 200)
# Confirm that we have only one Entrance Exam grader after re-adding the exam (validates SOL-475) # Confirm that we have only one Entrance Exam grader after re-adding the exam (validates SOL-475)
graders = CourseGradingModel.fetch(self.course_key).graders graders = CourseGradingModel.fetch(self.course_key).graders
count = 0 count = 0
for grader in graders: for grader in graders:
if grader['type'] == GRADER_TYPES['ENTRANCE_EXAM']: if grader['type'] == GRADER_TYPES['ENTRANCE_EXAM']:
count += 1 count += 1
self.assertEqual(count, 1) self.assertEqual(count, 1)
def test_contentstore_views_entrance_exam_delete_bogus_course(self): def test_contentstore_views_entrance_exam_delete_bogus_course(self):
""" """
Unit Test: test_contentstore_views_entrance_exam_delete_bogus_course Unit Test: test_contentstore_views_entrance_exam_delete_bogus_course
""" """
resp = self.client.delete('/course/bad/course/key/entrance_exam') resp = self.client.delete('/course/bad/course/key/entrance_exam')
self.assertEqual(resp.status_code, 400) self.assertEqual(resp.status_code, 400)
def test_contentstore_views_entrance_exam_get_bogus_course(self): def test_contentstore_views_entrance_exam_get_bogus_course(self):
""" """
Unit Test: test_contentstore_views_entrance_exam_get_bogus_course Unit Test: test_contentstore_views_entrance_exam_get_bogus_course
""" """
resp = self.client.get('/course/bad/course/key/entrance_exam') resp = self.client.get('/course/bad/course/key/entrance_exam')
self.assertEqual(resp.status_code, 400) self.assertEqual(resp.status_code, 400)
def test_contentstore_views_entrance_exam_get_bogus_exam(self): def test_contentstore_views_entrance_exam_get_bogus_exam(self):
""" """
Unit Test: test_contentstore_views_entrance_exam_get_bogus_exam Unit Test: test_contentstore_views_entrance_exam_get_bogus_exam
""" """
resp = self.client.post( resp = self.client.post(
self.exam_url, self.exam_url,
{'entrance_exam_minimum_score_pct': '50'}, {'entrance_exam_minimum_score_pct': '50'},
http_accept='application/json' http_accept='application/json'
) )
self.assertEqual(resp.status_code, 201) self.assertEqual(resp.status_code, 201)
resp = self.client.get(self.exam_url) resp = self.client.get(self.exam_url)
self.assertEqual(resp.status_code, 200) self.assertEqual(resp.status_code, 200)
self.course = modulestore().get_course(self.course.id) self.course = modulestore().get_course(self.course.id)
# Should raise an ItemNotFoundError and return a 404 # Should raise an ItemNotFoundError and return a 404
updated_metadata = {'entrance_exam_id': 'i4x://org.4/course_4/chapter/ed7c4c6a4d68409998e2c8554c4629d1'} updated_metadata = {'entrance_exam_id': 'i4x://org.4/course_4/chapter/ed7c4c6a4d68409998e2c8554c4629d1'}
CourseMetadata.update_from_dict( CourseMetadata.update_from_dict(
updated_metadata, updated_metadata,
self.course, self.course,
self.user, self.user,
) )
self.course = modulestore().get_course(self.course.id) self.course = modulestore().get_course(self.course.id)
resp = self.client.get(self.exam_url) resp = self.client.get(self.exam_url)
self.assertEqual(resp.status_code, 404) self.assertEqual(resp.status_code, 404)
# Should raise an InvalidKeyError and return a 404 # Should raise an InvalidKeyError and return a 404
updated_metadata = {'entrance_exam_id': '123afsdfsad90f87'} updated_metadata = {'entrance_exam_id': '123afsdfsad90f87'}
CourseMetadata.update_from_dict( CourseMetadata.update_from_dict(
updated_metadata, updated_metadata,
self.course, self.course,
self.user, self.user,
) )
self.course = modulestore().get_course(self.course.id) self.course = modulestore().get_course(self.course.id)
resp = self.client.get(self.exam_url) resp = self.client.get(self.exam_url)
self.assertEqual(resp.status_code, 404) self.assertEqual(resp.status_code, 404)
def test_contentstore_views_entrance_exam_post_bogus_course(self): def test_contentstore_views_entrance_exam_post_bogus_course(self):
""" """
Unit Test: test_contentstore_views_entrance_exam_post_bogus_course Unit Test: test_contentstore_views_entrance_exam_post_bogus_course
""" """
resp = self.client.post( resp = self.client.post(
'/course/bad/course/key/entrance_exam', '/course/bad/course/key/entrance_exam',
{}, {},
http_accept='application/json' http_accept='application/json'
) )
self.assertEqual(resp.status_code, 400) self.assertEqual(resp.status_code, 400)
def test_contentstore_views_entrance_exam_post_invalid_http_accept(self): def test_contentstore_views_entrance_exam_post_invalid_http_accept(self):
""" """
Unit Test: test_contentstore_views_entrance_exam_post_invalid_http_accept Unit Test: test_contentstore_views_entrance_exam_post_invalid_http_accept
""" """
resp = self.client.post( resp = self.client.post(
'/course/bad/course/key/entrance_exam', '/course/bad/course/key/entrance_exam',
{}, {},
http_accept='text/html' http_accept='text/html'
) )
self.assertEqual(resp.status_code, 400) self.assertEqual(resp.status_code, 400)
def test_contentstore_views_entrance_exam_get_invalid_user(self): def test_contentstore_views_entrance_exam_get_invalid_user(self):
""" """
Unit Test: test_contentstore_views_entrance_exam_get_invalid_user Unit Test: test_contentstore_views_entrance_exam_get_invalid_user
""" """
user = User.objects.create( user = User.objects.create(
username='test_user', username='test_user',
email='test_user@edx.org', email='test_user@edx.org',
is_active=True, is_active=True,
) )
user.set_password('test') user.set_password('test')
user.save() user.save()
self.client = AjaxEnabledTestClient() self.client = AjaxEnabledTestClient()
self.client.login(username='test_user', password='test') self.client.login(username='test_user', password='test')
resp = self.client.get(self.exam_url) resp = self.client.get(self.exam_url)
self.assertEqual(resp.status_code, 403) self.assertEqual(resp.status_code, 403)
def test_contentstore_views_entrance_exam_unsupported_method(self): def test_contentstore_views_entrance_exam_unsupported_method(self):
""" """
Unit Test: test_contentstore_views_entrance_exam_unsupported_method Unit Test: test_contentstore_views_entrance_exam_unsupported_method
""" """
resp = self.client.put(self.exam_url) resp = self.client.put(self.exam_url)
self.assertEqual(resp.status_code, 405) self.assertEqual(resp.status_code, 405)
def test_entrance_exam_view_direct_missing_score_setting(self): def test_entrance_exam_view_direct_missing_score_setting(self):
""" """
Unit Test: test_entrance_exam_view_direct_missing_score_setting Unit Test: test_entrance_exam_view_direct_missing_score_setting
""" """
user = UserFactory() user = UserFactory()
user.is_staff = True user.is_staff = True
request = RequestFactory() request = RequestFactory()
request.user = user request.user = user
resp = create_entrance_exam(request, self.course.id, None) resp = create_entrance_exam(request, self.course.id, None)
self.assertEqual(resp.status_code, 201) self.assertEqual(resp.status_code, 201)
@patch.dict('django.conf.settings.FEATURES', {'ENTRANCE_EXAMS': False}) @patch.dict('django.conf.settings.FEATURES', {'ENTRANCE_EXAMS': False})
def test_entrance_exam_feature_flag_gating(self): def test_entrance_exam_feature_flag_gating(self):
user = UserFactory() user = UserFactory()
user.is_staff = True user.is_staff = True
request = RequestFactory() request = RequestFactory()
request.user = user request.user = user
resp = self.client.get(self.exam_url) resp = self.client.get(self.exam_url)
self.assertEqual(resp.status_code, 400) self.assertEqual(resp.status_code, 400)
resp = create_entrance_exam(request, self.course.id, None) resp = create_entrance_exam(request, self.course.id, None)
self.assertEqual(resp.status_code, 400) self.assertEqual(resp.status_code, 400)
resp = delete_entrance_exam(request, self.course.id) resp = delete_entrance_exam(request, self.course.id)
self.assertEqual(resp.status_code, 400) self.assertEqual(resp.status_code, 400)
# No return, so we'll just ensure no exception is thrown # No return, so we'll just ensure no exception is thrown
update_entrance_exam(request, self.course.id, {}) update_entrance_exam(request, self.course.id, {})
common/djangoapps/student/models.py
...@@ -52,6 +52,7 @@ import lms.lib.comment_client as cc ...@@ -52,6 +52,7 @@ import lms.lib.comment_client as cc
from openedx.core.djangoapps.content.course_overviews.models import CourseOverview from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
from util.model_utils import emit_field_changed_events, get_changed_fields_dict from util.model_utils import emit_field_changed_events, get_changed_fields_dict
from util.query import use_read_replica_if_available from util.query import use_read_replica_if_available
from util.milestones_helpers import is_entrance_exams_enabled
UNENROLL_DONE = Signal(providing_args=["course_enrollment", "skip_refund"]) UNENROLL_DONE = Signal(providing_args=["course_enrollment", "skip_refund"])
...@@ -1896,7 +1897,7 @@ class EntranceExamConfiguration(models.Model): ...@@ -1896,7 +1897,7 @@ class EntranceExamConfiguration(models.Model):
Return True if given user can skip entrance exam for given course otherwise False. Return True if given user can skip entrance exam for given course otherwise False.
""" """
can_skip = False can_skip = False
if settings.FEATURES.get('ENTRANCE_EXAMS', False): if is_entrance_exams_enabled():
try: try:
record = EntranceExamConfiguration.objects.get(user=user, course_id=course_key) record = EntranceExamConfiguration.objects.get(user=user, course_id=course_key)
can_skip = record.skip_entrance_exam can_skip = record.skip_entrance_exam
......
common/djangoapps/util/milestones_helpers.py
...@@ -24,6 +24,14 @@ def get_namespace_choices(): ...@@ -24,6 +24,14 @@ def get_namespace_choices():
return NAMESPACE_CHOICES return NAMESPACE_CHOICES
def is_entrance_exams_enabled():
"""
Checks to see if the Entrance Exams feature is enabled
Use this operation instead of checking the feature flag all over the place
"""
return settings.FEATURES.get('ENTRANCE_EXAMS', False)
def is_prerequisite_courses_enabled(): def is_prerequisite_courses_enabled():
""" """
Returns boolean indicating prerequisite courses enabled system wide or not. Returns boolean indicating prerequisite courses enabled system wide or not.
......
lms/djangoapps/courseware/entrance_exams.py
...@@ -8,24 +8,16 @@ from courseware.model_data import FieldDataCache, ScoresClient ...@@ -8,24 +8,16 @@ from courseware.model_data import FieldDataCache, ScoresClient
from opaque_keys.edx.keys import UsageKey from opaque_keys.edx.keys import UsageKey
from opaque_keys.edx.locator import BlockUsageLocator from opaque_keys.edx.locator import BlockUsageLocator
from student.models import EntranceExamConfiguration from student.models import EntranceExamConfiguration
from util.milestones_helpers import get_required_content from util.milestones_helpers import get_required_content, is_entrance_exams_enabled
from util.module_utils import yield_dynamic_descriptor_descendants from util.module_utils import yield_dynamic_descriptor_descendants
from xmodule.modulestore.django import modulestore from xmodule.modulestore.django import modulestore
def feature_is_enabled():
"""
Checks to see if the Entrance Exams feature is enabled
Use this operation instead of checking the feature flag all over the place
"""
return settings.FEATURES.get('ENTRANCE_EXAMS', False)
def course_has_entrance_exam(course): def course_has_entrance_exam(course):
""" """
Checks to see if a course is properly configured for an entrance exam Checks to see if a course is properly configured for an entrance exam
""" """
if not feature_is_enabled(): if not is_entrance_exams_enabled():
return False return False
if not course.entrance_exam_enabled: if not course.entrance_exam_enabled:
return False return False
......
lms/djangoapps/courseware/module_render.py
...@@ -469,7 +469,7 @@ def get_module_system_for_user(user, student_data, # TODO # pylint: disable=to ...@@ -469,7 +469,7 @@ def get_module_system_for_user(user, student_data, # TODO # pylint: disable=to
# Fulfillment Use Case: Entrance Exam # Fulfillment Use Case: Entrance Exam
# If this module is part of an entrance exam, we'll need to see if the student # If this module is part of an entrance exam, we'll need to see if the student
# has reached the point at which they can collect the associated milestone # has reached the point at which they can collect the associated milestone
if settings.FEATURES.get('ENTRANCE_EXAMS', False): if milestones_helpers.is_entrance_exams_enabled():
course = modulestore().get_course(course_key) course = modulestore().get_course(course_key)
content = modulestore().get_item(content_key) content = modulestore().get_item(content_key)
entrance_exam_enabled = getattr(course, 'entrance_exam_enabled', False) entrance_exam_enabled = getattr(course, 'entrance_exam_enabled', False)
......
lms/djangoapps/courseware/tests/test_tabs.py
...@@ -19,7 +19,13 @@ from courseware.tests.factories import InstructorFactory, StaffFactory ...@@ -19,7 +19,13 @@ from courseware.tests.factories import InstructorFactory, StaffFactory
from courseware.views import get_static_tab_contents, static_tab from courseware.views import get_static_tab_contents, static_tab
from student.models import CourseEnrollment from student.models import CourseEnrollment
from student.tests.factories import UserFactory from student.tests.factories import UserFactory
from util import milestones_helpers from util.milestones_helpers import (
seed_milestone_relationship_types,
get_milestone_relationship_types,
add_milestone,
add_course_milestone,
add_course_content_milestone
)
from xmodule import tabs as xmodule_tabs from xmodule import tabs as xmodule_tabs
from xmodule.modulestore.tests.django_utils import ( from xmodule.modulestore.tests.django_utils import (
TEST_DATA_MIXED_TOY_MODULESTORE, TEST_DATA_MIXED_CLOSED_MODULESTORE TEST_DATA_MIXED_TOY_MODULESTORE, TEST_DATA_MIXED_CLOSED_MODULESTORE
...@@ -303,112 +309,112 @@ class StaticTabDateTestCaseXML(LoginEnrollmentTestCase, ModuleStoreTestCase): ...@@ -303,112 +309,112 @@ class StaticTabDateTestCaseXML(LoginEnrollmentTestCase, ModuleStoreTestCase):
@attr('shard_1') @attr('shard_1')
@patch.dict('django.conf.settings.FEATURES', {'ENTRANCE_EXAMS': True, 'MILESTONES_APP': True})
class EntranceExamsTabsTestCase(LoginEnrollmentTestCase, ModuleStoreTestCase): class EntranceExamsTabsTestCase(LoginEnrollmentTestCase, ModuleStoreTestCase):
""" """
Validate tab behavior when dealing with Entrance Exams Validate tab behavior when dealing with Entrance Exams
""" """
MODULESTORE = TEST_DATA_MIXED_CLOSED_MODULESTORE MODULESTORE = TEST_DATA_MIXED_CLOSED_MODULESTORE
if settings.FEATURES.get('ENTRANCE_EXAMS', False): @patch.dict('django.conf.settings.FEATURES', {'ENTRANCE_EXAMS': True, 'MILESTONES_APP': True})
def setUp(self):
"""
Test case scaffolding
"""
super(EntranceExamsTabsTestCase, self).setUp()
def setUp(self): self.course = CourseFactory.create()
""" self.instructor_tab = ItemFactory.create(
Test case scaffolding category="instructor", parent_location=self.course.location,
""" data="Instructor Tab", display_name="Instructor"
super(EntranceExamsTabsTestCase, self).setUp() )
self.extra_tab_2 = ItemFactory.create(
category="static_tab", parent_location=self.course.location,
data="Extra Tab", display_name="Extra Tab 2"
)
self.extra_tab_3 = ItemFactory.create(
category="static_tab", parent_location=self.course.location,
data="Extra Tab", display_name="Extra Tab 3"
)
self.setup_user()
self.enroll(self.course)
self.user.is_staff = True
seed_milestone_relationship_types()
self.relationship_types = get_milestone_relationship_types()
self.course = CourseFactory.create() def test_get_course_tabs_list_entrance_exam_enabled(self):
self.instructor_tab = ItemFactory.create( """
category="instructor", parent_location=self.course.location, Unit Test: test_get_course_tabs_list_entrance_exam_enabled
data="Instructor Tab", display_name="Instructor" """
) entrance_exam = ItemFactory.create(
self.extra_tab_2 = ItemFactory.create( category="chapter",
category="static_tab", parent_location=self.course.location, parent_location=self.course.location,
data="Extra Tab", display_name="Extra Tab 2" data="Exam Data",
) display_name="Entrance Exam",
self.extra_tab_3 = ItemFactory.create( is_entrance_exam=True
category="static_tab", parent_location=self.course.location, )
data="Extra Tab", display_name="Extra Tab 3" milestone = {
) 'name': 'Test Milestone',
self.setup_user() 'namespace': '{}.entrance_exams'.format(unicode(self.course.id)),
self.enroll(self.course) 'description': 'Testing Courseware Tabs'
self.user.is_staff = True }
self.relationship_types = milestones_helpers.get_milestone_relationship_types() self.user.is_staff = False
milestones_helpers.seed_milestone_relationship_types() request = get_request_for_user(self.user)
self.course.entrance_exam_enabled = True
def test_get_course_tabs_list_entrance_exam_enabled(self): self.course.entrance_exam_id = unicode(entrance_exam.location)
""" milestone = add_milestone(milestone)
Unit Test: test_get_course_tabs_list_entrance_exam_enabled add_course_milestone(
""" unicode(self.course.id),
entrance_exam = ItemFactory.create( self.relationship_types['REQUIRES'],
category="chapter", milestone
parent_location=self.course.location, )
data="Exam Data", add_course_content_milestone(
display_name="Entrance Exam", unicode(self.course.id),
is_entrance_exam=True unicode(entrance_exam.location),
) self.relationship_types['FULFILLS'],
milestone = { milestone
'name': 'Test Milestone', )
'namespace': '{}.entrance_exams'.format(unicode(self.course.id)), course_tab_list = get_course_tab_list(request, self.course)
'description': 'Testing Courseware Tabs' self.assertEqual(len(course_tab_list), 1)
} self.assertEqual(course_tab_list[0]['tab_id'], 'courseware')
self.user.is_staff = False self.assertEqual(course_tab_list[0]['name'], 'Entrance Exam')
request = get_request_for_user(self.user)
self.course.entrance_exam_enabled = True def test_get_course_tabs_list_skipped_entrance_exam(self):
self.course.entrance_exam_id = unicode(entrance_exam.location) """
milestone = milestones_helpers.add_milestone(milestone) Tests tab list is not limited if user is allowed to skip entrance exam.
milestones_helpers.add_course_milestone( """
unicode(self.course.id), #create a user
self.relationship_types['REQUIRES'], student = UserFactory()
milestone # login as instructor hit skip entrance exam api in instructor app
) instructor = InstructorFactory(course_key=self.course.id)
milestones_helpers.add_course_content_milestone( self.client.logout()
unicode(self.course.id), self.client.login(username=instructor.username, password='test')
unicode(entrance_exam.location),
self.relationship_types['FULFILLS'], url = reverse('mark_student_can_skip_entrance_exam', kwargs={'course_id': unicode(self.course.id)})
milestone response = self.client.post(url, {
) 'unique_student_identifier': student.email,
course_tab_list = get_course_tab_list(request, self.course) })
self.assertEqual(len(course_tab_list), 1) self.assertEqual(response.status_code, 200)
self.assertEqual(course_tab_list[0]['tab_id'], 'courseware')
self.assertEqual(course_tab_list[0]['name'], 'Entrance Exam') # log in again as student
self.client.logout()
def test_get_course_tabs_list_skipped_entrance_exam(self): self.login(self.email, self.password)
""" request = get_request_for_user(self.user)
Tests tab list is not limited if user is allowed to skip entrance exam. course_tab_list = get_course_tab_list(request, self.course)
""" self.assertEqual(len(course_tab_list), 5)
#create a user
student = UserFactory() def test_course_tabs_list_for_staff_members(self):
# login as instructor hit skip entrance exam api in instructor app """
instructor = InstructorFactory(course_key=self.course.id) Tests tab list is not limited if user is member of staff
self.client.logout() and has not passed entrance exam.
self.client.login(username=instructor.username, password='test') """
# Login as member of staff
url = reverse('mark_student_can_skip_entrance_exam', kwargs={'course_id': unicode(self.course.id)}) self.client.logout()
response = self.client.post(url, { staff_user = StaffFactory(course_key=self.course.id)
'unique_student_identifier': student.email, self.client.login(username=staff_user.username, password='test')
}) request = get_request_for_user(staff_user)
self.assertEqual(response.status_code, 200) course_tab_list = get_course_tab_list(request, self.course)
self.assertEqual(len(course_tab_list), 5)
# log in again as student
self.client.logout()
self.login(self.email, self.password)
request = get_request_for_user(self.user)
course_tab_list = get_course_tab_list(request, self.course)
self.assertEqual(len(course_tab_list), 5)
def test_course_tabs_list_for_staff_members(self):
"""
Tests tab list is not limited if user is member of staff
and has not passed entrance exam.
"""
# Login as member of staff
self.client.logout()
staff_user = StaffFactory(course_key=self.course.id)
self.client.login(username=staff_user.username, password='test')
request = get_request_for_user(staff_user)
course_tab_list = get_course_tab_list(request, self.course)
self.assertEqual(len(course_tab_list), 5)
@attr('shard_1') @attr('shard_1')
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment