def test_change_mutable_default():
"""
Ensure that mutating the default value for a field causes
the changes to be saved, and doesn't corrupt other instances
"""
class MutableTester(XBlock):
"""Test class with mutable fields."""
list_field = List()
field_data_a = DictFieldData({})
mutable_test_a = MutableTester(TestRuntime(services={'field-data': field_data_a}), scope_ids=Mock(spec=ScopeIds))
field_data_b = DictFieldData({})
mutable_test_b = MutableTester(TestRuntime(services={'field-data': field_data_b}), scope_ids=Mock(spec=ScopeIds))
# Saving without changing the default value shouldn't write to field_data
mutable_test_a.list_field # pylint: disable=W0104
mutable_test_a.save()
with assert_raises(KeyError):
field_data_a.get(mutable_test_a, 'list_field')
mutable_test_a.list_field.append(1)
mutable_test_a.save()
assert_equals([1], field_data_a.get(mutable_test_a, 'list_field'))
with assert_raises(KeyError):
field_data_b.get(mutable_test_b, 'list_field')
def test_caching_is_per_instance():
# Test that values cached for one instance do not appear on another
class FieldTester(ScopedStorageMixin):
"""Toy class for ModelMetaclass and field access testing"""
field_a = List(scope=Scope.settings)
field_data = MagicMock(spec=FieldData)
field_data.get = lambda block, name, default=None: [name] # pylint: disable=C0322
# Same field_data used in different objects should result
# in separately-cached values, so that changing a value
# in one instance doesn't affect values stored in others.
field_tester_a = FieldTester(
runtime=TestRuntime(services={'field-data': field_data}),
scope_ids=MagicMock(spec=ScopeIds)
)
field_tester_b = FieldTester(
runtime=TestRuntime(services={'field-data': field_data}),
scope_ids=MagicMock(spec=ScopeIds)
)
value = field_tester_a.field_a
assert_equals(value, field_tester_a.field_a)
field_tester_a.field_a.append(1)
assert_equals(value, field_tester_a.field_a)
assert_not_equals(value, field_tester_b.field_a)
def test_unique_id_default():
class TestBlock(XBlock):
"""
Block for testing
"""
field_a = String(default=UNIQUE_ID, scope=Scope.settings)
field_b = String(default=UNIQUE_ID, scope=Scope.user_state)
sids = ScopeIds(user_id="bob",
block_type="bobs-type",
def_id="definition-id",
usage_id="usage-id")
runtime = TestRuntime(services={'field-data': DictFieldData({})})
block = TestBlock(runtime, DictFieldData({}), sids)
unique_a = block.field_a
unique_b = block.field_b
# Create another instance of the same block. Unique ID defaults should not change.
runtime = TestRuntime(services={'field-data': DictFieldData({})})
block = TestBlock(runtime, DictFieldData({}), sids)
assert_equals(unique_a, block.field_a)
assert_equals(unique_b, block.field_b)
# Change the user id. Unique ID default should change for field_b with
# user_state scope, but not for field_a with scope=settings.
runtime = TestRuntime(services={'field-data': DictFieldData({})})
block = TestBlock(runtime, DictFieldData({}),
sids._replace(user_id='alice'))
assert_equals(unique_a, block.field_a)
assert_not_equals(unique_b, block.field_b)
# Change the usage id. Unique ID default for both fields should change.
runtime = TestRuntime(services={'field-data': DictFieldData({})})
block = TestBlock(runtime, DictFieldData({}),
sids._replace(usage_id='usage-2'))
assert_not_equals(unique_a, block.field_a)
assert_not_equals(unique_b, block.field_b)
def test_ugettext_calls():
"""
Test ugettext calls in xblock.
"""
runtime = TestRuntime()
block = XBlockWithServices(runtime, scope_ids=Mock(spec=[]))
assert block.ugettext('test') == 'test'
assert isinstance(block.ugettext('test'), six.text_type)
# NoSuchServiceError exception should raise if i18n is none/empty.
runtime = TestRuntime(services={'i18n': None})
block = XBlockWithServices(runtime, scope_ids=Mock(spec=[]))
with pytest.raises(NoSuchServiceError):
block.ugettext('test')
def test_ugettext_calls():
"""
Test ugettext calls in xblock.
"""
runtime = TestRuntime()
block = XBlockWithServices(runtime, scope_ids=Mock(spec=[]))
assert_equals(block.ugettext('test'), u'test')
assert_true(isinstance(block.ugettext('test'), unicode))
# NoSuchServiceError exception should raise if i18n is none/empty.
runtime = TestRuntime(services={'i18n': None})
block = XBlockWithServices(runtime, scope_ids=Mock(spec=[]))
with assert_raises(NoSuchServiceError):
block.ugettext('test')
def test_scope_key():
# Tests field display name default values
class TestBlock(XBlock):
"""
Block for testing
"""
field_x = List(scope=Scope.settings, name='')
settings_lst = List(scope=Scope.settings, name='')
uss_lst = List(scope=Scope.user_state_summary, name='')
user_lst = List(scope=Scope.user_state, name='')
pref_lst = List(scope=Scope.preferences, name='')
user_info_lst = List(scope=Scope.user_info, name='')
sids = ScopeIds(user_id="_bob",
block_type="b.12#ob",
def_id="..",
usage_id="..")
field_data = DictFieldData({})
runtime = TestRuntime(Mock(), services={'field-data': field_data})
block = TestBlock(runtime, None, sids)
# Format: usage or block ID/field_name/user_id
for item, correct_key in [
[TestBlock.field_x, "__..../field__x/NONE.NONE"],
[TestBlock.user_info_lst, "NONE.NONE/user__info__lst/____bob"],
[TestBlock.pref_lst, "b..12_35_ob/pref__lst/____bob"],
[TestBlock.user_lst, "__..../user__lst/____bob"],
[TestBlock.uss_lst, "__..../uss__lst/NONE.NONE"],
[TestBlock.settings_lst, "__..../settings__lst/NONE.NONE"]
]:
key = scope_key(item, block)
assert_equals(key, correct_key)
def test_set_field_data(self):
field_data = Mock(spec=FieldData)
runtime = TestRuntime(Mock(spec=IdReader), None)
with self.assertWarns(FieldDataDeprecationWarning):
runtime.field_data = field_data
with self.assertWarns(FieldDataDeprecationWarning):
self.assertEquals(runtime.field_data, field_data)
def test_mixin_field_access():
field_data = DictFieldData({
'field_a': 5,
'field_x': [1, 2, 3],
})
runtime = TestRuntime(Mock(),
mixins=[TestSimpleMixin],
services={'field-data': field_data})
field_tester = runtime.construct_xblock_from_class(FieldTester, Mock())
assert field_tester.field_a == 5
assert field_tester.field_b == 10
assert field_tester.field_c == 42
assert field_tester.field_x == [1, 2, 3]
assert field_tester.field_y == 'default_value'
field_tester.field_x = ['a', 'b']
field_tester.save()
assert ['a', 'b'] == field_tester._field_data.get(field_tester, 'field_x')
del field_tester.field_x
assert [] == field_tester.field_x
assert [1, 2, 3] == field_tester.field_x_with_default
with pytest.raises(AttributeError):
getattr(field_tester, 'field_z')
with pytest.raises(AttributeError):
delattr(field_tester, 'field_z')
field_tester.field_z = 'foo'
assert field_tester.field_z == 'foo'
assert not field_tester._field_data.has(field_tester, 'field_z')
def test_setting_the_same_value_marks_field_as_dirty():
"""
Check that setting field to the same value does not mark mutable fields as dirty.
This might be an unexpected behavior though
"""
class FieldTester(XBlock):
"""Test block for set - get test."""
non_mutable = String(scope=Scope.settings)
list_field = List(scope=Scope.settings)
dict_field = Dict(scope=Scope.settings)
runtime = TestRuntime(services={'field-data': DictFieldData({})})
field_tester = FieldTester(runtime, scope_ids=Mock(spec=ScopeIds))
# precondition checks
assert_equals(len(field_tester._dirty_fields), 0)
assert_false(field_tester.fields['list_field'].is_set_on(field_tester))
assert_false(field_tester.fields['dict_field'].is_set_on(field_tester))
assert_false(field_tester.fields['non_mutable'].is_set_on(field_tester))
field_tester.non_mutable = field_tester.non_mutable
field_tester.list_field = field_tester.list_field
field_tester.dict_field = field_tester.dict_field
assert_in(field_tester.fields['non_mutable'], field_tester._dirty_fields)
assert_in(field_tester.fields['list_field'], field_tester._dirty_fields)
assert_in(field_tester.fields['dict_field'], field_tester._dirty_fields)
assert_true(field_tester.fields['non_mutable'].is_set_on(field_tester))
assert_true(field_tester.fields['list_field'].is_set_on(field_tester))
assert_true(field_tester.fields['dict_field'].is_set_on(field_tester))
def test_lazy_translation(self):
with warnings.catch_warnings(record=True) as caught_warnings:
warnings.simplefilter('always', FailingEnforceTypeWarning)
class XBlockTest(XBlock):
"""
Set up a class that contains a single string field with a translated
default.
"""
STR_DEFAULT_ENG = 'ENG: String to be translated'
str_field = String(scope=Scope.settings, default=_('ENG: String to be translated'))
# No FailingEnforceTypeWarning should have been triggered
assert not caught_warnings
# Construct a runtime and an XBlock using it.
key_store = DictKeyValueStore()
field_data = KvsFieldData(key_store)
runtime = TestRuntime(Mock(), services={'field-data': field_data})
# Change language to 'de'.
user_language = 'de'
with translation.override(user_language):
tester = runtime.construct_xblock_from_class(XBlockTest, ScopeIds('s0', 'XBlockTest', 'd0', 'u0'))
# Assert instantiated XBlock str_field value is not yet evaluated.
assert 'django.utils.functional.' in str(type(tester.str_field))
# Assert str_field *is* translated when the value is used.
assert text_type(tester.str_field) == 'DEU: Translated string'
def test_twofaced_field_access():
# Check that a field with different to_json and from_json representations
# persists and saves correctly.
class TwoFacedField(Field):
"""A field that emits different 'json' than it parses."""
def from_json(self, thestr):
"""Store an int, the length of the string parsed."""
return len(thestr)
def to_json(self, value):
"""Emit some number of X's."""
return "X" * value
class FieldTester(XBlock):
"""Test block for TwoFacedField."""
how_many = TwoFacedField(scope=Scope.settings)
original_json = "YYY"
runtime = TestRuntime(
services={'field-data': DictFieldData({'how_many': original_json})})
field_tester = FieldTester(runtime, scope_ids=Mock(spec=ScopeIds))
# Test that the native value isn't equal to the original json we specified.
assert_not_equals(field_tester.how_many, original_json)
# Test that the native -> json value isn't equal to the original json we specified.
assert_not_equals(TwoFacedField().to_json(field_tester.how_many),
original_json)
# The previous accesses will mark the field as dirty (via __get__)
assert_equals(len(field_tester._dirty_fields), 1)
# However, the field should not ACTUALLY be marked as a field that is needing to be saved.
assert_not_in('how_many', field_tester._get_fields_to_save()) # pylint: disable=W0212
def test_default_index_view(self):
test_runtime = TestRuntime(services={'field-data': DictFieldData({})})
test_xblock = self.TestXBlock(test_runtime, scope_ids=Mock(spec=ScopeIds))
index_info = test_xblock.index_dictionary()
self.assertFalse(index_info)
self.assertTrue(isinstance(index_info, dict))
def test_db_model_keys():
# Tests that updates to fields are properly recorded in the KeyValueStore,
# and that the keys have been constructed correctly
key_store = DictKeyValueStore()
field_data = KvsFieldData(key_store)
runtime = TestRuntime(Mock(), mixins=[TestMixin], services={'field-data': field_data})
tester = runtime.construct_xblock_from_class(TestXBlock, ScopeIds('s0', 'TestXBlock', 'd0', 'u0'))
assert not field_data.has(tester, 'not a field')
for field in six.itervalues(tester.fields):
new_value = 'new ' + field.name
assert not field_data.has(tester, field.name)
if isinstance(field, List):
new_value = [new_value]
setattr(tester, field.name, new_value)
# Write out the values
tester.save()
# Make sure everything saved correctly
for field in six.itervalues(tester.fields):
assert field_data.has(tester, field.name)
def get_key_value(scope, user_id, block_scope_id, field_name):
"""Gets the value, from `key_store`, of a Key with the given values."""
new_key = KeyValueStore.Key(scope, user_id, block_scope_id, field_name)
return key_store.db_dict[new_key]
# Examine each value in the database and ensure that keys were constructed correctly
assert get_key_value(Scope.content, None, 'd0', 'content') == 'new content'
assert get_key_value(Scope.settings, None, 'u0', 'settings') == 'new settings'
assert get_key_value(Scope.user_state, 's0', 'u0', 'user_state') == 'new user_state'
assert get_key_value(Scope.preferences, 's0', 'TestXBlock', 'preferences') == 'new preferences'
assert get_key_value(Scope.user_info, 's0', None, 'user_info') == 'new user_info'
assert get_key_value(Scope(UserScope.NONE, BlockScope.TYPE), None, 'TestXBlock', 'by_type') == 'new by_type'
assert get_key_value(Scope(UserScope.NONE, BlockScope.ALL), None, None, 'for_all') == 'new for_all'
assert get_key_value(Scope(UserScope.ONE, BlockScope.DEFINITION), 's0', 'd0', 'user_def') == 'new user_def'
assert get_key_value(Scope(UserScope.ALL, BlockScope.ALL), None, None, 'agg_global') == 'new agg_global'
assert get_key_value(Scope(UserScope.ALL, BlockScope.TYPE), None, 'TestXBlock', 'agg_type') == 'new agg_type'
assert get_key_value(Scope(UserScope.ALL, BlockScope.DEFINITION), None, 'd0', 'agg_def') == 'new agg_def'
assert get_key_value(Scope.user_state_summary, None, 'u0', 'agg_usage') == 'new agg_usage'
assert get_key_value(Scope.content, None, 'd0', 'mixin_content') == 'new mixin_content'
assert get_key_value(Scope.settings, None, 'u0', 'mixin_settings') == 'new mixin_settings'
assert get_key_value(Scope.user_state, 's0', 'u0', 'mixin_user_state') == 'new mixin_user_state'
assert get_key_value(Scope.preferences, 's0', 'TestXBlock', 'mixin_preferences') == 'new mixin_preferences'
assert get_key_value(Scope.user_info, 's0', None, 'mixin_user_info') == 'new mixin_user_info'
assert get_key_value(Scope(UserScope.NONE, BlockScope.TYPE), None, 'TestXBlock', 'mixin_by_type') == \
'new mixin_by_type'
assert get_key_value(Scope(UserScope.NONE, BlockScope.ALL), None, None, 'mixin_for_all') == \
'new mixin_for_all'
assert get_key_value(Scope(UserScope.ONE, BlockScope.DEFINITION), 's0', 'd0', 'mixin_user_def') == \
'new mixin_user_def'
assert get_key_value(Scope(UserScope.ALL, BlockScope.ALL), None, None, 'mixin_agg_global') == \
'new mixin_agg_global'
assert get_key_value(Scope(UserScope.ALL, BlockScope.TYPE), None, 'TestXBlock', 'mixin_agg_type') == \
'new mixin_agg_type'
assert get_key_value(Scope(UserScope.ALL, BlockScope.DEFINITION), None, 'd0', 'mixin_agg_def') == \
'new mixin_agg_def'
assert get_key_value(Scope.user_state_summary, None, 'u0', 'mixin_agg_usage') == 'new mixin_agg_usage'
def test_field_serialization():
# Some Fields can define their own serialization mechanisms.
# This test ensures that we are using them properly.
class CustomField(Field):
"""
Specifiy a custom field that defines its own serialization
"""
def from_json(self, value):
return value['value']
def to_json(self, value):
return {'value': value}
class FieldTester(XBlock):
"""Test XBlock for field serialization testing"""
field = CustomField()
field_data = DictFieldData({
'field': {'value': 4}
})
field_tester = FieldTester(
TestRuntime(services={'field-data': field_data}),
None,
Mock(),
)
assert_equals(4, field_tester.field)
field_tester.field = 5
field_tester.save()
assert_equals({'value': 5}, field_data.get(field_tester, 'field'))
def test_cached_parent():
class HasParent(XBlock):
"""
Dummy empty class
"""
pass
runtime = TestRuntime(services={'field-data': DictFieldData({})})
runtime.get_block = Mock()
block = HasParent(runtime, scope_ids=Mock(spec=ScopeIds))
# block has no parent yet, and we don't need to call the runtime to find
# that out.
assert_equals(block.get_parent(), None)
assert not runtime.get_block.called
# Set a parent id for the block. Get the parent. Now we have one, and we
# used runtime.get_block to get it.
block.parent = "some_parent_id"
parent = block.get_parent()
assert_not_equals(parent, None)
assert runtime.get_block.called_with("some_parent_id")
# Get the parent again. It will be the same parent, and we didn't call the
# runtime.
runtime.get_block.reset_mock()
parent2 = block.get_parent()
assert parent2 is parent
assert not runtime.get_block.called
def test_get_mutable_mark_dirty():
"""
Ensure that accessing a mutable field type does not mark it dirty
if the field has never been set. If the field has been set, ensure
that it is set to dirty.
"""
class MutableTester(XBlock):
"""Test class with mutable fields."""
list_field = List(default=[])
mutable_test = MutableTester(TestRuntime(services={'field-data': DictFieldData({})}), scope_ids=Mock(spec=ScopeIds))
# Test get/set with a default value.
assert_equals(len(mutable_test._dirty_fields), 0)
_test_get = mutable_test.list_field
assert_equals(len(mutable_test._dirty_fields), 1)
mutable_test.list_field = []
assert_equals(len(mutable_test._dirty_fields), 1)
# Now test after having explicitly set the field.
mutable_test.save()
assert_equals(len(mutable_test._dirty_fields), 0)
_test_get = mutable_test.list_field
assert_equals(len(mutable_test._dirty_fields), 1)
def test_object_identity():
# Check that values that are modified are what is returned
class FieldTester(ScopedStorageMixin):
"""Toy class for ModelMetaclass and field access testing"""
field_a = List(scope=Scope.settings)
# Make sure that field_data always returns a different object
# each time it's actually queried, so that the caching is
# doing the work to maintain object identity.
field_data = MagicMock(spec=FieldData)
field_data.get = lambda block, name, default=None: [name] # pylint: disable=C0322
field_tester = FieldTester(
runtime=TestRuntime(services={'field-data': field_data}),
scope_ids=MagicMock(spec=ScopeIds)
)
value = field_tester.field_a
assert_equals(value, field_tester.field_a)
# Changing the field in place matches a previously fetched value
field_tester.field_a.append(1)
assert_equals(value, field_tester.field_a)
# Changing the previously-fetched value also changes the value returned by the field:
value.append(2)
assert_equals(value, field_tester.field_a)
# Deletion restores the default value. In the case of a List with
# no default defined, this is the empty list.
del field_tester.field_a
assert_equals([], field_tester.field_a)
def test_mixin_field_access():
field_data = DictFieldData({
'field_a': 5,
'field_x': [1, 2, 3],
})
runtime = TestRuntime(Mock(), mixins=[TestSimpleMixin], services={'field-data': field_data})
field_tester = runtime.construct_xblock_from_class(FieldTester, Mock())
assert_equals(5, field_tester.field_a)
assert_equals(10, field_tester.field_b)
assert_equals(42, field_tester.field_c)
assert_equals([1, 2, 3], field_tester.field_x)
assert_equals('default_value', field_tester.field_y)
field_tester.field_x = ['a', 'b']
field_tester.save()
assert_equals(['a', 'b'], field_tester._field_data.get(field_tester, 'field_x'))
del field_tester.field_x
assert_equals([], field_tester.field_x)
assert_equals([1, 2, 3], field_tester.field_x_with_default)
with assert_raises(AttributeError):
getattr(field_tester, 'field_z')
with assert_raises(AttributeError):
delattr(field_tester, 'field_z')
field_tester.field_z = 'foo'
assert_equals('foo', field_tester.field_z)
assert_false(field_tester._field_data.has(field_tester, 'field_z'))
def test_mutable_none_values():
# Check that fields with values intentionally set to None
# save properly.
class FieldTester(XBlock):
"""Test XBlock for field access testing"""
field_a = List(scope=Scope.settings)
field_b = List(scope=Scope.settings)
field_c = List(scope=Scope.content, default=None)
field_tester = FieldTester(
TestRuntime(services={'field-data': DictFieldData({'field_a': None})}),
scope_ids=Mock(spec=ScopeIds)
)
# Set fields b & c to None
field_tester.field_b = None
field_tester.field_c = None
# Save our changes
field_tester.save()
# Access the fields without modifying them. Want to call `__get__`, not `__set__`,
# because `__get__` marks only mutable fields as dirty.
_test_get = field_tester.field_a
_test_get = field_tester.field_b
_test_get = field_tester.field_c
# The previous accesses will mark the fields as dirty (via __get__)
assert_equals(len(field_tester._dirty_fields), 3) # pylint: disable=W0212
# However, the fields should not ACTUALLY be marked as fields that need to be saved.
assert_equals(len(field_tester._get_fields_to_save()), 0) # pylint: disable=W0212
def test_setting_the_same_value_marks_field_as_dirty():
"""
Check that setting field to the same value marks mutable fields as dirty.
However, since the value hasn't changed, these fields won't be saved.
"""
class FieldTester(XBlock):
"""Test block for set - get test."""
non_mutable = String(scope=Scope.settings)
list_field = List(scope=Scope.settings)
dict_field = Dict(scope=Scope.settings)
runtime = TestRuntime(services={'field-data': DictFieldData({})})
field_tester = FieldTester(runtime, scope_ids=Mock(spec=ScopeIds))
# precondition checks
assert_equals(len(field_tester._dirty_fields), 0)
assert_false(field_tester.fields['list_field'].is_set_on(field_tester))
assert_false(field_tester.fields['dict_field'].is_set_on(field_tester))
assert_false(field_tester.fields['non_mutable'].is_set_on(field_tester))
field_tester.non_mutable = field_tester.non_mutable
field_tester.list_field = field_tester.list_field
field_tester.dict_field = field_tester.dict_field
assert_not_in(field_tester.fields['non_mutable'],
field_tester._dirty_fields)
assert_in(field_tester.fields['list_field'], field_tester._dirty_fields)
assert_in(field_tester.fields['dict_field'], field_tester._dirty_fields)
assert_false(field_tester.fields['non_mutable'].is_set_on(field_tester))
assert_false(field_tester.fields['list_field'].is_set_on(field_tester))
assert_false(field_tester.fields['dict_field'].is_set_on(field_tester))
def setUp(self):
self.source = Mock()
self.read_only = ReadOnlyFieldData(self.source)
self.runtime = TestRuntime(services={'field-data': self.read_only})
self.block = TestingBlock(
runtime=self.runtime,
scope_ids=Mock(),
)
def setUp(self):
class TestBlock(XBlock):
"""Testing block for all field API tests"""
field = self.field_class(default=copy.deepcopy(self.field_default))
self.field_data = self.get_field_data()
self.runtime = TestRuntime(services={'field-data': self.field_data})
self.block = TestBlock(self.runtime, scope_ids=Mock(spec=ScopeIds))
def test_defaults_not_shared():
class FieldTester(XBlock):
"""Toy class for field access testing"""
field_a = List(scope=Scope.settings)
field_tester_a = FieldTester(TestRuntime(services={'field-data': DictFieldData({})}), scope_ids=Mock(spec=ScopeIds))
field_tester_b = FieldTester(TestRuntime(services={'field-data': DictFieldData({})}), scope_ids=Mock(spec=ScopeIds))
field_tester_a.field_a.append(1)
assert_equals([1], field_tester_a.field_a)
assert_equals([], field_tester_b.field_a)
# Write out the data
field_tester_a.save()
# Double check that write didn't do something weird
assert_equals([1], field_tester_a.field_a)
assert_equals([], field_tester_b.field_a)
def test_override_index_view(self):
test_runtime = TestRuntime(services={'field-data': DictFieldData({})})
test_xblock = self.TestIndexedXBlock(test_runtime, scope_ids=Mock(spec=ScopeIds))
index_info = test_xblock.index_dictionary()
self.assertTrue(index_info)
self.assertTrue(isinstance(index_info, dict))
self.assertEqual(index_info["test_field"], "ABC123")
def setUp(self):
field_data = TestModel(
{'field_a': {
'$type': 'set',
'$vals': [1, 2, 3]
}})
runtime = TestRuntime(services={'field-data': field_data})
self.block = TestBlock(runtime, scope_ids=Mock(spec=ScopeIds))
def test_dict_field_access():
# Check that dicts are correctly saved when not directly set
class FieldTester(XBlock):
"""Test XBlock for field access testing"""
field_a = Dict(scope=Scope.settings)
field_b = Dict(scope=Scope.content, default={'a': 1, 'b': 2, 'c': 3})
field_c = Dict(scope=Scope.content, default={'a': 4, 'b': 5, 'c': 6})
field_d = Dict(scope=Scope.settings)
field_data = DictFieldData({
'field_a': {'a': 200},
'field_b': {'a': 11, 'b': 12, 'c': 13}
})
field_tester = FieldTester(
TestRuntime(services={'field-data': field_data}),
None,
Mock()
)
# Check initial values have been set properly
assert_equals({'a': 200}, field_tester.field_a)
assert_equals({'a': 11, 'b': 12, 'c': 13}, field_tester.field_b)
assert_equals({'a': 4, 'b': 5, 'c': 6}, field_tester.field_c)
assert_equals({}, field_tester.field_d)
# Update the fields
field_tester.field_a['a'] = 250
field_tester.field_b['d'] = 14
field_tester.field_c['a'] = 0
field_tester.field_d['new'] = 'value'
# The fields should be update in the cache, but /not/ in the underlying kvstore.
assert_equals({'a': 250}, field_tester.field_a)
assert_equals({'a': 11, 'b': 12, 'c': 13, 'd': 14}, field_tester.field_b)
assert_equals({'a': 0, 'b': 5, 'c': 6}, field_tester.field_c)
assert_equals({'new': 'value'}, field_tester.field_d)
# Examine model data directly
# Caveat: there's not a clean way to copy the originally provided values for `field_a` and `field_b`
# when we instantiate the XBlock. So, the values for those two in both `field_data` and `_field_data_cache`
# point at the same object. Thus, `field_a` and `field_b` actually have the correct values in
# `field_data` right now. `field_c` does not, because it has never been written to the `field_data`.
assert_false(field_data.has(field_tester, 'field_c'))
assert_false(field_data.has(field_tester, 'field_d'))
field_tester.save()
# verify that the fields have been updated correctly
assert_equals({'a': 250}, field_tester.field_a)
assert_equals({'a': 11, 'b': 12, 'c': 13, 'd': 14}, field_tester.field_b)
assert_equals({'a': 0, 'b': 5, 'c': 6}, field_tester.field_c)
assert_equals({'new': 'value'}, field_tester.field_d)
# Now, the fields should be updated in the underlying kvstore
assert_equals({'a': 250}, field_data.get(field_tester, 'field_a'))
assert_equals({'a': 11, 'b': 12, 'c': 13, 'd': 14}, field_data.get(field_tester, 'field_b'))
assert_equals({'a': 0, 'b': 5, 'c': 6}, field_data.get(field_tester, 'field_c'))
assert_equals({'new': 'value'}, field_data.get(field_tester, 'field_d'))
def test_sub_service():
runtime = TestRuntime(id_reader=Mock(), services={
'secret_service': 17,
'field-data': DictFieldData({}),
})
tester = SubXBlockWithServices(runtime, scope_ids=Mock(spec=ScopeIds))
# Call the student_view to run its assertions.
runtime.render(tester, 'student_view')
def setUp(self):
"""
Create a test xblock with mock runtime.
"""
runtime = TestRuntime(Mock(entry_point=XBlock.entry_point),
mixins=[InheritanceMixin],
services={'field-data': {}})
self.xblock = runtime.construct_xblock_from_class(
TestXBlock, ScopeIds('user', 'TestXBlock', 'def_id', 'usage_id'))
super().setUp()
def _prepare_asides(self, scope_ids):
"""
Return list with connected aside xblocks
"""
key_store = DictKeyValueStore()
field_data = KvsFieldData(key_store)
aside = AsideTest(scope_ids=scope_ids, runtime=TestRuntime(services={'field-data': field_data})) # pylint: disable=abstract-class-instantiated
aside.fields[self.ASIDE_DATA_FIELD.field_name].write_to(aside, self.ASIDE_DATA_FIELD.initial)
return [aside]
def make_xblock(self, **kwargs):
key_store = DictKeyValueStore()
field_data = KvsFieldData(key_store)
runtime = TestRuntime(services={'field-data': field_data})
xblock = WistiaVideoXBlock(runtime, scope_ids=Mock())
for attr, val in kwargs.items():
setattr(xblock, attr, val)
return xblock
