self.load_extra_content(
- system, course_descriptor, 'static_tab',
+ system, course_block, 'static_tab',
self.data_dir / course_dir / 'tabs',
course_dir, url_name
)
self.load_extra_content(
- system, course_descriptor, 'custom_tag_template',
+ system, course_block, 'custom_tag_template',
self.data_dir / course_dir / 'custom_tags',
course_dir, url_name
)
self.load_extra_content(
- system, course_descriptor, 'about',
+ system, course_block, 'about',
self.data_dir / course_dir / 'about',
course_dir, url_name
)
@@ -587,14 +587,14 @@ def get_id(org, course, url_name):
# always used, preventing duplicate keys.
return CourseKey.from_string('/'.join([org, course, url_name]))
- def load_extra_content(self, system, course_descriptor, category, base_dir, course_dir, url_name): # lint-amnesty, pylint: disable=missing-function-docstring
- self._load_extra_content(system, course_descriptor, category, base_dir, course_dir)
+ def load_extra_content(self, system, course_block, category, base_dir, course_dir, url_name): # lint-amnesty, pylint: disable=missing-function-docstring
+ self._load_extra_content(system, course_block, category, base_dir, course_dir)
# then look in a override folder based on the course run
if os.path.isdir(base_dir / url_name):
- self._load_extra_content(system, course_descriptor, category, base_dir / url_name, course_dir)
+ self._load_extra_content(system, course_block, category, base_dir / url_name, course_dir)
- def _import_field_content(self, course_descriptor, category, file_path):
+ def _import_field_content(self, course_block, category, file_path):
"""
Import field data content for field other than 'data' or 'metadata' form json file and
return field data content as dictionary
@@ -606,7 +606,7 @@ def _import_field_content(self, course_descriptor, category, file_path):
dirname, field, file_suffix = file_path.split('/')[-1].split('.')
if file_suffix == 'json' and field not in DEFAULT_CONTENT_FIELDS:
slug = os.path.splitext(os.path.basename(dirname))[0]
- location = course_descriptor.scope_ids.usage_id.replace(category=category, name=slug)
+ location = course_block.scope_ids.usage_id.replace(category=category, name=slug)
with open(file_path) as field_content_file:
field_data = json.load(field_content_file)
data_content = {field: field_data}
@@ -618,7 +618,7 @@ def _import_field_content(self, course_descriptor, category, file_path):
return slug, location, data_content
- def _load_extra_content(self, system, course_descriptor, category, content_path, course_dir):
+ def _load_extra_content(self, system, course_block, category, content_path, course_dir):
"""
Import fields data content from files
"""
@@ -633,7 +633,7 @@ def _load_extra_content(self, system, course_descriptor, category, content_path,
try:
if filepath.find('.json') != -1:
# json file with json data content
- slug, loc, data_content = self._import_field_content(course_descriptor, category, filepath)
+ slug, loc, data_content = self._import_field_content(course_block, category, filepath)
if data_content is None:
continue
else:
@@ -649,7 +649,7 @@ def _load_extra_content(self, system, course_descriptor, category, content_path,
data_content['category'] = category
else:
slug = os.path.splitext(os.path.basename(filepath))[0]
- loc = course_descriptor.scope_ids.usage_id.replace(category=category, name=slug)
+ loc = course_block.scope_ids.usage_id.replace(category=category, name=slug)
# html file with html data content
html = f.read()
try:
@@ -663,7 +663,7 @@ def _load_extra_content(self, system, course_descriptor, category, content_path,
if block is None:
block = system.construct_xblock(
category,
- # We're loading a descriptor, so student_id is meaningless
+ # We're loading a block, so student_id is meaningless
# We also don't have separate notions of definition and usage ids yet,
# so we use the location for both
ScopeIds(None, category, loc, loc),
@@ -673,14 +673,14 @@ def _load_extra_content(self, system, course_descriptor, category, content_path,
# Hack because we need to pull in the 'display_name' for static tabs (because we need to edit them) # lint-amnesty, pylint: disable=line-too-long
# from the course policy
if category == "static_tab":
- tab = CourseTabList.get_tab_by_slug(tab_list=course_descriptor.tabs, url_slug=slug)
+ tab = CourseTabList.get_tab_by_slug(tab_list=course_block.tabs, url_slug=slug)
if tab:
block.display_name = tab.name
block.course_staff_only = tab.course_staff_only
block.data_dir = course_dir
block.save()
- self.modules[course_descriptor.id][block.scope_ids.usage_id] = block
+ self.modules[course_block.id][block.scope_ids.usage_id] = block
except Exception as exc: # pylint: disable=broad-except
logging.exception("Failed to load %s. Skipping... \
Exception: %s", filepath, str(exc))
@@ -712,7 +712,7 @@ def get_item(self, usage_key, depth=0, **kwargs): # lint-amnesty, pylint: disab
def get_items(self, course_id, settings=None, content=None, revision=None, qualifiers=None, **kwargs): # lint-amnesty, pylint: disable=arguments-differ
"""
Returns:
- list of XModuleDescriptor instances for the matching items within the course with
+ list of XBlock instances for the matching items within the course with
the given course_id
NOTE: don't use this to look for courses
@@ -737,7 +737,7 @@ def get_items(self, course_id, settings=None, content=None, revision=None, quali
if revision == ModuleStoreEnum.RevisionOption.draft_only:
return []
- items = []
+ blocks = []
qualifiers = qualifiers.copy() if qualifiers else {} # copy the qualifiers (destructively manipulated here)
category = qualifiers.pop('category', None)
@@ -760,9 +760,9 @@ def _block_matches_all(block_loc, block):
for block_loc, block in self.modules[course_id].items():
if _block_matches_all(block_loc, block):
- items.append(block)
+ blocks.append(block)
- return items
+ return blocks
def make_course_key(self, org, course, run):
"""
@@ -782,7 +782,7 @@ def make_course_usage_key(self, course_key):
def get_courses(self, **kwargs):
"""
- Returns a list of course descriptors. If there were errors on loading,
+ Returns a list of course blocks. If there were errors on loading,
some of these may be ErrorBlock instead.
"""
return list(self.courses.values())
@@ -900,26 +900,26 @@ def get_id(org, library, url_name): # lint-amnesty, pylint: disable=arguments-d
return LibraryLocator(org=org, library=library)
@staticmethod
- def patch_descriptor_kvs(library_descriptor):
+ def patch_block_kvs(library_block):
"""
Metadata inheritance can be done purely through XBlocks, but in the import phase
a root block with an InheritanceKeyValueStore is assumed to be at the top of the hierarchy.
This should change in the future, but as XBlocks don't have this KVS, we have to patch it
here manually.
"""
- init_dict = {key: getattr(library_descriptor, key) for key in library_descriptor.fields.keys()}
+ init_dict = {key: getattr(library_block, key) for key in library_block.fields.keys()}
# if set, invalidate '_unwrapped_field_data' so it will be reset
# the next time it will be called
- lazy.invalidate(library_descriptor, '_unwrapped_field_data')
+ lazy.invalidate(library_block, '_unwrapped_field_data')
# pylint: disable=protected-access
- library_descriptor._field_data = inheriting_field_data(InheritanceKeyValueStore(init_dict))
+ library_block._field_data = inheriting_field_data(InheritanceKeyValueStore(init_dict))
- def content_importers(self, system, course_descriptor, course_dir, url_name):
+ def content_importers(self, system, course_block, course_dir, url_name):
"""
Handle Metadata inheritance for Libraries.
"""
- self.patch_descriptor_kvs(course_descriptor)
- compute_inherited_metadata(course_descriptor)
+ self.patch_block_kvs(course_block)
+ compute_inherited_metadata(course_block)
def get_library(self, library_id, depth=0, **kwargs): # pylint: disable=unused-argument
"""
@@ -932,11 +932,11 @@ def get_library(self, library_id, depth=0, **kwargs): # pylint: disable=unused-
return None
@staticmethod
- def id_from_descriptor(descriptor):
+ def id_from_block(block):
"""
- Get the Library Key from the Library descriptor.
+ Get the Library Key from the Library block.
"""
- return descriptor.location.library_key
+ return block.location.library_key
def get_orphans(self, course_key, **kwargs):
"""
diff --git a/xmodule/modulestore/xml_exporter.py b/xmodule/modulestore/xml_exporter.py
index 5085bfe6e938..6f7b142a6714 100644
--- a/xmodule/modulestore/xml_exporter.py
+++ b/xmodule/modulestore/xml_exporter.py
@@ -111,7 +111,7 @@ def __init__(self, modulestore, contentstore, courselike_key, root_dir, target_d
`modulestore`: A `ModuleStore` object that is the source of the blocks to export
`contentstore`: A `ContentStore` object that is the source of the content to export, can be None
- `courselike_key`: The Locator of the Descriptor to export
+ `courselike_key`: The Locator of the block to export
`root_dir`: The directory to write the exported xml to
`target_dir`: The name of the directory inside `root_dir` to write the content to
"""
diff --git a/xmodule/modulestore/xml_importer.py b/xmodule/modulestore/xml_importer.py
index 2ab68f5d4050..45023b1a1a07 100644
--- a/xmodule/modulestore/xml_importer.py
+++ b/xmodule/modulestore/xml_importer.py
@@ -457,7 +457,7 @@ def get_dest_id(self, courselike_key):
@abstractmethod
def get_courselike(self, courselike_key, runtime, dest_id):
"""
- Given a key, a runtime, and an intended destination key, get the descriptor for the courselike
+ Given a key, a runtime, and an intended destination key, get the block for the courselike
we'll be importing into.
"""
raise NotImplementedError
@@ -739,7 +739,7 @@ def get_dest_id(self, courselike_key):
def get_courselike(self, courselike_key, runtime, dest_id):
"""
- Get the descriptor of the library from the XML import modulestore.
+ Get the block of the library from the XML import modulestore.
"""
source_library = self.xml_module_store.get_library(courselike_key)
library, library_data_path = self.import_courselike(
@@ -974,7 +974,7 @@ def _import_block(block):
# in the list of children since they would have been
# filtered out from the non-draft store export.
if parent_url is not None and index is not None:
- course_key = descriptor.location.course_key
+ course_key = block.location.course_key
parent_location = UsageKey.from_string(parent_url).map_into_course(course_key)
# IMPORTANT: Be sure to update the parent in the NEW namespace
@@ -1018,7 +1018,7 @@ def _import_block(block):
# Therefore only process verticals at the unit level, assuming that any other
# verticals must be descendants.
if 'index_in_children_list' in xml:
- descriptor = system.process_xml(xml)
+ block = system.process_xml(xml)
# HACK: since we are doing partial imports of drafts
# the vertical doesn't have the 'url-name' set in the
@@ -1026,14 +1026,14 @@ def _import_block(block):
# aka sequential), so we have to replace the location.name
# with the XML filename that is part of the pack
filename, __ = os.path.splitext(filename)
- descriptor.location = descriptor.location.replace(name=filename)
+ block.location = block.location.replace(name=filename)
- index = index_in_children_list(descriptor)
- parent_url = get_parent_url(descriptor, xml)
- draft_url = str(descriptor.location)
+ index = index_in_children_list(block)
+ parent_url = get_parent_url(block, xml)
+ draft_url = str(block.location)
draft = draft_node_constructor(
- block=descriptor, url=draft_url, parent_url=parent_url, index=index
+ block=block, url=draft_url, parent_url=parent_url, index=index
)
drafts.append(draft)
@@ -1047,7 +1047,7 @@ def _import_block(block):
try:
_import_block(draft.module)
except Exception: # pylint: disable=broad-except
- logging.exception(f'Course import {source_course_id}: while importing draft descriptor {draft.module}')
+ logging.exception(f'Course import {source_course_id}: while importing draft block {draft.module}')
def allowed_metadata_by_category(category):
diff --git a/xmodule/randomize_block.py b/xmodule/randomize_block.py
index 6c17804b11bc..c5e1f2c4747f 100644
--- a/xmodule/randomize_block.py
+++ b/xmodule/randomize_block.py
@@ -85,7 +85,7 @@ def child(self):
return child
- def get_child_descriptors(self):
+ def get_child_blocks(self):
"""
For grading--return just the chosen child.
"""
@@ -99,7 +99,7 @@ def student_view(self, context):
The student view.
"""
if self.child is None:
- # raise error instead? In fact, could complain on descriptor load...
+ # raise error instead? In fact, could complain on block load...
return Fragment(content="Nothing to randomize between
")
return self.child.render(STUDENT_VIEW, context)
@@ -120,6 +120,6 @@ def definition_to_xml(self, resource_fs):
def has_dynamic_children(self):
"""
Grading needs to know that only one of the children is actually "real". This
- makes it use block.get_child_descriptors().
+ makes it use block.get_child_blocks().
"""
return True
diff --git a/xmodule/services.py b/xmodule/services.py
index c4d00a73906e..595c8082fb5a 100644
--- a/xmodule/services.py
+++ b/xmodule/services.py
@@ -190,7 +190,7 @@ def rebind_noauth_module_to_user(self, block, real_user):
log.error(err_msg)
raise RebindUserServiceError(err_msg)
- field_data_cache_real_user = FieldDataCache.cache_for_descriptor_descendents(
+ field_data_cache_real_user = FieldDataCache.cache_for_block_descendents(
self.course_id,
real_user,
block,
diff --git a/xmodule/split_test_block.py b/xmodule/split_test_block.py
index c60d72c863ed..c45848800fb3 100644
--- a/xmodule/split_test_block.py
+++ b/xmodule/split_test_block.py
@@ -177,13 +177,13 @@ class SplitTestBlock( # lint-amnesty, pylint: disable=abstract-method
}
@cached_property
- def child_descriptor(self):
+ def child_block(self):
"""
Return the child block for the partition or None.
"""
- child_descriptors = self.get_child_descriptors()
- if len(child_descriptors) >= 1:
- return child_descriptors[0]
+ child_blocks = self.get_child_blocks()
+ if len(child_blocks) >= 1:
+ return child_blocks[0]
return None
@cached_property
@@ -191,15 +191,15 @@ def child(self):
"""
Return the user bound child block for the partition or None.
"""
- if self.child_descriptor is not None:
- return self.runtime.get_block_for_descriptor(self.child_descriptor)
+ if self.child_block is not None:
+ return self.runtime.get_block_for_descriptor(self.child_block)
else:
return None
- def get_child_descriptor_by_location(self, location):
+ def get_child_block_by_location(self, location):
"""
Look through the children and look for one with the given location.
- Returns the descriptor.
+ Returns the block.
If none match, return None
"""
for child in self.get_children():
@@ -227,7 +227,7 @@ def get_content_titles(self):
"""
return self.child.get_content_titles()
- def get_child_descriptors(self):
+ def get_child_blocks(self):
"""
For grading--return just the chosen child.
"""
@@ -239,19 +239,19 @@ def get_child_descriptors(self):
str_group_id = str(group_id)
if str_group_id in self.group_id_to_child:
child_location = self.group_id_to_child[str_group_id]
- child_descriptor = self.get_child_descriptor_by_location(child_location)
+ child_block = self.get_child_block_by_location(child_location)
else:
# Oops. Config error.
log.debug("configuration error in split test block: invalid group_id %r (not one of %r). Showing error", str_group_id, list(self.group_id_to_child.keys())) # lint-amnesty, pylint: disable=line-too-long
- if child_descriptor is None:
- # Peak confusion is great. Now that we set child_descriptor,
+ if child_block is None:
+ # Peak confusion is great. Now that we set child_block,
# get_children() should return a list with one element--the
# xmodule for the child
log.debug("configuration error in split test block: no such child")
return []
- return [child_descriptor]
+ return [child_block]
def get_group_id(self):
"""
@@ -271,8 +271,8 @@ def _staff_view(self, context):
inactive_contents = []
for child_location in self.children: # pylint: disable=no-member
- child_descriptor = self.get_child_descriptor_by_location(child_location)
- child = self.runtime.get_block_for_descriptor(child_descriptor)
+ child_block = self.get_child_block_by_location(child_location)
+ child = self.runtime.get_block_for_descriptor(child_block)
rendered_child = child.render(STUDENT_VIEW, context)
fragment.add_fragment_resources(rendered_child)
group_name, updated_group_id = self.get_data_for_vertical(child)
@@ -346,8 +346,8 @@ def studio_render_children(self, fragment, children, context):
dependencies are added to the specified fragment.
"""
html = ""
- for active_child_descriptor in children:
- active_child = self.runtime.get_block_for_descriptor(active_child_descriptor)
+ for active_child_block in children:
+ active_child = self.runtime.get_block_for_descriptor(active_child_block)
rendered_child = active_child.render(StudioEditableBlock.get_preview_view_name(active_child), context)
if active_child.category == 'vertical':
group_name, group_id = self.get_data_for_vertical(active_child)
@@ -378,7 +378,7 @@ def student_view(self, context):
conditions for staff.
"""
if self.child is None:
- # raise error instead? In fact, could complain on descriptor load...
+ # raise error instead? In fact, could complain on block load...
return Fragment(content="Nothing here. Move along.
")
if self.runtime.user_is_staff:
@@ -464,8 +464,8 @@ def definition_from_xml(cls, xml_object, system):
for child in xml_object:
try:
- descriptor = system.process_xml(etree.tostring(child))
- children.append(descriptor.scope_ids.usage_id)
+ block = system.process_xml(etree.tostring(child))
+ children.append(block.scope_ids.usage_id)
except Exception: # lint-amnesty, pylint: disable=broad-except
msg = "Unable to load child when parsing split_test block."
log.exception(msg)
@@ -486,7 +486,7 @@ def get_context(self):
def has_dynamic_children(self):
"""
Grading needs to know that only one of the children is actually "real". This
- makes it use block.get_child_descriptors().
+ makes it use block.get_child_blocks().
"""
return True
@@ -561,9 +561,9 @@ def active_and_inactive_children(self):
if not user_partition:
return [], children
- def get_child_descriptor(location):
+ def get_child_block(location):
"""
- Returns the child descriptor which matches the specified location, or None if one is not found.
+ Returns the child block which matches the specified location, or None if one is not found.
"""
for child in children:
if child.location == location:
@@ -575,7 +575,7 @@ def get_child_descriptor(location):
for group in user_partition.groups:
group_id = str(group.id)
child_location = self.group_id_to_child.get(group_id, None)
- child = get_child_descriptor(child_location)
+ child = get_child_block(child_location)
if child:
active_children.append(child)
diff --git a/xmodule/studio_editable.py b/xmodule/studio_editable.py
index 2795bf31bca8..844f0f446c37 100644
--- a/xmodule/studio_editable.py
+++ b/xmodule/studio_editable.py
@@ -51,8 +51,8 @@ def get_preview_view_name(block):
return AUTHOR_VIEW if has_author_view(block) else STUDENT_VIEW
-def has_author_view(descriptor):
+def has_author_view(block):
"""
- Returns True if the xmodule linked to the descriptor supports "author_view".
+ Returns True if the xmodule linked to the block supports "author_view".
"""
- return getattr(descriptor, 'has_author_view', False)
+ return getattr(block, 'has_author_view', False)
diff --git a/xmodule/templates.py b/xmodule/templates.py
index f019d5ee409e..550d84ae4391 100644
--- a/xmodule/templates.py
+++ b/xmodule/templates.py
@@ -21,13 +21,13 @@
def all_templates():
"""
- Returns all templates for enabled modules, grouped by descriptor type
+ Returns all templates for enabled modules, grouped by block type
"""
# TODO use memcache to memoize w/ expiration
templates = defaultdict(list)
- for category, descriptor in XBlock.load_classes():
- if not hasattr(descriptor, 'templates'):
+ for category, block in XBlock.load_classes():
+ if not hasattr(block, 'templates'):
continue
- templates[category] = descriptor.templates()
+ templates[category] = block.templates()
return templates
diff --git a/xmodule/tests/__init__.py b/xmodule/tests/__init__.py
index e31aee021615..2a903f6f0433 100644
--- a/xmodule/tests/__init__.py
+++ b/xmodule/tests/__init__.py
@@ -191,7 +191,7 @@ def prepare_block_runtime(
add_get_block=False,
):
"""
- Sets properties in the runtime of the specified descriptor that is
+ Sets properties in the runtime of the specified block that is
required for tests.
"""
diff --git a/xmodule/tests/test_capa_block.py b/xmodule/tests/test_capa_block.py
index 2e14b2b1c9e6..b13aae0839ad 100644
--- a/xmodule/tests/test_capa_block.py
+++ b/xmodule/tests/test_capa_block.py
@@ -2492,22 +2492,22 @@ class ProblemBlockXMLTest(unittest.TestCase): # lint-amnesty, pylint: disable=m
""")
- def _create_descriptor(self, xml, name=None):
+ def _create_block(self, xml, name=None):
""" Creates a ProblemBlock to run test against """
- descriptor = CapaFactory.create()
- descriptor.data = xml
+ block = CapaFactory.create()
+ block.data = xml
if name:
- descriptor.display_name = name
- return descriptor
+ block.display_name = name
+ return block
@ddt.data(*sorted(responsetypes.registry.registered_tags()))
def test_all_response_types(self, response_tag):
""" Tests that every registered response tag is correctly returned """
xml = "<{response_tag}>".format(response_tag=response_tag)
name = "Some Capa Problem"
- descriptor = self._create_descriptor(xml, name=name)
- assert descriptor.problem_types == {response_tag}
- assert descriptor.index_dictionary() ==\
+ block = self._create_block(xml, name=name)
+ assert block.problem_types == {response_tag}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': [response_tag],
'content': {'display_name': name, 'capa_content': ''}}
@@ -2528,9 +2528,9 @@ def test_response_types_ignores_non_response_tags(self):
""")
name = "Test Capa Problem"
- descriptor = self._create_descriptor(xml, name=name)
- assert descriptor.problem_types == {'multiplechoiceresponse'}
- assert descriptor.index_dictionary() ==\
+ block = self._create_block(xml, name=name)
+ assert block.problem_types == {'multiplechoiceresponse'}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': ['multiplechoiceresponse'],
'content': {'display_name': name, 'capa_content': ' Label Some comment Apple Banana Chocolate Donut '}}
@@ -2556,14 +2556,14 @@ def test_response_types_multiple_tags(self):
""")
name = "Other Test Capa Problem"
- descriptor = self._create_descriptor(xml, name=name)
- assert descriptor.problem_types == {'multiplechoiceresponse', 'optionresponse'}
+ block = self._create_block(xml, name=name)
+ assert block.problem_types == {'multiplechoiceresponse', 'optionresponse'}
# We are converting problem_types to a set to compare it later without taking into account the order
# the reasoning behind is that the problem_types (property) is represented by dict and when it is converted
# to list its ordering is different everytime.
- indexing_result = descriptor.index_dictionary()
+ indexing_result = block.index_dictionary()
indexing_result['problem_types'] = set(indexing_result['problem_types'])
self.assertDictEqual(
indexing_result, {
@@ -2608,15 +2608,15 @@ def test_solutions_not_indexed(self):
""")
name = "Blank Common Capa Problem"
- descriptor = self._create_descriptor(xml, name=name)
- assert descriptor.index_dictionary() ==\
+ block = self._create_block(xml, name=name)
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': [],
'content': {'display_name': name, 'capa_content': ' '}}
def test_indexing_checkboxes(self):
name = "Checkboxes"
- descriptor = self._create_descriptor(self.sample_checkbox_problem_xml, name=name)
+ block = self._create_block(self.sample_checkbox_problem_xml, name=name)
capa_content = textwrap.dedent("""
Title
Description
@@ -2629,30 +2629,30 @@ def test_indexing_checkboxes(self):
Hungarian
Note: Make sure you select all of the correct options—there may be more than one!
""")
- assert descriptor.problem_types == {'choiceresponse'}
- assert descriptor.index_dictionary() ==\
+ assert block.problem_types == {'choiceresponse'}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': ['choiceresponse'],
'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ')}}
def test_indexing_dropdown(self):
name = "Dropdown"
- descriptor = self._create_descriptor(self.sample_dropdown_problem_xml, name=name)
+ block = self._create_block(self.sample_dropdown_problem_xml, name=name)
capa_content = textwrap.dedent("""
Dropdown problems allow learners to select only one option from a list of options.
Description
You can use the following example problem as a model.
Which of the following countries celebrates its independence on August 15? 'India','Spain','China','Bermuda'
""")
- assert descriptor.problem_types == {'optionresponse'}
- assert descriptor.index_dictionary() ==\
+ assert block.problem_types == {'optionresponse'}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': ['optionresponse'],
'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ')}}
def test_indexing_multiple_choice(self):
name = "Multiple Choice"
- descriptor = self._create_descriptor(self.sample_multichoice_problem_xml, name=name)
+ block = self._create_block(self.sample_multichoice_problem_xml, name=name)
capa_content = textwrap.dedent("""
Multiple choice problems allow learners to select only one option.
When you add the problem, be sure to select Settings to specify a Display Name and other values.
@@ -2663,15 +2663,15 @@ def test_indexing_multiple_choice(self):
Indonesia
Russia
""")
- assert descriptor.problem_types == {'multiplechoiceresponse'}
- assert descriptor.index_dictionary() ==\
+ assert block.problem_types == {'multiplechoiceresponse'}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': ['multiplechoiceresponse'],
'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ')}}
def test_indexing_numerical_input(self):
name = "Numerical Input"
- descriptor = self._create_descriptor(self.sample_numerical_input_problem_xml, name=name)
+ block = self._create_block(self.sample_numerical_input_problem_xml, name=name)
capa_content = textwrap.dedent("""
In a numerical input problem, learners enter numbers or a specific and relatively simple mathematical
expression. Learners enter the response in plain text, and the system then converts the text to a symbolic
@@ -2685,15 +2685,15 @@ def test_indexing_numerical_input(self):
How many miles away from Earth is the sun? Use scientific notation to answer.
The square of what number is -100?
""")
- assert descriptor.problem_types == {'numericalresponse'}
- assert descriptor.index_dictionary() ==\
+ assert block.problem_types == {'numericalresponse'}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': ['numericalresponse'],
'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ')}}
def test_indexing_text_input(self):
name = "Text Input"
- descriptor = self._create_descriptor(self.sample_text_input_problem_xml, name=name)
+ block = self._create_block(self.sample_text_input_problem_xml, name=name)
capa_content = textwrap.dedent("""
In text input problems, also known as "fill-in-the-blank" problems, learners enter text into a response
field. The text can include letters and characters such as punctuation marks. The text that the learner
@@ -2704,8 +2704,8 @@ def test_indexing_text_input(self):
You can use the following example problem as a model.
What was the first post-secondary school in China to allow both male and female students?
""")
- assert descriptor.problem_types == {'stringresponse'}
- assert descriptor.index_dictionary() ==\
+ assert block.problem_types == {'stringresponse'}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': ['stringresponse'],
'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ')}}
@@ -2718,15 +2718,15 @@ def test_indexing_non_latin_problem(self):
""")
name = "Non latin Input"
- descriptor = self._create_descriptor(sample_text_input_problem_xml, name=name)
+ block = self._create_block(sample_text_input_problem_xml, name=name)
capa_content = " Δοκιμή με μεταβλητές με Ελληνικούς χαρακτήρες μέσα σε python: $FX1_VAL "
- descriptor_dict = descriptor.index_dictionary()
- assert descriptor_dict['content']['capa_content'] == smart_str(capa_content)
+ block_dict = block.index_dictionary()
+ assert block_dict['content']['capa_content'] == smart_str(capa_content)
def test_indexing_checkboxes_with_hints_and_feedback(self):
name = "Checkboxes with Hints and Feedback"
- descriptor = self._create_descriptor(self.sample_checkboxes_with_hints_and_feedback_problem_xml, name=name)
+ block = self._create_block(self.sample_checkboxes_with_hints_and_feedback_problem_xml, name=name)
capa_content = textwrap.dedent("""
You can provide feedback for each option in a checkbox problem, with distinct feedback depending on
whether or not the learner selects that option.
@@ -2742,15 +2742,15 @@ def test_indexing_checkboxes_with_hints_and_feedback(self):
potato
tomato
""")
- assert descriptor.problem_types == {'choiceresponse'}
- assert descriptor.index_dictionary() ==\
+ assert block.problem_types == {'choiceresponse'}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': ['choiceresponse'],
'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ')}}
def test_indexing_dropdown_with_hints_and_feedback(self):
name = "Dropdown with Hints and Feedback"
- descriptor = self._create_descriptor(self.sample_dropdown_with_hints_and_feedback_problem_xml, name=name)
+ block = self._create_block(self.sample_dropdown_with_hints_and_feedback_problem_xml, name=name)
capa_content = textwrap.dedent("""
You can provide feedback for each available option in a dropdown problem.
You can also add hints for learners.
@@ -2762,15 +2762,15 @@ def test_indexing_dropdown_with_hints_and_feedback(self):
potato
tomato
""")
- assert descriptor.problem_types == {'optionresponse'}
- assert descriptor.index_dictionary() ==\
+ assert block.problem_types == {'optionresponse'}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': ['optionresponse'],
'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ')}}
def test_indexing_multiple_choice_with_hints_and_feedback(self):
name = "Multiple Choice with Hints and Feedback"
- descriptor = self._create_descriptor(self.sample_multichoice_with_hints_and_feedback_problem_xml, name=name)
+ block = self._create_block(self.sample_multichoice_with_hints_and_feedback_problem_xml, name=name)
capa_content = textwrap.dedent("""
You can provide feedback for each option in a multiple choice problem.
You can also add hints for learners.
@@ -2782,15 +2782,15 @@ def test_indexing_multiple_choice_with_hints_and_feedback(self):
potato
tomato
""")
- assert descriptor.problem_types == {'multiplechoiceresponse'}
- assert descriptor.index_dictionary() ==\
+ assert block.problem_types == {'multiplechoiceresponse'}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': ['multiplechoiceresponse'],
'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ')}}
def test_indexing_numerical_input_with_hints_and_feedback(self):
name = "Numerical Input with Hints and Feedback"
- descriptor = self._create_descriptor(self.sample_numerical_input_with_hints_and_feedback_problem_xml, name=name)
+ block = self._create_block(self.sample_numerical_input_with_hints_and_feedback_problem_xml, name=name)
capa_content = textwrap.dedent("""
You can provide feedback for correct answers in numerical input problems. You cannot provide feedback
for incorrect answers.
@@ -2800,15 +2800,15 @@ def test_indexing_numerical_input_with_hints_and_feedback(self):
Use the following example problem as a model.
What is the arithmetic mean for the following set of numbers? (1, 5, 6, 3, 5)
""")
- assert descriptor.problem_types == {'numericalresponse'}
- assert descriptor.index_dictionary() ==\
+ assert block.problem_types == {'numericalresponse'}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': ['numericalresponse'],
'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ')}}
def test_indexing_text_input_with_hints_and_feedback(self):
name = "Text Input with Hints and Feedback"
- descriptor = self._create_descriptor(self.sample_text_input_with_hints_and_feedback_problem_xml, name=name)
+ block = self._create_block(self.sample_text_input_with_hints_and_feedback_problem_xml, name=name)
capa_content = textwrap.dedent("""
You can provide feedback for the correct answer in text input problems, as well as for specific
incorrect answers.
@@ -2818,8 +2818,8 @@ def test_indexing_text_input_with_hints_and_feedback(self):
Use the following example problem as a model.
Which U.S. state has the largest land area?
""")
- assert descriptor.problem_types == {'stringresponse'}
- assert descriptor.index_dictionary() ==\
+ assert block.problem_types == {'stringresponse'}
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': ['stringresponse'],
'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ')}}
@@ -2840,12 +2840,12 @@ def test_indexing_problem_with_html_tags(self):
""")
name = "Mixed business"
- descriptor = self._create_descriptor(sample_problem_xml, name=name)
+ block = self._create_block(sample_problem_xml, name=name)
capa_content = textwrap.dedent("""
This has HTML comment in it.
HTML end.
""")
- assert descriptor.index_dictionary() ==\
+ assert block.index_dictionary() ==\
{'content_type': ProblemBlock.INDEX_CONTENT_TYPE,
'problem_types': [],
'content': {'display_name': name, 'capa_content': capa_content.replace('\n', ' ')}}
@@ -2860,7 +2860,7 @@ def test_invalid_xml_handling(self):
This is a secret') # lint-amnesty, pylint: disable=protected-access
- child_descriptor.student_view = child_descriptor._xmodule.student_view # lint-amnesty, pylint: disable=protected-access
- child_descriptor.runtime = system
- child_descriptor.render = lambda view, context=None: system.render(child_descriptor, view, context)
- child_descriptor.location = source_location.replace(category='html', name='child')
+ source_block = Mock(name='source_block')
+ source_block.location = source_location
+
+ source_block.visible_to_staff_only = source_visible_to_staff_only
+ source_block.runtime = system
+ source_block.render = lambda view, context=None: system.render(source_block, view, context)
+
+ # construct other blocks:
+ child_block = Mock(name='child_block')
+ child_block.visible_to_staff_only = False
+ child_block._xmodule.student_view.return_value = Fragment(content='This is a secret
') # lint-amnesty, pylint: disable=protected-access
+ child_block.student_view = child_block._xmodule.student_view # lint-amnesty, pylint: disable=protected-access
+ child_block.runtime = system
+ child_block.render = lambda view, context=None: system.render(child_block, view, context)
+ child_block.location = source_location.replace(category='html', name='child')
def visible_to_nonstaff_users(desc):
"""
@@ -104,8 +104,8 @@ def visible_to_nonstaff_users(desc):
def load_item(usage_id, for_parent=None): # pylint: disable=unused-argument
"""Test-only implementation of load_item that simply returns static xblocks."""
return {
- child_descriptor.location: child_descriptor,
- source_location: source_descriptor
+ child_block.location: child_block,
+ source_location: source_block
}.get(usage_id)
system.load_item = load_item
@@ -118,23 +118,23 @@ def load_item(usage_id, for_parent=None): # pylint: disable=unused-argument
'conditional_attr': 'attempted',
'conditional_value': 'true',
'xml_attributes': {'attempted': 'true'},
- 'children': [child_descriptor.location],
+ 'children': [child_block.location],
})
- cond_descriptor = ConditionalBlock(
+ cond_block = ConditionalBlock(
system,
field_data,
ScopeIds(None, None, cond_location, cond_location)
)
system.get_block_for_descriptor = lambda desc: desc if visible_to_nonstaff_users(desc) else None
- cond_descriptor.get_required_blocks = [
- system.get_block_for_descriptor(source_descriptor),
+ cond_block.get_required_blocks = [
+ system.get_block_for_descriptor(source_block),
]
# return dict:
- return {'cond_block': cond_descriptor,
- 'source_block': source_descriptor,
- 'child_block': child_descriptor}
+ return {'cond_block': cond_block,
+ 'source_block': source_block,
+ 'child_block': child_block}
class ConditionalBlockBasicTest(unittest.TestCase):
@@ -228,10 +228,10 @@ def add_block_as_child_node(block, node):
self.course = courses[0]
def get_block_for_location(self, location):
- descriptor = self.modulestore.get_item(location, depth=None)
- return self.test_system.get_block_for_descriptor(descriptor)
+ block = self.modulestore.get_item(location, depth=None)
+ return self.test_system.get_block_for_descriptor(block)
- @patch('xmodule.x_module.descriptor_global_local_resource_url')
+ @patch('xmodule.x_module.block_global_local_resource_url')
@patch.dict(settings.FEATURES, {'ENABLE_EDXNOTES': False})
def test_conditional_block(self, _):
"""Make sure that conditional block works"""
diff --git a/xmodule/tests/test_course_block.py b/xmodule/tests/test_course_block.py
index 183a4f9c069e..0adca423695a 100644
--- a/xmodule/tests/test_course_block.py
+++ b/xmodule/tests/test_course_block.py
@@ -235,36 +235,36 @@ def test_start_date_is_default(self):
assert d.start_date_is_still_default == s[3]
def test_display_organization(self):
- descriptor = get_dummy_course(start='2012-12-02T12:00', is_new=True)
- assert descriptor.location.org != descriptor.display_org_with_default
- assert descriptor.display_org_with_default == f'{ORG}_display'
+ block = get_dummy_course(start='2012-12-02T12:00', is_new=True)
+ assert block.location.org != block.display_org_with_default
+ assert block.display_org_with_default == f'{ORG}_display'
def test_display_coursenumber(self):
- descriptor = get_dummy_course(start='2012-12-02T12:00', is_new=True)
- assert descriptor.location.course != descriptor.display_number_with_default
- assert descriptor.display_number_with_default == f'{COURSE}_display'
+ block = get_dummy_course(start='2012-12-02T12:00', is_new=True)
+ assert block.location.course != block.display_number_with_default
+ assert block.display_number_with_default == f'{COURSE}_display'
def test_is_newish(self):
- descriptor = get_dummy_course(start='2012-12-02T12:00', is_new=True)
- assert descriptor.is_newish is True
+ block = get_dummy_course(start='2012-12-02T12:00', is_new=True)
+ assert block.is_newish is True
- descriptor = get_dummy_course(start='2013-02-02T12:00', is_new=False)
- assert descriptor.is_newish is False
+ block = get_dummy_course(start='2013-02-02T12:00', is_new=False)
+ assert block.is_newish is False
- descriptor = get_dummy_course(start='2013-02-02T12:00', is_new=True)
- assert descriptor.is_newish is True
+ block = get_dummy_course(start='2013-02-02T12:00', is_new=True)
+ assert block.is_newish is True
- descriptor = get_dummy_course(start='2013-01-15T12:00')
- assert descriptor.is_newish is True
+ block = get_dummy_course(start='2013-01-15T12:00')
+ assert block.is_newish is True
- descriptor = get_dummy_course(start='2013-03-01T12:00')
- assert descriptor.is_newish is True
+ block = get_dummy_course(start='2013-03-01T12:00')
+ assert block.is_newish is True
- descriptor = get_dummy_course(start='2012-10-15T12:00')
- assert descriptor.is_newish is False
+ block = get_dummy_course(start='2012-10-15T12:00')
+ assert block.is_newish is False
- descriptor = get_dummy_course(start='2012-12-31T12:00')
- assert descriptor.is_newish is True
+ block = get_dummy_course(start='2012-12-31T12:00')
+ assert block.is_newish is True
class DiscussionTopicsTestCase(unittest.TestCase):
diff --git a/xmodule/tests/test_error_block.py b/xmodule/tests/test_error_block.py
index f80fb905cb8b..b585b1c439ea 100644
--- a/xmodule/tests/test_error_block.py
+++ b/xmodule/tests/test_error_block.py
@@ -31,14 +31,14 @@ class TestErrorBlock(SetupTestErrorBlock):
"""
def test_error_block_xml_rendering(self):
- descriptor = ErrorBlock.from_xml(
+ block = ErrorBlock.from_xml(
self.valid_xml,
self.system,
CourseLocationManager(self.course_id),
self.error_msg
)
- assert isinstance(descriptor, ErrorBlock)
- descriptor.runtime = self.system
- context_repr = self.system.render(descriptor, STUDENT_VIEW).content
+ assert isinstance(block, ErrorBlock)
+ block.runtime = self.system
+ context_repr = self.system.render(block, STUDENT_VIEW).content
assert self.error_msg in context_repr
assert repr(self.valid_xml) in context_repr
diff --git a/xmodule/tests/test_export.py b/xmodule/tests/test_export.py
index 0e6469db70af..7d6316a6a144 100644
--- a/xmodule/tests/test_export.py
+++ b/xmodule/tests/test_export.py
@@ -28,22 +28,22 @@
from xmodule.x_module import XModuleMixin
-def strip_filenames(descriptor):
+def strip_filenames(block):
"""
Recursively strips 'filename' from all children's definitions.
"""
- print(f"strip filename from {str(descriptor.location)}")
- if descriptor._field_data.has(descriptor, 'filename'): # lint-amnesty, pylint: disable=protected-access
- descriptor._field_data.delete(descriptor, 'filename') # lint-amnesty, pylint: disable=protected-access
+ print(f"strip filename from {str(block.location)}")
+ if block._field_data.has(block, 'filename'): # lint-amnesty, pylint: disable=protected-access
+ block._field_data.delete(block, 'filename') # lint-amnesty, pylint: disable=protected-access
- if hasattr(descriptor, 'xml_attributes'):
- if 'filename' in descriptor.xml_attributes:
- del descriptor.xml_attributes['filename']
+ if hasattr(block, 'xml_attributes'):
+ if 'filename' in block.xml_attributes:
+ del block.xml_attributes['filename']
- for child in descriptor.get_children():
+ for child in block.get_children():
strip_filenames(child)
- descriptor.save()
+ block.save()
class PureXBlock(XBlock):
diff --git a/xmodule/tests/test_html_block.py b/xmodule/tests/test_html_block.py
index df8c803b5235..019b32f09505 100644
--- a/xmodule/tests/test_html_block.py
+++ b/xmodule/tests/test_html_block.py
@@ -16,9 +16,9 @@
from . import get_test_descriptor_system, get_test_system
-def instantiate_descriptor(**field_data):
+def instantiate_block(**field_data):
"""
- Instantiate descriptor with most properties.
+ Instantiate block with most properties.
"""
system = get_test_descriptor_system()
course_key = CourseLocator('org', 'course', 'run')
@@ -152,8 +152,8 @@ def test_index_dictionary_simple_html_block(self):
Hello World!
'
self.course_link = 'Test course rewrite'
- self.descriptor = BlockFactory.create(
+ self.block = BlockFactory.create(
category='html',
data=self.content_string + self.rewrite_link + self.rewrite_bad_link + self.course_link
)
- self.location = self.descriptor.location
- self.field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
+ self.location = self.block.location
+ self.field_data_cache = FieldDataCache.cache_for_block_descendents(
self.course.id,
self.user,
- self.descriptor
+ self.block
)
def test_xblock_display_wrapper_enabled(self):
@@ -1649,12 +1649,12 @@ def test_json_init_data(self, json_data, json_output):
mock_request = MagicMock()
mock_request.user = mock_user
course = CourseFactory()
- descriptor = BlockFactory(category='withjson', parent=course)
- field_data_cache = FieldDataCache([course, descriptor], course.id, mock_user)
+ block = BlockFactory(category='withjson', parent=course)
+ field_data_cache = FieldDataCache([course, block], course.id, mock_user)
block = render.get_block_for_descriptor(
mock_user,
mock_request,
- descriptor,
+ block,
field_data_cache,
course.id,
course=course
@@ -1704,17 +1704,17 @@ def setUp(self):
options=['Correct', 'Incorrect'],
correct_option='Correct'
)
- self.descriptor = BlockFactory.create(
+ self.block = BlockFactory.create(
category='problem',
data=problem_xml,
display_name='Option Response Problem'
)
- self.location = self.descriptor.location
- self.field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
+ self.location = self.block.location
+ self.field_data_cache = FieldDataCache.cache_for_block_descendents(
self.course.id,
self.user,
- self.descriptor
+ self.block
)
@patch.dict('django.conf.settings.FEATURES', {'DISPLAY_DEBUG_INFO_TO_STAFF': False})
@@ -1757,14 +1757,14 @@ def test_staff_debug_info_score_for_invalid_dropdown(self):
"""
- problem_descriptor = BlockFactory.create(
+ problem_block = BlockFactory.create(
category='problem',
data=problem_xml
)
block = render.get_block(
self.user,
self.request,
- problem_descriptor.location,
+ problem_block.location,
self.field_data_cache
)
html_fragment = block.render(STUDENT_VIEW)
@@ -1774,26 +1774,26 @@ def test_staff_debug_info_score_for_invalid_dropdown(self):
""")
- assert expected_score_override_html.format(block_id=problem_descriptor.location.block_id) in\
+ assert expected_score_override_html.format(block_id=problem_block.location.block_id) in\
html_fragment.content
@XBlock.register_temp_plugin(DetachedXBlock, identifier='detached-block')
def test_staff_debug_info_disabled_for_detached_blocks(self):
"""Staff markup should not be present on detached blocks."""
- descriptor = BlockFactory.create(
+ detached_block = BlockFactory.create(
category='detached-block',
display_name='Detached Block'
)
- field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
+ field_data_cache = FieldDataCache.cache_for_block_descendents(
self.course.id,
self.user,
- descriptor
+ detached_block
)
block = render.get_block(
self.user,
self.request,
- descriptor.location,
+ detached_block.location,
field_data_cache,
)
result_fragment = block.render(STUDENT_VIEW)
@@ -1813,21 +1813,21 @@ def test_histogram_disabled(self):
def test_histogram_enabled_for_unscored_xblocks(self):
"""Histograms should not display for xblocks which are not scored."""
- html_descriptor = BlockFactory.create(
+ html_block = BlockFactory.create(
category='html',
data='Here are some course details.'
)
- field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
+ field_data_cache = FieldDataCache.cache_for_block_descendents(
self.course.id,
self.user,
- self.descriptor
+ self.block
)
with patch('openedx.core.lib.xblock_utils.grade_histogram') as mock_grade_histogram:
mock_grade_histogram.return_value = []
block = render.get_block(
self.user,
self.request,
- html_descriptor.location,
+ html_block.location,
field_data_cache,
)
block.render(STUDENT_VIEW)
@@ -1888,7 +1888,7 @@ def setUp(self):
@patch('lms.djangoapps.courseware.block_render.has_access', Mock(return_value=True, autospec=True))
def _get_anonymous_id(self, course_id, xblock_class): # lint-amnesty, pylint: disable=missing-function-docstring
location = course_id.make_usage_key('dummy_category', 'dummy_name')
- descriptor = Mock(
+ block = Mock(
spec=xblock_class,
_field_data=Mock(spec=FieldData, name='field_data'),
location=location,
@@ -1901,36 +1901,36 @@ def _get_anonymous_id(self, course_id, xblock_class): # lint-amnesty, pylint: d
name='runtime',
),
scope_ids=Mock(spec=ScopeIds),
- name='descriptor',
+ name='block',
_field_data_cache={},
_dirty_fields={},
fields={},
days_early_for_beta=None,
)
- descriptor.runtime = DescriptorSystem(None, None, None)
+ block.runtime = DescriptorSystem(None, None, None)
# Use the xblock_class's bind_for_student method
- descriptor.bind_for_student = partial(xblock_class.bind_for_student, descriptor)
+ block.bind_for_student = partial(xblock_class.bind_for_student, block)
if hasattr(xblock_class, 'module_class'):
- descriptor.module_class = xblock_class.module_class
+ block.module_class = xblock_class.module_class
- block = render.get_block_for_descriptor_internal(
+ rendered_block = render.get_block_for_descriptor_internal(
user=self.user,
- descriptor=descriptor,
+ block=block,
student_data=Mock(spec=FieldData, name='student_data'),
course_id=course_id,
track_function=Mock(name='track_function'), # Track Function
request_token='request_token',
course=self.course,
)
- current_user = block.runtime.service(block, 'user').get_current_user()
+ current_user = rendered_block.runtime.service(rendered_block, 'user').get_current_user()
return current_user.opt_attrs.get(ATTR_KEY_ANONYMOUS_USER_ID)
@ddt.data(*PER_STUDENT_ANONYMIZED_XBLOCKS)
- def test_per_student_anonymized_id(self, descriptor_class):
+ def test_per_student_anonymized_id(self, block_class):
for course_id in ('MITx/6.00x/2012_Fall', 'MITx/6.00x/2013_Spring'):
assert 'de619ab51c7f4e9c7216b4644c24f3b5' == \
- self._get_anonymous_id(CourseKey.from_string(course_id), descriptor_class)
+ self._get_anonymous_id(CourseKey.from_string(course_id), block_class)
@ddt.data(*PER_COURSE_ANONYMIZED_XBLOCKS)
def test_per_course_anonymized_id(self, xblock_class):
@@ -2014,14 +2014,14 @@ def handle_callback_and_get_context_info(self,
metadata from the emitted problem_check event.
"""
- descriptor_kwargs = {
+ block_kwargs = {
'category': 'problem',
'data': self.problem_xml
}
if problem_display_name:
- descriptor_kwargs['display_name'] = problem_display_name
+ block_kwargs['display_name'] = problem_display_name
- descriptor = BlockFactory.create(**descriptor_kwargs)
+ block = BlockFactory.create(**block_kwargs)
mock_tracker_for_context = MagicMock()
with patch('lms.djangoapps.courseware.block_render.tracker', mock_tracker_for_context), patch(
'xmodule.services.tracker', mock_tracker_for_context
@@ -2029,7 +2029,7 @@ def handle_callback_and_get_context_info(self,
render.handle_xblock_callback(
self.request,
str(self.course.id),
- quote_slashes(str(descriptor.location)),
+ quote_slashes(str(block.location)),
'xmodule_handler',
'problem_check',
)
@@ -2096,7 +2096,7 @@ def get_block_for_user(self, user):
"""Helper function to get useful block at self.location in self.course_id for user"""
mock_request = MagicMock()
mock_request.user = user
- field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
+ field_data_cache = FieldDataCache.cache_for_block_descendents(
self.course.id, user, self.course, depth=2)
return render.get_block(
@@ -2167,7 +2167,7 @@ def get_block_for_user(self, user, item=None):
"""Helper function to get useful block at self.location in self.course_id for user"""
mock_request = MagicMock()
mock_request.user = user
- field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
+ field_data_cache = FieldDataCache.cache_for_block_descendents(
self.course.id, user, self.course, depth=2)
if item is None:
@@ -2248,9 +2248,9 @@ def test_event_publishing(self, mock_track_function):
request = self.request_factory.get('')
request.user = self.mock_user
course = CourseFactory()
- descriptor = BlockFactory(category='xblock', parent=course)
- field_data_cache = FieldDataCache([course, descriptor], course.id, self.mock_user)
- block = render.get_block(self.mock_user, request, descriptor.location, field_data_cache)
+ block = BlockFactory(category='xblock', parent=course)
+ field_data_cache = FieldDataCache([course, block], course.id, self.mock_user)
+ block = render.get_block(self.mock_user, request, block.location, field_data_cache)
event_type = 'event_type'
event = {'event': 'data'}
@@ -2273,7 +2273,7 @@ def _prepare_runtime(self):
_ = render.prepare_runtime_for_user(
self.user,
self.student_data,
- self.descriptor,
+ self.block,
self.course.id,
self.track_function,
self.request_token,
@@ -2291,7 +2291,7 @@ def setUp(self):
self.student_data = Mock()
self.track_function = Mock()
self.request_token = Mock()
- self.descriptor = BlockFactory(category="pure", parent=self.course)
+ self.block = BlockFactory(category="pure", parent=self.course)
self._prepare_runtime()
@@ -2334,19 +2334,19 @@ def test_expected_services_exist(self, expected_service):
"""
Tests that the 'user', 'i18n', and 'fs' services are provided by the LMS runtime.
"""
- service = self.descriptor.runtime.service(self.descriptor, expected_service)
+ service = self.block.runtime.service(self.block, expected_service)
assert service is not None
def test_beta_tester_fields_added(self):
"""
Tests that the beta tester fields are set on LMS runtime.
"""
- self.descriptor.days_early_for_beta = 5
+ self.block.days_early_for_beta = 5
self._prepare_runtime()
# pylint: disable=no-member
- assert not self.descriptor.runtime.user_is_beta_tester
- assert self.descriptor.runtime.days_early_for_beta == 5
+ assert not self.block.runtime.user_is_beta_tester
+ assert self.block.runtime.days_early_for_beta == 5
def test_get_set_tag(self):
"""
@@ -2356,23 +2356,23 @@ def test_get_set_tag(self):
key = 'key1'
# test for when we haven't set the tag yet
- tag = self.descriptor.runtime.service(self.descriptor, 'user_tags').get_tag(scope, key)
+ tag = self.block.runtime.service(self.block, 'user_tags').get_tag(scope, key)
assert tag is None
# set the tag
set_value = 'value'
- self.descriptor.runtime.service(self.descriptor, 'user_tags').set_tag(scope, key, set_value)
- tag = self.descriptor.runtime.service(self.descriptor, 'user_tags').get_tag(scope, key)
+ self.block.runtime.service(self.block, 'user_tags').set_tag(scope, key, set_value)
+ tag = self.block.runtime.service(self.block, 'user_tags').get_tag(scope, key)
assert tag == set_value
# Try to set tag in wrong scope
with pytest.raises(ValueError):
- self.descriptor.runtime.service(self.descriptor, 'user_tags').set_tag('fake_scope', key, set_value)
+ self.block.runtime.service(self.block, 'user_tags').set_tag('fake_scope', key, set_value)
# Try to get tag in wrong scope
with pytest.raises(ValueError):
- self.descriptor.runtime.service(self.descriptor, 'user_tags').get_tag('fake_scope', key)
+ self.block.runtime.service(self.block, 'user_tags').get_tag('fake_scope', key)
@ddt.ddt
@@ -2382,23 +2382,23 @@ class TestBadgingService(LMSXBlockServiceMixin):
@patch.dict(settings.FEATURES, {'ENABLE_OPENBADGES': True})
def test_service_rendered(self):
self._prepare_runtime()
- assert self.descriptor.runtime.service(self.descriptor, 'badging')
+ assert self.block.runtime.service(self.block, 'badging')
def test_no_service_rendered(self):
with pytest.raises(NoSuchServiceError):
- self.descriptor.runtime.service(self.descriptor, 'badging')
+ self.block.runtime.service(self.block, 'badging')
@ddt.data(True, False)
@patch.dict(settings.FEATURES, {'ENABLE_OPENBADGES': True})
def test_course_badges_toggle(self, toggle):
self.course = CourseFactory.create(metadata={'issue_badges': toggle})
self._prepare_runtime()
- assert self.descriptor.runtime.service(self.descriptor, 'badging').course_badges_enabled is toggle
+ assert self.block.runtime.service(self.block, 'badging').course_badges_enabled is toggle
@patch.dict(settings.FEATURES, {'ENABLE_OPENBADGES': True})
def test_get_badge_class(self):
self._prepare_runtime()
- badge_service = self.descriptor.runtime.service(self.descriptor, 'badging')
+ badge_service = self.block.runtime.service(self.block, 'badging')
premade_badge_class = BadgeClassFactory.create()
# Ignore additional parameters. This class already exists.
# We should get back the first class we created, rather than a new one.
@@ -2422,7 +2422,7 @@ def test_module_i18n_lms_service(self):
"""
Test: module i18n service in LMS
"""
- i18n_service = self.descriptor.runtime.service(self.descriptor, 'i18n')
+ i18n_service = self.block.runtime.service(self.block, 'i18n')
assert i18n_service is not None
assert isinstance(i18n_service, XBlockI18nService)
@@ -2430,32 +2430,32 @@ def test_no_service_exception_with_none_declaration_(self):
"""
Test: NoSuchServiceError should be raised block declaration returns none
"""
- self.descriptor.service_declaration = Mock(return_value=None)
+ self.block.service_declaration = Mock(return_value=None)
with pytest.raises(NoSuchServiceError):
- self.descriptor.runtime.service(self.descriptor, 'i18n')
+ self.block.runtime.service(self.block, 'i18n')
def test_no_service_exception_(self):
"""
Test: NoSuchServiceError should be raised if i18n service is none.
"""
- i18nService = self.descriptor.runtime._services['i18n'] # pylint: disable=protected-access
- self.descriptor.runtime._runtime_services['i18n'] = None # pylint: disable=protected-access
- self.descriptor.runtime._services['i18n'] = None # pylint: disable=protected-access
+ i18nService = self.block.runtime._services['i18n'] # pylint: disable=protected-access
+ self.block.runtime._runtime_services['i18n'] = None # pylint: disable=protected-access
+ self.block.runtime._services['i18n'] = None # pylint: disable=protected-access
with pytest.raises(NoSuchServiceError):
- self.descriptor.runtime.service(self.descriptor, 'i18n')
- self.descriptor.runtime._services['i18n'] = i18nService # pylint: disable=protected-access
+ self.block.runtime.service(self.block, 'i18n')
+ self.block.runtime._services['i18n'] = i18nService # pylint: disable=protected-access
def test_i18n_service_callable(self):
"""
Test: _services dict should contain the callable i18n service in LMS.
"""
- assert callable(self.descriptor.runtime._services.get('i18n')) # pylint: disable=protected-access
+ assert callable(self.block.runtime._services.get('i18n')) # pylint: disable=protected-access
def test_i18n_service_not_callable(self):
"""
Test: i18n service should not be callable in LMS after initialization.
"""
- assert not callable(self.descriptor.runtime.service(self.descriptor, 'i18n'))
+ assert not callable(self.block.runtime.service(self.block, 'i18n'))
class PureXBlockWithChildren(PureXBlock):
@@ -2490,15 +2490,6 @@ def test_unbound(self):
block = self._load_block()
self.assertUnboundChildren(block)
- @ddt.data(*USER_NUMBERS)
- @XBlock.register_temp_plugin(PureXBlockWithChildren, identifier='xblock')
- def test_unbound_then_bound_as_descriptor(self, user_number):
- user = self.users[user_number]
- block = self._load_block()
- self.assertUnboundChildren(block)
- self._bind_block(block, user)
- self.assertBoundChildren(block, user)
-
@ddt.data(*USER_NUMBERS)
@XBlock.register_temp_plugin(PureXBlockWithChildren, identifier='xblock')
def test_unbound_then_bound_as_xblock(self, user_number):
@@ -2508,14 +2499,6 @@ def test_unbound_then_bound_as_xblock(self, user_number):
self._bind_block(block, user)
self.assertBoundChildren(block, user)
- @ddt.data(*USER_NUMBERS)
- @XBlock.register_temp_plugin(PureXBlockWithChildren, identifier='xblock')
- def test_bound_only_as_descriptor(self, user_number):
- user = self.users[user_number]
- block = self._load_block()
- self._bind_block(block, user)
- self.assertBoundChildren(block, user)
-
@ddt.data(*USER_NUMBERS)
@XBlock.register_temp_plugin(PureXBlockWithChildren, identifier='xblock')
def test_bound_only_as_xblock(self, user_number):
@@ -2545,7 +2528,7 @@ def _bind_block(self, block, user):
Bind `block` to the supplied `user`.
"""
course_id = self.course.id
- field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
+ field_data_cache = FieldDataCache.cache_for_block_descendents(
course_id,
user,
block,
@@ -2606,25 +2589,25 @@ def setUp(self):
def test_get_item(self):
course = CourseFactory()
- self._verify_descriptor('video', course, 'HiddenBlockWithMixins')
+ self._verify_block('video', course, 'HiddenBlockWithMixins')
def test_dynamic_updates(self):
"""Tests that the list of disabled xblocks can dynamically update."""
course = CourseFactory()
- item_usage_id = self._verify_descriptor('problem', course, 'ProblemBlockWithMixins')
+ item_usage_id = self._verify_block('problem', course, 'ProblemBlockWithMixins')
XBlockConfiguration(name='problem', enabled=False).save()
# First verify that the cached value is used until there is a new request cache.
- self._verify_descriptor('problem', course, 'ProblemBlockWithMixins', item_usage_id)
+ self._verify_block('problem', course, 'ProblemBlockWithMixins', item_usage_id)
# Now simulate a new request cache.
self.store.request_cache.data.clear()
- self._verify_descriptor('problem', course, 'HiddenBlockWithMixins', item_usage_id)
+ self._verify_block('problem', course, 'HiddenBlockWithMixins', item_usage_id)
- def _verify_descriptor(self, category, course, descriptor, item_id=None):
+ def _verify_block(self, category, course, block, item_id=None):
"""
Helper method that gets an item with the specified category from the
- modulestore and verifies that it has the expected descriptor name.
+ modulestore and verifies that it has the expected block name.
Returns the item's usage_id.
"""
@@ -2633,7 +2616,7 @@ def _verify_descriptor(self, category, course, descriptor, item_id=None):
item_id = item.scope_ids.usage_id # lint-amnesty, pylint: disable=no-member
item = self.store.get_item(item_id)
- assert item.__class__.__name__ == descriptor
+ assert item.__class__.__name__ == block
return item_id
@@ -2650,15 +2633,15 @@ class LmsModuleSystemShimTest(SharedModuleStoreTestCase):
@classmethod
def setUpClass(cls):
"""
- Set up the course and descriptor used to instantiate the runtime.
+ Set up the course and block used to instantiate the runtime.
"""
super().setUpClass()
org = 'edX'
number = 'LmsModuleShimTest'
run = '2021_Fall'
cls.course = CourseFactory.create(org=org, number=number, run=run)
- cls.descriptor = BlockFactory(category="vertical", parent=cls.course)
- cls.problem_descriptor = BlockFactory(category="problem", parent=cls.course)
+ cls.block = BlockFactory(category="vertical", parent=cls.course)
+ cls.problem_block = BlockFactory(category="problem", parent=cls.course)
def setUp(self):
"""
@@ -2673,7 +2656,7 @@ def setUp(self):
_ = render.prepare_runtime_for_user(
self.user,
self.student_data,
- self.descriptor,
+ self.block,
self.course.id,
self.track_function,
self.request_token,
@@ -2690,37 +2673,37 @@ def test_user_service_attributes(self, attribute, expected_value):
"""
Tests that the deprecated attributes provided by the user service match expected values.
"""
- assert getattr(self.descriptor.runtime, attribute) == expected_value
+ assert getattr(self.block.runtime, attribute) == expected_value
@patch('lms.djangoapps.courseware.block_render.has_access', Mock(return_value=True, autospec=True))
def test_user_is_staff(self):
_ = render.prepare_runtime_for_user(
self.user,
self.student_data,
- self.descriptor,
+ self.block,
self.course.id,
self.track_function,
self.request_token,
course=self.course,
)
- assert self.descriptor.runtime.user_is_staff
- assert self.descriptor.runtime.get_user_role() == 'student'
+ assert self.block.runtime.user_is_staff
+ assert self.block.runtime.get_user_role() == 'student'
@patch('lms.djangoapps.courseware.block_render.get_user_role', Mock(return_value='instructor', autospec=True))
def test_get_user_role(self):
_ = render.prepare_runtime_for_user(
self.user,
self.student_data,
- self.descriptor,
+ self.block,
self.course.id,
self.track_function,
self.request_token,
course=self.course,
)
- assert self.descriptor.runtime.get_user_role() == 'instructor'
+ assert self.block.runtime.get_user_role() == 'instructor'
def test_anonymous_student_id(self):
- assert self.descriptor.runtime.anonymous_student_id == anonymous_id_for_user(self.user, self.course.id)
+ assert self.block.runtime.anonymous_student_id == anonymous_id_for_user(self.user, self.course.id)
def test_anonymous_student_id_bug(self):
"""
@@ -2730,76 +2713,76 @@ def test_anonymous_student_id_bug(self):
_ = render.prepare_runtime_for_user(
self.user,
self.student_data,
- self.problem_descriptor,
+ self.problem_block,
self.course.id,
self.track_function,
self.request_token,
course=self.course,
)
# Ensure the problem block returns a per-user anonymous id
- assert self.problem_descriptor.runtime.anonymous_student_id == anonymous_id_for_user(self.user, None)
+ assert self.problem_block.runtime.anonymous_student_id == anonymous_id_for_user(self.user, None)
_ = render.prepare_runtime_for_user(
self.user,
self.student_data,
- self.descriptor,
+ self.block,
self.course.id,
self.track_function,
self.request_token,
course=self.course,
)
# Ensure the vertical block returns a per-course+user anonymous id
- assert self.descriptor.runtime.anonymous_student_id == anonymous_id_for_user(self.user, self.course.id)
+ assert self.block.runtime.anonymous_student_id == anonymous_id_for_user(self.user, self.course.id)
# Ensure the problem runtime's anonymous student ID is unchanged after the above call.
- assert self.problem_descriptor.runtime.anonymous_student_id == anonymous_id_for_user(self.user, None)
+ assert self.problem_block.runtime.anonymous_student_id == anonymous_id_for_user(self.user, None)
def test_user_service_with_anonymous_user(self):
_ = render.prepare_runtime_for_user(
AnonymousUser(),
self.student_data,
- self.descriptor,
+ self.block,
self.course.id,
self.track_function,
self.request_token,
course=self.course,
)
- assert self.descriptor.runtime.anonymous_student_id is None
- assert self.descriptor.runtime.seed == 0
- assert self.descriptor.runtime.user_id is None
- assert not self.descriptor.runtime.user_is_staff
- assert not self.descriptor.runtime.get_user_role()
+ assert self.block.runtime.anonymous_student_id is None
+ assert self.block.runtime.seed == 0
+ assert self.block.runtime.user_id is None
+ assert not self.block.runtime.user_is_staff
+ assert not self.block.runtime.get_user_role()
def test_get_real_user(self):
_ = render.prepare_runtime_for_user(
self.user,
self.student_data,
- self.descriptor,
+ self.block,
self.course.id,
self.track_function,
self.request_token,
course=self.course,
)
course_anonymous_student_id = anonymous_id_for_user(self.user, self.course.id)
- assert self.descriptor.runtime.get_real_user(course_anonymous_student_id) == self.user # pylint: disable=not-callable
+ assert self.block.runtime.get_real_user(course_anonymous_student_id) == self.user # pylint: disable=not-callable
no_course_anonymous_student_id = anonymous_id_for_user(self.user, None)
- assert self.descriptor.runtime.get_real_user(no_course_anonymous_student_id) == self.user # pylint: disable=not-callable
+ assert self.block.runtime.get_real_user(no_course_anonymous_student_id) == self.user # pylint: disable=not-callable
# Tests that the default is to use the user service's anonymous_student_id
- assert self.descriptor.runtime.get_real_user() == self.user # pylint: disable=not-callable
+ assert self.block.runtime.get_real_user() == self.user # pylint: disable=not-callable
def test_render_template(self):
- rendered = self.descriptor.runtime.render_template('templates/edxmako.html', {'element_id': 'hi'}) # pylint: disable=not-callable
+ rendered = self.block.runtime.render_template('templates/edxmako.html', {'element_id': 'hi'}) # pylint: disable=not-callable
assert rendered == '