-
diff --git a/common/lib/xmodule/xmodule/modulestore/mongo/base.py b/common/lib/xmodule/xmodule/modulestore/mongo/base.py
index f872e1466a..83d855bc0c 100644
--- a/common/lib/xmodule/xmodule/modulestore/mongo/base.py
+++ b/common/lib/xmodule/xmodule/modulestore/mongo/base.py
@@ -797,7 +797,7 @@ class MongoModuleStore(ModuleStoreWriteBase):
if xblock.category == 'static_tab':
course = self._get_course_for_item(xblock.location)
# find the course's reference to this tab and update the name.
- static_tab = CourseTabList.get_tab_by_slug(course, xblock.location.name)
+ static_tab = CourseTabList.get_tab_by_slug(course.tabs, xblock.location.name)
# only update if changed
if static_tab and static_tab['name'] != xblock.display_name:
static_tab['name'] = xblock.display_name
diff --git a/common/lib/xmodule/xmodule/modulestore/xml.py b/common/lib/xmodule/xmodule/modulestore/xml.py
index b8023c9ea4..304f5f1c0c 100644
--- a/common/lib/xmodule/xmodule/modulestore/xml.py
+++ b/common/lib/xmodule/xmodule/modulestore/xml.py
@@ -663,7 +663,7 @@ class XMLModuleStore(ModuleStoreReadBase):
# Hack because we need to pull in the 'display_name' for static tabs (because we need to edit them)
# from the course policy
if category == "static_tab":
- tab = CourseTabList.get_tab_by_slug(course=course_descriptor, url_slug=slug)
+ tab = CourseTabList.get_tab_by_slug(tab_list=course_descriptor.tabs, url_slug=slug)
if tab:
module.display_name = tab.name
module.data_dir = course_dir
diff --git a/common/lib/xmodule/xmodule/tabs.py b/common/lib/xmodule/xmodule/tabs.py
index c3193a540b..cd1f5101db 100644
--- a/common/lib/xmodule/xmodule/tabs.py
+++ b/common/lib/xmodule/xmodule/tabs.py
@@ -28,6 +28,15 @@ class CourseTab(object): # pylint: disable=incomplete-protocol
# subclass, shared by all instances of the subclass.
type = ''
+ # Class property that specifies whether the tab can be hidden for a particular course
+ is_hideable = False
+
+ # Class property that specifies whether the tab can be moved within a course's list of tabs
+ is_movable = True
+
+ # Class property that specifies whether the tab is a collection of other tabs
+ is_collection = False
+
def __init__(self, name, tab_id, link_func):
"""
Initializes class members with values passed in by subclasses.
@@ -48,9 +57,6 @@ class CourseTab(object): # pylint: disable=incomplete-protocol
self.link_func = link_func
- # indicates whether the tab can be hidden for a particular course
- self.is_hideable = False
-
def can_display(self, course, settings, is_user_authenticated, is_user_staff): # pylint: disable=unused-argument
"""
Determines whether the tab should be displayed in the UI for the given course and a particular user.
@@ -140,12 +146,12 @@ class CourseTab(object): # pylint: disable=incomplete-protocol
return not (self == other)
@classmethod
- def validate(cls, tab, raise_error=True): # pylint: disable=unused-argument
+ def validate(cls, tab_dict, raise_error=True):
"""
Validates the given dict-type tab object to ensure it contains the expected keys.
This method should be overridden by subclasses that require certain keys to be persisted in the tab.
"""
- return key_checker(['type'])(tab, raise_error)
+ return key_checker(['type'])(tab_dict, raise_error)
def to_json(self):
"""
@@ -158,7 +164,7 @@ class CourseTab(object): # pylint: disable=incomplete-protocol
return {'type': self.type, 'name': self.name}
@staticmethod
- def from_json(tab):
+ def from_json(tab_dict):
"""
Deserializes a CourseTab from a json-like representation.
@@ -191,15 +197,15 @@ class CourseTab(object): # pylint: disable=incomplete-protocol
'instructor': InstructorTab, # not persisted
}
- tab_type = tab.get('type')
+ tab_type = tab_dict.get('type')
if tab_type not in sub_class_types:
raise InvalidTabsException(
'Unknown tab type {0}. Known types: {1}'.format(tab_type, sub_class_types)
)
- tab_class = sub_class_types[tab['type']]
- tab_class.validate(tab)
- return tab_class(tab=tab)
+ tab_class = sub_class_types[tab_dict['type']]
+ tab_class.validate(tab_dict)
+ return tab_class(tab_dict=tab_dict)
class AuthenticatedCourseTab(CourseTab):
@@ -218,14 +224,53 @@ class StaffTab(AuthenticatedCourseTab):
return is_user_staff
+class HideableTab(CourseTab):
+ """
+ Abstract class for tabs that are hideable
+ """
+ is_hideable = True
+
+ def __init__(self, name, tab_id, link_func, tab_dict):
+ super(HideableTab, self).__init__(
+ name=name,
+ tab_id=tab_id,
+ link_func=link_func,
+ )
+ self.is_hidden = tab_dict.get('is_hidden', False) if tab_dict else False
+
+ def __getitem__(self, key):
+ if key == 'is_hidden':
+ return self.is_hidden
+ else:
+ return super(HideableTab, self).__getitem__(key)
+
+ def __setitem__(self, key, value):
+ if key == 'is_hidden':
+ self.is_hidden = value
+ else:
+ super(HideableTab, self).__setitem__(key, value)
+
+ def to_json(self):
+ to_json_val = super(HideableTab, self).to_json()
+ if self.is_hidden:
+ to_json_val.update({'is_hidden': True})
+ return to_json_val
+
+ def __eq__(self, other):
+ if not super(HideableTab, self).__eq__(other):
+ return False
+ return self.is_hidden == other.get('is_hidden', False)
+
+
class CoursewareTab(CourseTab):
"""
A tab containing the course content.
"""
type = 'courseware'
+ is_movable = False
- def __init__(self, tab=None): # pylint: disable=unused-argument
+ def __init__(self, tab_dict=None): # pylint: disable=unused-argument
super(CoursewareTab, self).__init__(
# Translators: 'Courseware' refers to the tab in the courseware that leads to the content of a course
name=_('Courseware'), # support fixed name for the courseware tab
@@ -240,18 +285,19 @@ class CourseInfoTab(CourseTab):
"""
type = 'course_info'
+ is_movable = False
- def __init__(self, tab=None):
+ def __init__(self, tab_dict=None):
super(CourseInfoTab, self).__init__(
# Translators: "Course Info" is the name of the course's information and updates page
- name=tab['name'] if tab else _('Course Info'),
+ name=tab_dict['name'] if tab_dict else _('Course Info'),
tab_id='info',
link_func=link_reverse_func('info'),
)
@classmethod
- def validate(cls, tab, raise_error=True):
- return super(CourseInfoTab, cls).validate(tab, raise_error) and need_name(tab, raise_error)
+ def validate(cls, tab_dict, raise_error=True):
+ return super(CourseInfoTab, cls).validate(tab_dict, raise_error) and need_name(tab_dict, raise_error)
class ProgressTab(AuthenticatedCourseTab):
@@ -261,10 +307,10 @@ class ProgressTab(AuthenticatedCourseTab):
type = 'progress'
- def __init__(self, tab=None):
+ def __init__(self, tab_dict=None):
super(ProgressTab, self).__init__(
# Translators: "Progress" is the name of the student's course progress page
- name=tab['name'] if tab else _('Progress'),
+ name=tab_dict['name'] if tab_dict else _('Progress'),
tab_id=self.type,
link_func=link_reverse_func(self.type),
)
@@ -273,34 +319,32 @@ class ProgressTab(AuthenticatedCourseTab):
return not course.hide_progress_tab
@classmethod
- def validate(cls, tab, raise_error=True):
- return super(ProgressTab, cls).validate(tab, raise_error) and need_name(tab, raise_error)
+ def validate(cls, tab_dict, raise_error=True):
+ return super(ProgressTab, cls).validate(tab_dict, raise_error) and need_name(tab_dict, raise_error)
-class WikiTab(CourseTab):
+class WikiTab(HideableTab):
"""
- A tab containing the course wiki.
+ A tab_dict containing the course wiki.
"""
type = 'wiki'
- def __init__(self, tab=None):
- # LATER - enable the following flag to enable hiding of the Wiki page
- # self.is_hideable = True
-
+ def __init__(self, tab_dict=None):
super(WikiTab, self).__init__(
# Translators: "Wiki" is the name of the course's wiki page
- name=tab['name'] if tab else _('Wiki'),
+ name=tab_dict['name'] if tab_dict else _('Wiki'),
tab_id=self.type,
link_func=link_reverse_func('course_wiki'),
+ tab_dict=tab_dict,
)
def can_display(self, course, settings, is_user_authenticated, is_user_staff):
return settings.WIKI_ENABLED
@classmethod
- def validate(cls, tab, raise_error=True):
- return super(WikiTab, cls).validate(tab, raise_error) and need_name(tab, raise_error)
+ def validate(cls, tab_dict, raise_error=True):
+ return super(WikiTab, cls).validate(tab_dict, raise_error) and need_name(tab_dict, raise_error)
class DiscussionTab(CourseTab):
@@ -310,10 +354,10 @@ class DiscussionTab(CourseTab):
type = 'discussion'
- def __init__(self, tab=None):
+ def __init__(self, tab_dict=None):
super(DiscussionTab, self).__init__(
# Translators: "Discussion" is the title of the course forum page
- name=tab['name'] if tab else _('Discussion'),
+ name=tab_dict['name'] if tab_dict else _('Discussion'),
tab_id=self.type,
link_func=link_reverse_func('django_comment_client.forum.views.forum_form_discussion'),
)
@@ -322,8 +366,8 @@ class DiscussionTab(CourseTab):
return settings.FEATURES.get('ENABLE_DISCUSSION_SERVICE')
@classmethod
- def validate(cls, tab, raise_error=True):
- return super(DiscussionTab, cls).validate(tab, raise_error) and need_name(tab, raise_error)
+ def validate(cls, tab_dict, raise_error=True):
+ return super(DiscussionTab, cls).validate(tab_dict, raise_error) and need_name(tab_dict, raise_error)
class LinkTab(CourseTab):
@@ -363,8 +407,8 @@ class LinkTab(CourseTab):
return self.link_value == other.get('link')
@classmethod
- def validate(cls, tab, raise_error=True):
- return super(LinkTab, cls).validate(tab, raise_error) and key_checker(['link'])(tab, raise_error)
+ def validate(cls, tab_dict, raise_error=True):
+ return super(LinkTab, cls).validate(tab_dict, raise_error) and key_checker(['link'])(tab_dict, raise_error)
class ExternalDiscussionTab(LinkTab):
@@ -374,12 +418,12 @@ class ExternalDiscussionTab(LinkTab):
type = 'external_discussion'
- def __init__(self, tab=None, link_value=None):
+ def __init__(self, tab_dict=None, link_value=None):
super(ExternalDiscussionTab, self).__init__(
# Translators: 'Discussion' refers to the tab in the courseware that leads to the discussion forums
name=_('Discussion'),
tab_id='discussion',
- link_value=tab['link'] if tab else link_value,
+ link_value=tab_dict['link'] if tab_dict else link_value,
)
@@ -389,11 +433,11 @@ class ExternalLinkTab(LinkTab):
"""
type = 'external_link'
- def __init__(self, tab):
+ def __init__(self, tab_dict):
super(ExternalLinkTab, self).__init__(
- name=tab['name'],
+ name=tab_dict['name'],
tab_id=None, # External links are never active.
- link_value=tab['link'],
+ link_value=tab_dict['link'],
)
@@ -402,17 +446,15 @@ class StaticTab(CourseTab):
A custom tab.
"""
type = 'static_tab'
- url_slug = ''
@classmethod
- def validate(cls, tab, raise_error=True):
- return super(StaticTab, cls).validate(tab, raise_error) and key_checker(['name', 'url_slug'])(tab, raise_error)
+ def validate(cls, tab_dict, raise_error=True):
+ return super(StaticTab, cls).validate(tab_dict, raise_error) and key_checker(['name', 'url_slug'])(tab_dict, raise_error)
- def __init__(self, tab=None, name=None, url_slug=None):
- self.url_slug = tab['url_slug'] if tab else url_slug
- tab_name = tab['name'] if tab else name
+ def __init__(self, tab_dict=None, name=None, url_slug=None):
+ self.url_slug = tab_dict['url_slug'] if tab_dict else url_slug
super(StaticTab, self).__init__(
- name=tab_name,
+ name=tab_dict['name'] if tab_dict else name,
tab_id='static_tab_{0}'.format(self.url_slug),
link_func=lambda course, reverse_func: reverse_func(self.type, args=[course.id, self.url_slug]),
)
@@ -446,6 +488,8 @@ class SingleTextbookTab(CourseTab):
Textbook collection tab. It should not be serialized or persisted.
"""
type = 'single_textbook'
+ is_movable = False
+ is_collection_item = True
def to_json(self):
raise NotImplementedError('SingleTextbookTab should not be serialized.')
@@ -455,11 +499,18 @@ class TextbookTabsBase(AuthenticatedCourseTab):
"""
Abstract class for textbook collection tabs classes.
"""
- def __init__(self, tab=None): # pylint: disable=unused-argument
- super(TextbookTabsBase, self).__init__('', '', '')
+ is_collection = True
+
+ def __init__(self, tab_id):
+ # Translators: 'Textbooks' refers to the tab in the course that leads to the course' textbooks
+ super(TextbookTabsBase, self).__init__(
+ name=_("Textbooks"),
+ tab_id=tab_id,
+ link_func=None,
+ )
@abstractmethod
- def books(self, course):
+ def items(self, course):
"""
A generator for iterating through all the SingleTextbookTab book objects associated with this
collection of textbooks.
@@ -473,10 +524,15 @@ class TextbookTabs(TextbookTabsBase):
"""
type = 'textbooks'
+ def __init__(self, tab_dict=None): # pylint: disable=unused-argument
+ super(TextbookTabs, self).__init__(
+ tab_id=self.type,
+ )
+
def can_display(self, course, settings, is_user_authenticated, is_user_staff):
return settings.FEATURES.get('ENABLE_TEXTBOOK')
- def books(self, course):
+ def items(self, course):
for index, textbook in enumerate(course.textbooks):
yield SingleTextbookTab(
name=textbook.title,
@@ -491,7 +547,12 @@ class PDFTextbookTabs(TextbookTabsBase):
"""
type = 'pdf_textbooks'
- def books(self, course):
+ def __init__(self, tab_dict=None): # pylint: disable=unused-argument
+ super(PDFTextbookTabs, self).__init__(
+ tab_id=self.type,
+ )
+
+ def items(self, course):
for index, textbook in enumerate(course.pdf_textbooks):
yield SingleTextbookTab(
name=textbook['tab_title'],
@@ -506,7 +567,12 @@ class HtmlTextbookTabs(TextbookTabsBase):
"""
type = 'html_textbooks'
- def books(self, course):
+ def __init__(self, tab_dict=None): # pylint: disable=unused-argument
+ super(HtmlTextbookTabs, self).__init__(
+ tab_id=self.type,
+ )
+
+ def items(self, course):
for index, textbook in enumerate(course.html_textbooks):
yield SingleTextbookTab(
name=textbook['tab_title'],
@@ -528,7 +594,7 @@ class StaffGradingTab(StaffTab, GradingTab):
"""
type = 'staff_grading'
- def __init__(self, tab=None): # pylint: disable=unused-argument
+ def __init__(self, tab_dict=None): # pylint: disable=unused-argument
super(StaffGradingTab, self).__init__(
# Translators: "Staff grading" appears on a tab that allows
# staff to view open-ended problems that require staff grading
@@ -544,7 +610,7 @@ class PeerGradingTab(AuthenticatedCourseTab, GradingTab):
"""
type = 'peer_grading'
- def __init__(self, tab=None): # pylint: disable=unused-argument
+ def __init__(self, tab_dict=None): # pylint: disable=unused-argument
super(PeerGradingTab, self).__init__(
# Translators: "Peer grading" appears on a tab that allows
# students to view open-ended problems that require grading
@@ -560,7 +626,7 @@ class OpenEndedGradingTab(AuthenticatedCourseTab, GradingTab):
"""
type = 'open_ended'
- def __init__(self, tab=None): # pylint: disable=unused-argument
+ def __init__(self, tab_dict=None): # pylint: disable=unused-argument
super(OpenEndedGradingTab, self).__init__(
# Translators: "Open Ended Panel" appears on a tab that, when clicked, opens up a panel that
# displays information about open-ended problems that a user has submitted or needs to grade
@@ -579,7 +645,7 @@ class SyllabusTab(CourseTab):
def can_display(self, course, settings, is_user_authenticated, is_user_staff):
return hasattr(course, 'syllabus_present') and course.syllabus_present
- def __init__(self, tab=None): # pylint: disable=unused-argument
+ def __init__(self, tab_dict=None): # pylint: disable=unused-argument
super(SyllabusTab, self).__init__(
# Translators: "Syllabus" appears on a tab that, when clicked, opens the syllabus of the course.
name=_('Syllabus'),
@@ -597,16 +663,16 @@ class NotesTab(AuthenticatedCourseTab):
def can_display(self, course, settings, is_user_authenticated, is_user_staff):
return settings.FEATURES.get('ENABLE_STUDENT_NOTES')
- def __init__(self, tab=None):
+ def __init__(self, tab_dict=None):
super(NotesTab, self).__init__(
- name=tab['name'],
+ name=tab_dict['name'],
tab_id=self.type,
link_func=link_reverse_func(self.type),
)
@classmethod
- def validate(cls, tab, raise_error=True):
- return super(NotesTab, cls).validate(tab, raise_error) and need_name(tab, raise_error)
+ def validate(cls, tab_dict, raise_error=True):
+ return super(NotesTab, cls).validate(tab_dict, raise_error) and need_name(tab_dict, raise_error)
class InstructorTab(StaffTab):
@@ -615,7 +681,7 @@ class InstructorTab(StaffTab):
"""
type = 'instructor'
- def __init__(self, tab=None): # pylint: disable=unused-argument
+ def __init__(self, tab_dict=None): # pylint: disable=unused-argument
super(InstructorTab, self).__init__(
# Translators: 'Instructor' appears on the tab that leads to the instructor dashboard, which is
# a portal where an instructor can get data and perform various actions on their course
@@ -681,36 +747,68 @@ class CourseTabList(List):
return None
@staticmethod
- def get_tab_by_slug(course, url_slug):
+ def get_tab_by_slug(tab_list, url_slug):
"""
Look for a tab with the specified 'url_slug'. Returns the tab or None if not found.
"""
- for tab in course.tabs:
- # The validation code checks that these exist.
- if tab.get('url_slug') == url_slug:
- return tab
- return None
+ return next((tab for tab in tab_list if tab.get('url_slug') == url_slug), None)
@staticmethod
- def iterate_displayable(course, settings, is_user_authenticated=True, is_user_staff=True, include_instructor_tab=False):
+ def get_tab_by_type(tab_list, tab_type):
+ """
+ Look for a tab with the specified type. Returns the first matching tab.
+ """
+ return next((tab for tab in tab_list if tab.type == tab_type), None)
+
+ @staticmethod
+ def get_tab_by_id(tab_list, tab_id):
+ """
+ Look for a tab with the specified tab_id. Returns the first matching tab.
+ """
+ return next((tab for tab in tab_list if tab.tab_id == tab_id), None)
+
+ @staticmethod
+ def iterate_displayable(
+ course,
+ settings,
+ is_user_authenticated=True,
+ is_user_staff=True,
+ ):
"""
Generator method for iterating through all tabs that can be displayed for the given course and
the given user with the provided access settings.
"""
for tab in course.tabs:
- if tab.can_display(course, settings, is_user_authenticated, is_user_staff):
- if isinstance(tab, TextbookTabsBase):
- for book in tab.books(course):
- yield book
+ if tab.can_display(
+ course, settings, is_user_authenticated, is_user_staff
+ ) and (not tab.is_hideable or not tab.is_hidden):
+ if tab.is_collection:
+ for item in tab.items(course):
+ yield item
else:
yield tab
- if include_instructor_tab:
- instructor_tab = InstructorTab()
- if instructor_tab.can_display(course, settings, is_user_authenticated, is_user_staff):
- yield instructor_tab
+ instructor_tab = InstructorTab()
+ if instructor_tab.can_display(course, settings, is_user_authenticated, is_user_staff):
+ yield instructor_tab
+
+ @staticmethod
+ def iterate_displayable_cms(
+ course,
+ settings
+ ):
+ """
+ Generator method for iterating through all tabs that can be displayed for the given course
+ with the provided settings.
+ """
+ for tab in course.tabs:
+ if tab.can_display(course, settings, is_user_authenticated=True, is_user_staff=True):
+ if tab.is_collection and not len(list(tab.items(course))):
+ # do not yield collections that have no items
+ continue
+ yield tab
@classmethod
- def _validate_tabs(cls, tabs):
+ def validate_tabs(cls, tabs):
"""
Check that the tabs set for the specified course is valid. If it
isn't, raise InvalidTabsException with the complaint.
@@ -776,8 +874,8 @@ class CourseTabList(List):
"""
Overrides the from_json method to de-serialize the CourseTab objects from a json-like representation.
"""
- self._validate_tabs(values)
- return [CourseTab.from_json(tab) for tab in values]
+ self.validate_tabs(values)
+ return [CourseTab.from_json(tab_dict) for tab_dict in values]
#### Link Functions
@@ -833,3 +931,10 @@ class InvalidTabsException(Exception):
A complaint about invalid tabs.
"""
pass
+
+
+class UnequalTabsException(Exception):
+ """
+ A complaint about tab lists being unequal
+ """
+ pass
diff --git a/common/lib/xmodule/xmodule/tests/test_tabs.py b/common/lib/xmodule/xmodule/tests/test_tabs.py
index d41580c881..311cced077 100644
--- a/common/lib/xmodule/xmodule/tests/test_tabs.py
+++ b/common/lib/xmodule/xmodule/tests/test_tabs.py
@@ -14,6 +14,16 @@ class TabTestCase(unittest.TestCase):
self.settings = MagicMock()
self.settings.FEATURES = {}
self.reverse = lambda name, args: "name/{0}/args/{1}".format(name, ",".join(str(a) for a in args))
+ self.books = None
+
+ def set_up_books(self, num_books):
+ """Initializes the textbooks in the course and adds the given number of books to each textbook"""
+ self.books = [MagicMock() for _ in range(num_books)]
+ for book_index, book in enumerate(self.books):
+ book.title = 'Book{0}'.format(book_index)
+ self.course.textbooks = self.books
+ self.course.pdf_textbooks = self.books
+ self.course.html_textbooks = self.books
def check_tab(
self,
@@ -57,22 +67,30 @@ class TabTestCase(unittest.TestCase):
self.check_get_and_set_methods(tab)
# check to_json and from_json methods
- serialized_tab = tab.to_json()
- deserialized_tab = tab_class.from_json(serialized_tab)
- self.assertEquals(serialized_tab, deserialized_tab)
+ self.check_tab_json_methods(tab)
# check equality methods
+ self.check_tab_equality(tab, dict_tab)
+
+ # return tab for any additional tests
+ return tab
+
+ def check_tab_equality(self, tab, dict_tab):
+ """Tests the equality methods on the given tab"""
self.assertEquals(tab, dict_tab) # test __eq__
ne_dict_tab = dict_tab
ne_dict_tab['type'] = 'fake_type'
self.assertNotEquals(tab, ne_dict_tab) # test __ne__: incorrect type
self.assertNotEquals(tab, {'fake_key': 'fake_value'}) # test __ne__: missing type
- # return tab for any additional tests
- return tab
+ def check_tab_json_methods(self, tab):
+ """Tests the json from and to methods on the given tab"""
+ serialized_tab = tab.to_json()
+ deserialized_tab = tab.from_json(serialized_tab)
+ self.assertEquals(serialized_tab, deserialized_tab)
def check_can_display_results(self, tab, expected_value=True, for_authenticated_users_only=False, for_staff_only=False):
- """Check can display results for various users"""
+ """Checks can display results for various users"""
if for_staff_only:
self.assertEquals(
expected_value,
@@ -90,7 +108,7 @@ class TabTestCase(unittest.TestCase):
)
def check_get_and_set_methods(self, tab):
- """test __getitem__ and __setitem__ calls"""
+ """Test __getitem__ and __setitem__ calls"""
self.assertEquals(tab['type'], tab.type)
self.assertEquals(tab['tab_id'], tab.tab_id)
with self.assertRaises(KeyError):
@@ -102,7 +120,7 @@ class TabTestCase(unittest.TestCase):
tab['invalid_key'] = 'New Value'
def check_get_and_set_method_for_key(self, tab, key):
- """test __getitem__ and __setitem__ for the given key"""
+ """Test __getitem__ and __setitem__ for the given key"""
old_value = tab[key]
new_value = 'New Value'
tab[key] = new_value
@@ -149,17 +167,31 @@ class WikiTestCase(TabTestCase):
)
def test_wiki_enabled(self):
+ """Test wiki tab when Enabled setting is True"""
self.settings.WIKI_ENABLED = True
tab = self.check_wiki_tab()
self.check_can_display_results(tab)
def test_wiki_enabled_false(self):
+ """Test wiki tab when Enabled setting is False"""
self.settings.WIKI_ENABLED = False
tab = self.check_wiki_tab()
self.check_can_display_results(tab, expected_value=False)
+ def test_wiki_visibility(self):
+ """Test toggling of visibility of wiki tab"""
+
+ wiki_tab = tabs.WikiTab()
+ self.assertTrue(wiki_tab.is_hideable)
+ wiki_tab.is_hidden = True
+ self.assertTrue(wiki_tab['is_hidden'])
+ self.check_tab_json_methods(wiki_tab)
+ self.check_tab_equality(wiki_tab, wiki_tab.to_json())
+ wiki_tab['is_hidden'] = False
+ self.assertFalse(wiki_tab.is_hidden)
+
class ExternalLinkTestCase(TabTestCase):
"""Test cases for External Link Tab."""
@@ -202,15 +234,9 @@ class TextbooksTestCase(TabTestCase):
def setUp(self):
super(TextbooksTestCase, self).setUp()
+ self.set_up_books(2)
+
self.dict_tab = MagicMock()
- book1 = MagicMock()
- book2 = MagicMock()
- book1.title = 'Book1: Algebra'
- book2.title = 'Book2: Topology'
- books = [book1, book2]
- self.course.textbooks = books
- self.course.pdf_textbooks = books
- self.course.html_textbooks = books
self.course.tabs = [
tabs.CoursewareTab(),
tabs.CourseInfoTab(),
@@ -219,7 +245,7 @@ class TextbooksTestCase(TabTestCase):
tabs.HtmlTextbookTabs(),
]
self.num_textbook_tabs = sum(1 for tab in self.course.tabs if isinstance(tab, tabs.TextbookTabsBase))
- self.num_textbooks = self.num_textbook_tabs * len(books)
+ self.num_textbooks = self.num_textbook_tabs * len(self.books)
def test_textbooks_enabled(self):
@@ -233,7 +259,7 @@ class TextbooksTestCase(TabTestCase):
book_type, book_index = tab.tab_id.split("/", 1)
expected_link = self.reverse(type_to_reverse_name[book_type], args=[self.course.id, book_index])
self.assertEqual(tab.link_func(self.course, self.reverse), expected_link)
- self.assertTrue(tab.name.startswith('Book{0}:'.format(1 + int(book_index))))
+ self.assertTrue(tab.name.startswith('Book{0}'.format(book_index)))
num_textbooks_found = num_textbooks_found + 1
self.assertEquals(num_textbooks_found, self.num_textbooks)
@@ -381,10 +407,11 @@ class NeedNameTestCase(unittest.TestCase):
tabs.need_name(self.invalid_dict)
-class ValidateTabsTestCase(unittest.TestCase):
- """Test cases for validating tabs."""
+class TabListTestCase(TabTestCase):
+ """Base class for Test cases involving tab lists."""
def setUp(self):
+ super(TabListTestCase, self).setUp()
# invalid tabs
self.invalid_tabs = [
@@ -447,6 +474,12 @@ class ValidateTabsTestCase(unittest.TestCase):
],
]
+ self.all_valid_tab_list = tabs.CourseTabList().from_json(self.valid_tabs[1])
+
+
+class ValidateTabsTestCase(TabListTestCase):
+ """Test cases for validating tabs."""
+
def test_validate_tabs(self):
tab_list = tabs.CourseTabList()
for invalid_tab_list in self.invalid_tabs:
@@ -458,7 +491,7 @@ class ValidateTabsTestCase(unittest.TestCase):
self.assertEquals(len(from_json_result), len(valid_tab_list))
-class CourseTabListTestCase(TabTestCase):
+class CourseTabListTestCase(TabListTestCase):
"""Testing the generator method for iterating through displayable tabs"""
def test_initialize_default_without_syllabus(self):
@@ -488,23 +521,64 @@ class CourseTabListTestCase(TabTestCase):
self.assertTrue(tabs.DiscussionTab() in self.course.tabs)
def test_iterate_displayable(self):
+ # enable all tab types
self.settings.FEATURES['ENABLE_TEXTBOOK'] = True
- self.course.tabs = [
- tabs.CoursewareTab(),
- tabs.CourseInfoTab(),
- tabs.WikiTab(),
- ]
+ self.settings.FEATURES['ENABLE_DISCUSSION_SERVICE'] = True
+ self.settings.FEATURES['ENABLE_STUDENT_NOTES'] = True
+ self.course.hide_progress_tab = False
+ # create 1 book per textbook type
+ self.set_up_books(1)
+
+ # initialize the course tabs to a list of all valid tabs
+ self.course.tabs = self.all_valid_tab_list
+
+ # enumerate the tabs using the CMS call
+ for i, tab in enumerate(tabs.CourseTabList.iterate_displayable_cms(
+ self.course,
+ self.settings,
+ )):
+ self.assertEquals(tab.type, self.course.tabs[i].type)
+
+ # enumerate the tabs and verify textbooks and the instructor tab
for i, tab in enumerate(tabs.CourseTabList.iterate_displayable(
self.course,
self.settings,
- include_instructor_tab=True,
)):
- if i == len(self.course.tabs):
+ if getattr(tab, 'is_collection_item', False):
+ # a collection item was found as a result of a collection tab
+ self.assertTrue(getattr(self.course.tabs[i], 'is_collection', False))
+ elif i == len(self.course.tabs):
+ # the last tab must be the Instructor tab
self.assertEquals(tab.type, tabs.InstructorTab.type)
else:
+ # all other tabs must match the expected type
self.assertEquals(tab.type, self.course.tabs[i].type)
+ # test including non-empty collections
+ self.assertIn(
+ tabs.HtmlTextbookTabs(),
+ list(tabs.CourseTabList.iterate_displayable_cms(self.course, self.settings)),
+ )
+
+ # test not including empty collections
+ self.course.html_textbooks = []
+ self.assertNotIn(
+ tabs.HtmlTextbookTabs(),
+ list(tabs.CourseTabList.iterate_displayable_cms(self.course, self.settings)),
+ )
+
+ def test_get_tab_by_methods(self):
+ """Tests the get_tab methods in CourseTabList"""
+ self.course.tabs = self.all_valid_tab_list
+ for tab in self.course.tabs:
+
+ # get tab by type
+ self.assertEquals(tabs.CourseTabList.get_tab_by_type(self.course.tabs, tab.type), tab)
+
+ # get tab by id
+ self.assertEquals(tabs.CourseTabList.get_tab_by_id(self.course.tabs, tab.tab_id), tab)
+
class DiscussionLinkTestCase(TabTestCase):
"""Test cases for discussion link tab."""
@@ -526,7 +600,7 @@ class DiscussionLinkTestCase(TabTestCase):
@staticmethod
def _reverse(course):
- """custom reverse function"""
+ """Custom reverse function"""
def reverse_discussion_link(viewname, args):
"""reverse lookup for discussion link"""
if viewname == "django_comment_client.forum.views.forum_form_discussion" and args == [course.id]:
diff --git a/lms/djangoapps/courseware/tests/test_tabs.py b/lms/djangoapps/courseware/tests/test_tabs.py
index 51a2dd5b0d..f69c1a83eb 100644
--- a/lms/djangoapps/courseware/tests/test_tabs.py
+++ b/lms/djangoapps/courseware/tests/test_tabs.py
@@ -45,7 +45,7 @@ class StaticTabDateTestCase(LoginEnrollmentTestCase, ModuleStoreTestCase):
def test_get_static_tab_contents(self):
course = get_course_by_id('edX/toy/2012_Fall')
request = get_request_for_user(UserFactory.create())
- tab = CourseTabList.get_tab_by_slug(course, 'resources')
+ tab = CourseTabList.get_tab_by_slug(course.tabs, 'resources')
# Test render works okay
tab_content = get_static_tab_contents(request, course, tab)
diff --git a/lms/djangoapps/courseware/views.py b/lms/djangoapps/courseware/views.py
index 854ba5e5f6..9ee7a700a6 100644
--- a/lms/djangoapps/courseware/views.py
+++ b/lms/djangoapps/courseware/views.py
@@ -482,7 +482,7 @@ def static_tab(request, course_id, tab_slug):
"""
course = get_course_with_access(request.user, course_id, 'load')
- tab = CourseTabList.get_tab_by_slug(course, tab_slug)
+ tab = CourseTabList.get_tab_by_slug(course.tabs, tab_slug)
if tab is None:
raise Http404
diff --git a/lms/envs/common.py b/lms/envs/common.py
index 4cef6a88d6..e61ee8740d 100644
--- a/lms/envs/common.py
+++ b/lms/envs/common.py
@@ -76,10 +76,11 @@ FEATURES = {
'FORCE_UNIVERSITY_DOMAIN': False, # set this to the university domain to use, as an override to HTTP_HOST
# set to None to do no university selection
- 'ENABLE_TEXTBOOK': True,
-
- # for consistency in user-experience, keep the value of this setting in sync with the one in cms/envs/common.py
+ # for consistency in user-experience, keep the value of the following 3 settings
+ # in sync with the corresponding ones in cms/envs/common.py
'ENABLE_DISCUSSION_SERVICE': True,
+ 'ENABLE_TEXTBOOK': True,
+ 'ENABLE_STUDENT_NOTES': True, # enables the student notes API and UI.
# discussion home panel, which includes a subscription on/off setting for discussion digest emails.
# this should remain off in production until digest notifications are online.
@@ -146,9 +147,6 @@ FEATURES = {
# segment.io for LMS--need to explicitly turn it on for production.
'SEGMENT_IO_LMS': False,
- # Enables the student notes API and UI.
- 'ENABLE_STUDENT_NOTES': True,
-
# Provide a UI to allow users to submit feedback from the LMS (left-hand help modal)
'ENABLE_FEEDBACK_SUBMISSION': False,
diff --git a/lms/templates/courseware/course_navigation.html b/lms/templates/courseware/course_navigation.html
index 7ce6075aee..de27004e4c 100644
--- a/lms/templates/courseware/course_navigation.html
+++ b/lms/templates/courseware/course_navigation.html
@@ -23,7 +23,7 @@ def url_class(is_active):
-
+
-
- --
${_(tab.name)}
----
+ % for tab in tabs_to_render:
+ <%
+ css_class = "course-tab"
+ if tab.is_movable:
+ css_class = css_class + " is-movable"
+ elif (not tab.is_movable) and (not tab.is_hideable):
+ css_class = css_class + " is-fixed"
+ %>
- % if tab.is_hideable:
-
- - - - - - %endif + % if isinstance(tab, StaticTab): + -
- ${_("Fixed page")} --
+ % else:
+ -
+ + + % if tab.is_collection: + ++ +
${_(tab.name)}
+-
+ % for item in tab.items(context_course):
+
- + ${_(item.name)} + + % endfor +
${_(tab.name)}
+ % endif +++ + % if tab.is_movable: +-
+
+ % if tab.is_hideable:
+
- + + % if tab.is_hidden: + + % else: + + % endif + + + % endif + +
+ ${_("Drag to reorder")} ++ % else: ++ ${_("This page cannot be reordered")} ++ % endif +
+
+ % endif
% endfor
- % for locator in components:
-
- % endfor
-
- - - - +
-
- % for tab in built_in_tabs:
-