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()
mutable_test_a = MutableTester(MagicMock(), DictFieldData({}), Mock())
mutable_test_b = MutableTester(MagicMock(), DictFieldData({}), Mock())
# 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):
mutable_test_a._field_data.get(mutable_test_a, 'list_field')
mutable_test_a.list_field.append(1)
mutable_test_a.save()
assert_equals([1],
mutable_test_a._field_data.get(mutable_test_a, 'list_field'))
with assert_raises(KeyError):
mutable_test_b._field_data.get(mutable_test_b, 'list_field')
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_runtime_handle():
# Test a simple handler and a fallback handler
key_store = DictKeyValueStore()
field_data = KvsFieldData(key_store)
runtime = TestRuntime(services={"field-data": field_data})
tester = TestXBlock(runtime, scope_ids=Mock(spec=ScopeIds))
runtime = MockRuntimeForQuerying()
# string we want to update using the handler
update_string = "user state update"
assert_equals(runtime.handle(tester, "existing_handler", update_string), "I am the existing test handler")
assert_equals(tester.user_state, update_string)
# when the handler needs to use the fallback as given name can't be found
new_update_string = "new update"
assert_equals(runtime.handle(tester, "test_fallback_handler", new_update_string), "I have been handled")
assert_equals(tester.user_state, new_update_string)
# request to use a handler which doesn't have XBlock.handler decoration
# should use the fallback
new_update_string = "new update"
assert_equals(runtime.handle(tester, "handler_without_correct_decoration", new_update_string), "gone to fallback")
assert_equals(tester.user_state, new_update_string)
# handler can't be found & no fallback handler supplied, should throw an exception
tester = TestXBlockNoFallback(runtime, scope_ids=Mock(spec=ScopeIds))
ultimate_string = "ultimate update"
with assert_raises(NoSuchHandlerError):
runtime.handle(tester, "test_nonexistant_fallback_handler", ultimate_string)
# request to use a handler which doesn't have XBlock.handler decoration
# and no fallback should raise NoSuchHandlerError
with assert_raises(NoSuchHandlerError):
runtime.handle(tester, "handler_without_correct_decoration", "handled")
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()
mutable_test_a = MutableTester(MagicMock(), DictFieldData({}), Mock())
mutable_test_b = MutableTester(MagicMock(), DictFieldData({}), Mock())
# 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):
mutable_test_a._field_data.get(mutable_test_a, 'list_field')
mutable_test_a.list_field.append(1)
mutable_test_a.save()
assert_equals([1], mutable_test_a._field_data.get(mutable_test_a, 'list_field'))
with assert_raises(KeyError):
mutable_test_b._field_data.get(mutable_test_b, 'list_field')
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_mixin_field_access():
field_data = DictFieldData({
'field_a': 5,
'field_x': [1, 2, 3],
})
runtime = TestRuntime(Mock(), field_data, [TestSimpleMixin])
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('field c', 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_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_field_access():
class FieldTester(XBlock):
"""Test XBlock for field access testing"""
field_a = Integer(scope=Scope.settings)
field_b = Integer(scope=Scope.content, default=10)
field_c = Integer(scope=Scope.user_state, default=42)
float_a = Float(scope=Scope.settings, default=5.8)
float_b = Float(scope=Scope.settings)
field_tester = FieldTester(
MagicMock(),
DictFieldData({
'field_a': 5,
'float_a': 6.1,
'field_x': 15
}), Mock())
# Verify that the fields have been set
assert_equals(5, field_tester.field_a)
assert_equals(10, field_tester.field_b)
assert_equals(42, field_tester.field_c)
assert_equals(6.1, field_tester.float_a)
assert_equals(None, field_tester.float_b)
assert not hasattr(field_tester, 'field_x')
# Set two of the fields.
field_tester.field_a = 20
field_tester.float_a = 20.5
# field_a should be updated in the cache, but /not/ in the underlying db.
assert_equals(20, field_tester.field_a)
assert_equals(20.5, field_tester.float_a)
assert_equals(5, field_tester._field_data.get(field_tester, 'field_a'))
assert_equals(6.1, field_tester._field_data.get(field_tester, 'float_a'))
# save the XBlock
field_tester.save()
# verify that the fields have been updated correctly
assert_equals(20, field_tester.field_a)
assert_equals(20.5, field_tester.float_a)
# Now, field_a should be updated in the underlying db
assert_equals(20, field_tester._field_data.get(field_tester, 'field_a'))
assert_equals(20.5, field_tester._field_data.get(field_tester, 'float_a'))
assert_equals(10, field_tester.field_b)
assert_equals(42, field_tester.field_c)
assert_equals(None, field_tester.float_b)
# Deletes happen immediately (do not require a save)
del field_tester.field_a
del field_tester.float_a
# After delete, we should find default values in the cache
assert_equals(None, field_tester.field_a)
assert_equals(5.8, field_tester.float_a)
# But the fields should not actually be present in the underlying kvstore
with assert_raises(KeyError):
field_tester._field_data.get(field_tester, 'field_a')
assert_false(field_tester._field_data.has(field_tester, 'field_a'))
with assert_raises(KeyError):
field_tester._field_data.get(field_tester, 'float_a')
assert_false(field_tester._field_data.has(field_tester, 'float_a'))
def test_bad_parameters(self):
"""
Test that `TypeError`s are thrown for bad input parameters.
"""
with assert_raises(TypeError):
ValidationMessage("unknown type", "Unknown type info")
with assert_raises(TypeError):
ValidationMessage(ValidationMessage.WARNING, b"Non-unicode message")
def test_delete(self):
assert_equals(1, self.agg.first)
del self.agg.first
assert_false(hasattr(self.first, 'first'))
with assert_raises(AttributeError):
self.agg.first # pylint: disable=W0104
with assert_raises(AttributeError):
del self.agg.other
def test_bad_parameters(self):
"""
Test that `TypeError`s are thrown for bad input parameters.
"""
with assert_raises(TypeError):
ValidationMessage("unknown type", u"Unknown type info")
with assert_raises(TypeError):
ValidationMessage(ValidationMessage.WARNING, "Non-unicode message")
def test_delete(self):
assert_equals(1, self.agg.first)
del self.agg.first
assert_false(hasattr(self.first, 'first'))
with assert_raises(AttributeError):
self.agg.first # pylint: disable=W0104
with assert_raises(AttributeError):
del self.agg.other
def test_field_access():
class FieldTester(XBlock):
"""Test XBlock for field access testing"""
field_a = Integer(scope=Scope.settings)
field_b = Integer(scope=Scope.content, default=10)
field_c = Integer(scope=Scope.user_state, default=42)
float_a = Float(scope=Scope.settings, default=5.8)
float_b = Float(scope=Scope.settings)
field_data = DictFieldData({"field_a": 5, "float_a": 6.1, "field_x": 15})
field_tester = FieldTester(TestRuntime(services={"field-data": field_data}), scope_ids=Mock())
# Verify that the fields have been set
assert_equals(5, field_tester.field_a)
assert_equals(10, field_tester.field_b)
assert_equals(42, field_tester.field_c)
assert_equals(6.1, field_tester.float_a)
assert_equals(None, field_tester.float_b)
assert not hasattr(field_tester, "field_x")
# Set two of the fields.
field_tester.field_a = 20
field_tester.float_a = 20.5
# field_a should be updated in the cache, but /not/ in the underlying db.
assert_equals(20, field_tester.field_a)
assert_equals(20.5, field_tester.float_a)
assert_equals(5, field_data.get(field_tester, "field_a"))
assert_equals(6.1, field_data.get(field_tester, "float_a"))
# save the XBlock
field_tester.save()
# verify that the fields have been updated correctly
assert_equals(20, field_tester.field_a)
assert_equals(20.5, field_tester.float_a)
# Now, field_a should be updated in the underlying db
assert_equals(20, field_data.get(field_tester, "field_a"))
assert_equals(20.5, field_data.get(field_tester, "float_a"))
assert_equals(10, field_tester.field_b)
assert_equals(42, field_tester.field_c)
assert_equals(None, field_tester.float_b)
# Deletes happen immediately (do not require a save)
del field_tester.field_a
del field_tester.float_a
# After delete, we should find default values in the cache
assert_equals(None, field_tester.field_a)
assert_equals(5.8, field_tester.float_a)
# But the fields should not actually be present in the underlying kvstore
with assert_raises(KeyError):
field_data.get(field_tester, "field_a")
assert_false(field_data.has(field_tester, "field_a"))
with assert_raises(KeyError):
field_data.get(field_tester, "float_a")
assert_false(field_data.has(field_tester, "float_a"))
def test_bad_parameters(self):
"""
Test that `TypeError`s are thrown for bad input parameters.
"""
with assert_raises(TypeError):
StudioValidationMessage("unknown type", u"Unknown type info")
with assert_raises(TypeError):
StudioValidationMessage(StudioValidationMessage.WARNING, u"bad warning", action_class=0)
with assert_raises(TypeError):
StudioValidationMessage(StudioValidationMessage.WARNING, u"bad warning", action_runtime_event=0)
with assert_raises(TypeError):
StudioValidationMessage(StudioValidationMessage.WARNING, u"bad warning", action_label="Non-unicode string")
def test_bad_parameters(self):
"""
Test that `TypeError`s are thrown for bad input parameters.
"""
with assert_raises(TypeError):
StudioValidationMessage("unknown type", u"Unknown type info")
with assert_raises(TypeError):
StudioValidationMessage(StudioValidationMessage.WARNING, u"bad warning", action_class=0)
with assert_raises(TypeError):
StudioValidationMessage(StudioValidationMessage.WARNING, u"bad warning", action_runtime_event=0)
with assert_raises(TypeError):
StudioValidationMessage(StudioValidationMessage.WARNING, u"bad warning", action_label="Non-unicode string")
def test_runtime_render():
key_store = DictKeyValueStore()
field_data = KvsFieldData(key_store)
runtime = MockRuntimeForQuerying(services={'field-data': field_data})
tester = TestXBlock(runtime, scope_ids=Mock(spec=ScopeIds))
# string we want to update using the handler
update_string = u"user state update"
# test against the student view
frag = runtime.render(tester, 'student_view', [update_string])
assert_equals(frag.body_html(), update_string)
assert_equals(tester.preferences, update_string)
# test against the fallback view
update_string = u"new update"
frag = runtime.render(tester, 'test_fallback_view', [update_string])
assert_equals(frag.body_html(), update_string)
assert_equals(tester.preferences, update_string)
# test block-first
update_string = u"penultimate update"
frag = tester.render('student_view', [update_string])
assert_equals(frag.body_html(), update_string)
assert_equals(tester.preferences, update_string)
# test against the no-fallback XBlock
update_string = u"ultimate update"
tester = TestXBlockNoFallback(Mock(), scope_ids=Mock(spec=ScopeIds))
with assert_raises(NoSuchViewError):
runtime.render(tester, 'test_nonexistant_view', [update_string])
def test_dummy_user_service_exception():
"""
Tests NotImplemented error raised by UserService when not instantiated with kwarg get_current_user
"""
user_service = UserService()
with assert_raises(NotImplementedError):
user_service.get_current_user()
def test_dummy_user_service_exception():
"""
Tests NotImplemented error raised by UserService when not instantiated with kwarg get_current_user
"""
user_service = UserService()
with assert_raises(NotImplementedError):
user_service.get_current_user()
def test_runtime_render():
key_store = DictKeyValueStore()
db_model = KvsFieldData(key_store)
runtime = MockRuntimeForQuerying()
tester = TestXBlock(runtime, db_model, Mock())
# string we want to update using the handler
update_string = u"user state update"
# test against the student view
frag = runtime.render(tester, 'student_view', [update_string])
assert_equals(frag.body_html(), update_string)
assert_equals(tester.preferences, update_string)
# test against the fallback view
update_string = u"new update"
frag = runtime.render(tester, 'test_fallback_view', [update_string])
assert_equals(frag.body_html(), update_string)
assert_equals(tester.preferences, update_string)
# test block-first
update_string = u"penultimate update"
frag = tester.render('student_view', [update_string])
assert_equals(frag.body_html(), update_string)
assert_equals(tester.preferences, update_string)
# test against the no-fallback XBlock
update_string = u"ultimate update"
tester = TestXBlockNoFallback(Mock(), db_model, Mock())
with assert_raises(NoSuchViewError):
runtime.render(tester, 'test_nonexistant_view', [update_string])
def student_view(self, _context):
"""Try out some services."""
# i18n is available, and works.
def assert_equals_unicode(str1, str2):
"""`str1` equals `str2`, and both are Unicode strings."""
assert_equals(str1, str2)
assert isinstance(str1, unicode)
assert isinstance(str2, unicode)
i18n = self.runtime.service(self, "i18n")
assert_equals_unicode(u"Welcome!", i18n.ugettext("Welcome!"))
assert_equals_unicode(u"Plural", i18n.ungettext("Singular", "Plural", 0))
assert_equals_unicode(u"Singular", i18n.ungettext("Singular", "Plural", 1))
assert_equals_unicode(u"Plural", i18n.ungettext("Singular", "Plural", 2))
# secret_service is available.
assert_equals(self.runtime.service(self, "secret_service"), 17)
# no_such_service is not available, and raises an exception, because we
# said we needed it.
with assert_raises(NoSuchServiceError):
self.runtime.service(self, "no_such_service")
# another_not_service is not available, and returns None, because we
# didn't need it, we only wanted it.
assert_is(self.runtime.service(self, "another_not_service"), None)
def test_xblock_save_one():
# Mimics a save failure when we only manage to save one of the values
# Pylint, please allow this method to accept arguments.
# pylint: disable=W0613
def fake_set_many(block, update_dict):
"""Mock update method that throws a KeyValueMultiSaveError indicating
that only one field was correctly saved."""
raise KeyValueMultiSaveError([update_dict.keys()[0]])
# pylint: enable=W0613
field_tester = setup_save_failure(fake_set_many)
field_tester.field_a = 20
field_tester.field_b = 40
field_tester.field_c = 60
with assert_raises(XBlockSaveError) as save_error:
# This call should raise an XBlockSaveError
field_tester.save()
# Verify that the correct data is getting stored by the error
assert_equals(len(save_error.exception.saved_fields), 1)
assert_equals(len(save_error.exception.dirty_fields), 2)
def test_runtime_render():
key_store = DictKeyValueStore()
db_model = DbModel(key_store)
runtime = MockRuntimeForQuerying()
tester = TestXBlock(runtime, db_model, Mock())
# string we want to update using the handler
update_string = u"user state update"
# test against the student view
frag = runtime.render(tester, 'student_view', [update_string])
assert_equals(frag.body_html(), update_string)
assert_equals(tester.preferences, update_string)
# test against the fallback view
update_string = u"new update"
frag = runtime.render(tester, 'test_fallback_view', [update_string])
assert_equals(frag.body_html(), update_string)
assert_equals(tester.preferences, update_string)
# test block-first
update_string = u"penultimate update"
frag = tester.render('student_view', [update_string])
assert_equals(frag.body_html(), update_string)
assert_equals(tester.preferences, update_string)
# test against the no-fallback XBlock
update_string = u"ultimate update"
tester = TestXBlockNoFallback(Mock(), db_model, Mock())
with assert_raises(NoSuchViewError):
runtime.render(tester, 'test_nonexistant_view', [update_string])
def test_runtime_render():
key_store = DictKeyValueStore()
field_data = KvsFieldData(key_store)
runtime = MockRuntimeForQuerying(services={'field-data': field_data})
block_type = 'test'
def_id = runtime.id_generator.create_definition(block_type)
usage_id = runtime.id_generator.create_usage(def_id)
tester = TestXBlock(runtime, scope_ids=ScopeIds('user', block_type, def_id, usage_id))
# string we want to update using the handler
update_string = u"user state update"
# test against the student view
frag = runtime.render(tester, 'student_view', [update_string])
assert_in(update_string, frag.body_html())
assert_equals(tester.preferences, update_string)
# test against the fallback view
update_string = u"new update"
frag = runtime.render(tester, 'test_fallback_view', [update_string])
assert_in(update_string, frag.body_html())
assert_equals(tester.preferences, update_string)
# test block-first
update_string = u"penultimate update"
frag = tester.render('student_view', [update_string])
assert_in(update_string, frag.body_html())
assert_equals(tester.preferences, update_string)
# test against the no-fallback XBlock
update_string = u"ultimate update"
tester = TestXBlockNoFallback(Mock(), scope_ids=Mock(spec=ScopeIds))
with assert_raises(NoSuchViewError):
runtime.render(tester, 'test_nonexistent_view', [update_string])
def test_runtime_render():
key_store = DictKeyValueStore()
field_data = KvsFieldData(key_store)
runtime = MockRuntimeForQuerying(services={'field-data': field_data})
block_type = 'test'
def_id = runtime.id_generator.create_definition(block_type)
usage_id = runtime.id_generator.create_usage(def_id)
tester = TestXBlock(runtime, scope_ids=ScopeIds('user', block_type, def_id, usage_id))
# string we want to update using the handler
update_string = "user state update"
# test against the student view
frag = runtime.render(tester, 'student_view', [update_string])
assert_in(update_string, frag.body_html())
assert_equals(tester.preferences, update_string)
# test against the fallback view
update_string = "new update"
frag = runtime.render(tester, 'test_fallback_view', [update_string])
assert_in(update_string, frag.body_html())
assert_equals(tester.preferences, update_string)
# test block-first
update_string = "penultimate update"
frag = tester.render('student_view', [update_string])
assert_in(update_string, frag.body_html())
assert_equals(tester.preferences, update_string)
# test against the no-fallback XBlock
update_string = "ultimate update"
no_fallback_tester = TestXBlockNoFallback(Mock(), scope_ids=Mock(spec=ScopeIds))
with assert_raises(NoSuchViewError):
runtime.render(no_fallback_tester, 'test_nonexistent_view', [update_string])
def test_add_messages_error(self):
"""
Test that calling `add_messages` with something that is not a `Validation` instances throw an error.
"""
validation = Validation("id")
with assert_raises(TypeError):
validation.add_messages("foo")
def test_add_messages_error(self):
"""
Test that calling `add_messages` with something that is not a `Validation` instances throw an error.
"""
validation = Validation("id")
with assert_raises(TypeError):
validation.add_messages("foo")
def test_set(self):
assert_equals(1, self.agg.first)
self.agg.first = 10
assert_equals(10, self.agg.first)
assert_equals(10, self.first.first) # pylint: disable=E1101
with assert_raises(AttributeError):
self.agg.other = 99
assert_false(hasattr(self.first, 'other'))
assert_false(hasattr(self.second, 'other'))
def test_runtime_handle():
# Test a simple handler and a fallback handler
key_store = DictKeyValueStore()
field_data = KvsFieldData(key_store)
test_runtime = TestRuntime(services={'field-data': field_data})
basic_tester = TestXBlock(test_runtime, scope_ids=Mock(spec=ScopeIds))
runtime = MockRuntimeForQuerying()
# string we want to update using the handler
update_string = "user state update"
assert_equals(
runtime.handle(basic_tester, 'existing_handler', update_string),
'I am the existing test handler')
assert_equals(basic_tester.user_state, update_string)
# when the handler needs to use the fallback as given name can't be found
new_update_string = "new update"
assert_equals(
runtime.handle(basic_tester, 'test_fallback_handler',
new_update_string), 'I have been handled')
assert_equals(basic_tester.user_state, new_update_string)
# request to use a handler which doesn't have XBlock.handler decoration
# should use the fallback
new_update_string = "new update"
assert_equals(
runtime.handle(basic_tester, 'handler_without_correct_decoration',
new_update_string), 'gone to fallback')
assert_equals(basic_tester.user_state, new_update_string)
# handler can't be found & no fallback handler supplied, should throw an exception
no_fallback_tester = TestXBlockNoFallback(runtime,
scope_ids=Mock(spec=ScopeIds))
ultimate_string = "ultimate update"
with assert_raises(NoSuchHandlerError):
runtime.handle(no_fallback_tester, 'test_nonexistant_fallback_handler',
ultimate_string)
# request to use a handler which doesn't have XBlock.handler decoration
# and no fallback should raise NoSuchHandlerError
with assert_raises(NoSuchHandlerError):
runtime.handle(no_fallback_tester,
'handler_without_correct_decoration', 'handled')
def test_set(self):
assert_equals(1, self.agg.first)
self.agg.first = 10
assert_equals(10, self.agg.first)
assert_equals(10, self.first.first) # pylint: disable=E1101
with assert_raises(AttributeError):
self.agg.other = 99
assert_false(hasattr(self.first, 'other'))
assert_false(hasattr(self.second, 'other'))
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_runtime_handle():
# Test a simple handler and a fallback handler
key_store = DictKeyValueStore()
db_model = DbModel(key_store)
tester = TestXBlock(Mock(), db_model, Mock())
runtime = MockRuntimeForQuerying()
# string we want to update using the handler
update_string = "user state update"
assert_equals(runtime.handle(tester, 'existing_handler', update_string),
'I am the existing test handler')
assert_equals(tester.user_state, update_string)
# when the handler needs to use the fallback as given name can't be found
new_update_string = "new update"
assert_equals(runtime.handle(tester, 'test_fallback_handler', new_update_string),
'I have been handled')
assert_equals(tester.user_state, new_update_string)
# request to use a handler which doesn't have XBlock.handler decoration
# should use the fallback
new_update_string = "new update"
assert_equals(runtime.handle(tester, 'handler_without_correct_decoration', new_update_string),
'gone to fallback')
assert_equals(tester.user_state, new_update_string)
# handler can't be found & no fallback handler supplied, should throw an exception
tester = TestXBlockNoFallback(Mock(), db_model, Mock())
ultimate_string = "ultimate update"
with assert_raises(NoSuchHandlerError):
runtime.handle(tester, 'test_nonexistant_fallback_handler', ultimate_string)
# request to use a handler which doesn't have XBlock.handler decoration
# and no fallback should raise NoSuchHandlerError
with assert_raises(NoSuchHandlerError):
runtime.handle(tester, 'handler_without_correct_decoration', 'handled')
def test_runtime_handle():
# Test a simple handler and a fallback handler
key_store = DictKeyValueStore()
db_model = DbModel(key_store)
tester = TestXBlock(Mock(), db_model, Mock())
runtime = MockRuntimeForQuerying()
# string we want to update using the handler
update_string = "user state update"
assert_equals(runtime.handle(tester, 'existing_handler', update_string),
'I am the existing test handler')
assert_equals(tester.user_state, update_string)
# when the handler needs to use the fallback as given name can't be found
new_update_string = "new update"
assert_equals(runtime.handle(tester, 'test_fallback_handler', new_update_string),
'I have been handled')
assert_equals(tester.user_state, new_update_string)
# request to use a handler which doesn't have XBlock.handler decoration
# should use the fallback
new_update_string = "new update"
assert_equals(runtime.handle(tester, 'handler_without_correct_decoration', new_update_string),
'gone to fallback')
assert_equals(tester.user_state, new_update_string)
# handler can't be found & no fallback handler supplied, should throw an exception
tester = TestXBlockNoFallback(Mock(), db_model, Mock())
ultimate_string = "ultimate update"
with assert_raises(NoSuchHandlerError):
runtime.handle(tester, 'test_nonexistant_fallback_handler', ultimate_string)
# request to use a handler which doesn't have XBlock.handler decoration
# and no fallback should raise NoSuchHandlerError
with assert_raises(NoSuchHandlerError):
runtime.handle(tester, 'handler_without_correct_decoration', 'handled')
def test_ugettext_calls():
"""
Test ugettext calls in xblock.
"""
runtime = TestRuntime()
block = XBlockWithServices(runtime, scope_ids=Mock(spec=[]))
assert_equals(block.ugettext('test'), 'test')
assert_true(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 assert_raises(NoSuchServiceError):
block.ugettext('test')
def test_xblock_without_handler():
# Test that an XBlock without a handler raises an Exception
# when we try to hit a handler on it
client = Client()
# Pick a random usage_id from the USAGE_STORE because we
# need to ensure the usage is a valid id.
# TODO: Make a usage in this test instead.
usage_id = USAGE_STORE._usages.keys()[0]
# Plug that usage_id into a mock handler URL
# /handler/[usage_id]/[handler_name]
handler_url = "/handler/" + usage_id + "/does_not_exist/?student=student_doesntexist"
# The default XBlock implementation doesn't provide
# a handler, so this call should raise an exception
# (from xblock.runtime.Runtime.handle)
with assert_raises(NoSuchHandlerError):
client.post(handler_url, '{}', 'text/json')
def test_xblock_without_handler():
# Test that an XBlock without a handler raises an Exception
# when we try to hit a handler on it
client = Client()
# Pick the most usage ID we just made in the temp_scenario setup...
usage_id = ID_MANAGER.last_created_usage_id()
# Plug that usage_id into a mock handler URL
# /handler/[usage_id]/[handler_name]
handler_url = (
reverse("handler", kwargs={"usage_id": usage_id, "handler_slug": "does_not_exist", "suffix": ""})
+ "?student=student_doesntexist"
)
# The default XBlock implementation doesn't provide
# a handler, so this call should raise an exception
# (from xblock.runtime.Runtime.handle)
with assert_raises(NoSuchHandlerError):
client.post(handler_url, "{}", "text/json")
def test_xblock_save_failure_none():
# Mimics a save failure when we don't manage to save any of the values
def fake_set_many(block, update_dict): # pylint: disable=unused-argument
"""Mock update method that throws a KeyValueMultiSaveError indicating
that no fields were correctly saved."""
raise KeyValueMultiSaveError([])
field_tester = setup_save_failure(fake_set_many)
field_tester.field_a = 20
field_tester.field_b = 30
field_tester.field_c = 40
with assert_raises(XBlockSaveError) as save_error:
# This call should raise an XBlockSaveError
field_tester.save()
# Verify that the correct data is getting stored by the error
assert_equals(len(save_error.exception.saved_fields), 0)
assert_equals(len(save_error.exception.dirty_fields), 3)
def test_xblock_without_handler():
# Test that an XBlock without a handler raises an Exception
# when we try to hit a handler on it
client = Client()
# Pick the most-recent usage ID just made in the temp_scenario setup...
usage_id = ID_MANAGER.last_created_usage_id()
# Plug that usage_id into a mock handler URL
# /handler/[usage_id]/[handler_name]
handler_url = reverse('handler', kwargs={
'usage_id': usage_id,
'handler_slug': 'does_not_exist',
'suffix': ''
}) + '?student=student_doesntexist'
# The default XBlock implementation doesn't provide
# a handler, so this call should raise an exception
# (from xblock.runtime.Runtime.handle)
with assert_raises(NoSuchHandlerError):
client.post(handler_url, '{}', 'text/json')
def test_xblock_without_handler():
# Test that an XBlock without a handler raises an Exception
# when we try to hit a handler on it
client = Client()
# Pick a random usage_id from the USAGE_STORE because we
# need to ensure the usage is a valid id.
# TODO: Make a usage in this test instead.
usage_id = USAGE_STORE._usages.keys()[0]
# Plug that usage_id into a mock handler URL
# /handler/[usage_id]/[handler_name]
handler_url = reverse('handler', kwargs={
'usage_id': usage_id,
'handler_slug': 'does_not_exist',
'suffix': ''
}) + '?student=student_doesntexist'
# The default XBlock implementation doesn't provide
# a handler, so this call should raise an exception
# (from xblock.runtime.Runtime.handle)
with assert_raises(NoSuchHandlerError):
client.post(handler_url, '{}', 'text/json')
def test_xblock_without_handler():
# Test that an XBlock without a handler raises an Exception
# when we try to hit a handler on it
client = Client()
# Pick the most usage ID we just made in the temp_scenario setup...
usage_id = ID_MANAGER.last_created_usage_id()
# Plug that usage_id into a mock handler URL
# /handler/[usage_id]/[handler_name]
handler_url = reverse('handler',
kwargs={
'usage_id': usage_id,
'handler_slug': 'does_not_exist',
'suffix': ''
}) + '?student=student_doesntexist'
# The default XBlock implementation doesn't provide
# a handler, so this call should raise an exception
# (from xblock.runtime.Runtime.handle)
with assert_raises(NoSuchHandlerError):
client.post(handler_url, '{}', 'text/json')
def test_xblock_without_handler():
# Test that an XBlock without a handler raises an Exception
# when we try to hit a handler on it
client = Client()
# Pick a random usage_id from the ID_MANAGER because we
# need to ensure the usage is a valid id.
# TODO: Make a usage in this test instead.
usage_id = ID_MANAGER._usages.keys()[0]
# Plug that usage_id into a mock handler URL
# /handler/[usage_id]/[handler_name]
handler_url = reverse('handler', kwargs={
'usage_id': usage_id,
'handler_slug': 'does_not_exist',
'suffix': ''
}) + '?student=student_doesntexist'
# The default XBlock implementation doesn't provide
# a handler, so this call should raise an exception
# (from xblock.runtime.Runtime.handle)
with assert_raises(NoSuchHandlerError):
client.post(handler_url, '{}', 'text/json')
def test_xblock_save_one():
# Mimics a save failure when we only manage to save one of the values
# Pylint, please allow this method to accept arguments.
# pylint: disable=W0613
def fake_set_many(block, update_dict):
"""Mock update method that throws a KeyValueMultiSaveError indicating
that only one field was correctly saved."""
raise KeyValueMultiSaveError([update_dict.keys()[0]])
# pylint: enable=W0613
field_tester = setup_save_failure(fake_set_many)
field_tester.field_a = 20
field_tester.field_b = 40
field_tester.field_c = 60
with assert_raises(XBlockSaveError) as save_error:
# This call should raise an XBlockSaveError
field_tester.save()
# Verify that the correct data is getting stored by the error
assert_equals(len(save_error.exception.saved_fields), 1)
assert_equals(len(save_error.exception.dirty_fields), 2)
def test_get(self):
assert_equals(1, self.agg.first)
assert_equals(2, self.agg.second)
assert_false(hasattr(self.agg, 'other'))
with assert_raises(AttributeError):
self.agg.other # pylint: disable=W0104
def test_delete(self):
with assert_raises(InvalidScopeError):
self.read_only.delete(self.block, 'content')
def test_set_many(self):
with assert_raises(InvalidScopeError):
self.read_only.set_many(self.block, {
'content': 'foo',
'settings': 'bar'
})
def test_invalid_scope(self):
with assert_raises(InvalidScopeError):
self.split.get(self.block, 'user_state')
def test_set_many(self):
with assert_raises(InvalidScopeError):
self.read_only.set_many(self.block, {'content': 'foo', 'settings': 'bar'})
def test_set(self):
with assert_raises(InvalidScopeError):
self.read_only.set(self.block, 'content', 'foo')
def test_get(self):
assert_equals(1, self.agg.first)
assert_equals(2, self.agg.second)
assert_false(hasattr(self.agg, 'other'))
with assert_raises(AttributeError):
self.agg.other # pylint: disable=W0104
def test_copy_errors(self):
with assert_raises(TypeError):
StudioValidation.copy("foo")
def test_set_summary_errors(self):
"""
Test that `set_summary` errors if argument is not a ValidationMessage.
"""
with assert_raises(TypeError):
StudioValidation("id").set_summary("foo")
def test_set(self):
with assert_raises(InvalidScopeError):
self.read_only.set(self.block, 'content', 'foo')
def test_set_summary_errors(self):
"""
Test that `set_summary` errors if argument is not a ValidationMessage.
"""
with assert_raises(TypeError):
StudioValidation("id").set_summary("foo")
def test_invalid_scope(self):
with assert_raises(InvalidScopeError):
self.split.get(self.block, 'user_state')
def test_copy_errors(self):
with assert_raises(TypeError):
StudioValidation.copy("foo")