def setUp(self): """ Setting up tests """ super(TestSettingsService, self).setUp() # lint-amnesty, pylint: disable=super-with-arguments self.settings_service = SettingsService() self.xblock_mock = mock.Mock() self.xblock_mock.block_settings_key = self.xblock_setting_key1 self.xblock_mock.unmixed_class = mock.Mock() self.xblock_mock.unmixed_class.__name__ = self.xblock_setting_key2
def setUp(self): """ Setting up tests """ super(TestSettingsService, self).setUp() self.settings_service = SettingsService() self.xblock_mock = mock.Mock() self.xblock_mock.block_settings_key = self.xblock_setting_key1 self.xblock_mock.unmixed_class = mock.Mock() self.xblock_mock.unmixed_class.__name__ = self.xblock_setting_key2
class TestSettingsService(unittest.TestCase): """ Test SettingsService """ xblock_setting_key1 = 'dummy_block' xblock_setting_key2 = 'other_dummy_block' def setUp(self): """ Setting up tests """ super().setUp() self.settings_service = SettingsService() self.xblock_mock = mock.Mock() self.xblock_mock.block_settings_key = self.xblock_setting_key1 self.xblock_mock.unmixed_class = mock.Mock() self.xblock_mock.unmixed_class.__name__ = self.xblock_setting_key2 def test_get_given_none_throws_value_error(self): """ Test that given None throws value error """ with pytest.raises(ValueError): self.settings_service.get_settings_bucket(None) def test_get_return_default_if_xblock_settings_is_missing(self): """ Test that returns default (or None if default not set) if XBLOCK_SETTINGS is not set """ assert not hasattr(settings, 'XBLOCK_SETTINGS') # precondition check assert self.settings_service.get_settings_bucket(self.xblock_mock, 'zzz') == 'zzz' def test_get_return_empty_dictionary_if_xblock_settings_and_default_is_missing(self): """ Test that returns default (or None if default not set) if XBLOCK_SETTINGS is not set """ assert not hasattr(settings, 'XBLOCK_SETTINGS') # precondition check assert self.settings_service.get_settings_bucket(self.xblock_mock) == {} @override_settings(XBLOCK_SETTINGS={xblock_setting_key2: {'b': 1}}) def test_get_returns_none_or_default_if_bucket_not_found(self): """ Test if settings service returns default if setting not found """ assert settings.XBLOCK_SETTINGS == {self.xblock_setting_key2: {'b': 1}} assert self.settings_service.get_settings_bucket(self.xblock_mock) == {} assert self.settings_service.get_settings_bucket(self.xblock_mock, 123) == 123 @override_settings(XBLOCK_SETTINGS={xblock_setting_key1: 42}) def test_get_returns_correct_value(self): """ Test if settings service returns correct bucket """ assert settings.XBLOCK_SETTINGS == {self.xblock_setting_key1: 42} assert self.settings_service.get_settings_bucket(self.xblock_mock) == 42 @override_settings(XBLOCK_SETTINGS={xblock_setting_key2: "I'm a setting"}) def test_get_respects_block_settings_key(self): """ Test if settings service respects block_settings_key value """ assert settings.XBLOCK_SETTINGS == {self.xblock_setting_key2: "I'm a setting"} self.xblock_mock.block_settings_key = self.xblock_setting_key2 assert self.settings_service.get_settings_bucket(self.xblock_mock) == "I'm a setting" @override_settings(XBLOCK_SETTINGS={_DummyBlock.__name__: [1, 2, 3]}) def test_get_uses_class_name_if_block_settings_key_is_not_set(self): """ Test if settings service uses class name if block_settings_key attribute does not exist """ mixologist = Mixologist([]) block = mixologist.mix(_DummyBlock) assert settings.XBLOCK_SETTINGS == {'_DummyBlock': [1, 2, 3]} assert self.settings_service.get_settings_bucket(block) == [1, 2, 3]
class TestSettingsService(TestCase): """ Test SettingsService """ shard = 1 xblock_setting_key1 = 'dummy_block' xblock_setting_key2 = 'other_dummy_block' def setUp(self): """ Setting up tests """ super(TestSettingsService, self).setUp() self.settings_service = SettingsService() self.xblock_mock = mock.Mock() self.xblock_mock.block_settings_key = self.xblock_setting_key1 self.xblock_mock.unmixed_class = mock.Mock() self.xblock_mock.unmixed_class.__name__ = self.xblock_setting_key2 def test_get_given_none_throws_value_error(self): """ Test that given None throws value error """ with self.assertRaises(ValueError): self.settings_service.get_settings_bucket(None) def test_get_return_default_if_xblock_settings_is_missing(self): """ Test that returns default (or None if default not set) if XBLOCK_SETTINGS is not set """ self.assertFalse(hasattr(settings, 'XBLOCK_SETTINGS')) # precondition check self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock, 'zzz'), 'zzz') def test_get_return_empty_dictionary_if_xblock_settings_and_default_is_missing(self): """ Test that returns default (or None if default not set) if XBLOCK_SETTINGS is not set """ self.assertFalse(hasattr(settings, 'XBLOCK_SETTINGS')) # precondition check self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), {}) @override_settings(XBLOCK_SETTINGS={xblock_setting_key2: {'b': 1}}) def test_get_returns_none_or_default_if_bucket_not_found(self): """ Test if settings service returns default if setting not found """ self.assertEqual(settings.XBLOCK_SETTINGS, {self.xblock_setting_key2: {'b': 1}}) self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), {}) self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock, 123), 123) @override_settings(XBLOCK_SETTINGS={xblock_setting_key1: 42}) def test_get_returns_correct_value(self): """ Test if settings service returns correct bucket """ self.assertEqual(settings.XBLOCK_SETTINGS, {self.xblock_setting_key1: 42}) self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), 42) @override_settings(XBLOCK_SETTINGS={xblock_setting_key2: "I'm a setting"}) def test_get_respects_block_settings_key(self): """ Test if settings service respects block_settings_key value """ self.assertEqual(settings.XBLOCK_SETTINGS, {self.xblock_setting_key2: "I'm a setting"}) self.xblock_mock.block_settings_key = self.xblock_setting_key2 self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), "I'm a setting") @override_settings(XBLOCK_SETTINGS={_DummyBlock.__name__: [1, 2, 3]}) def test_get_uses_class_name_if_block_settings_key_is_not_set(self): """ Test if settings service uses class name if block_settings_key attribute does not exist """ mixologist = Mixologist([]) block = mixologist.mix(_DummyBlock) self.assertEqual(settings.XBLOCK_SETTINGS, {"_DummyBlock": [1, 2, 3]}) self.assertEqual(self.settings_service.get_settings_bucket(block), [1, 2, 3])
class TestSettingsService(TestCase): """ Test SettingsService """ xblock_setting_key1 = 'dummy_block' xblock_setting_key2 = 'other_dummy_block' def setUp(self): """ Setting up tests """ super(TestSettingsService, self).setUp() self.settings_service = SettingsService() self.xblock_mock = mock.Mock() self.xblock_mock.block_settings_key = self.xblock_setting_key1 self.xblock_mock.unmixed_class = mock.Mock() self.xblock_mock.unmixed_class.__name__ = self.xblock_setting_key2 def test_get_given_none_throws_value_error(self): """ Test that given None throws value error """ with self.assertRaises(ValueError): self.settings_service.get_settings_bucket(None) def test_get_return_default_if_xblock_settings_is_missing(self): """ Test that returns default (or None if default not set) if XBLOCK_SETTINGS is not set """ self.assertFalse(hasattr(settings, 'XBLOCK_SETTINGS')) # precondition check self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock, 'zzz'), 'zzz') def test_get_return_empty_dictionary_if_xblock_settings_and_default_is_missing(self): """ Test that returns default (or None if default not set) if XBLOCK_SETTINGS is not set """ self.assertFalse(hasattr(settings, 'XBLOCK_SETTINGS')) # precondition check self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), {}) @override_settings(XBLOCK_SETTINGS={xblock_setting_key2: {'b': 1}}) def test_get_returns_none_or_default_if_bucket_not_found(self): """ Test if settings service returns default if setting not found """ self.assertEqual(getattr(settings, 'XBLOCK_SETTINGS'), {self.xblock_setting_key2: {'b': 1}}) self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), {}) self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock, 123), 123) @override_settings(XBLOCK_SETTINGS={xblock_setting_key1: 42}) def test_get_returns_correct_value(self): """ Test if settings service returns correct bucket """ self.assertEqual(getattr(settings, 'XBLOCK_SETTINGS'), {self.xblock_setting_key1: 42}) self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), 42) @override_settings(XBLOCK_SETTINGS={xblock_setting_key2: "I'm a setting"}) def test_get_respects_block_settings_key(self): """ Test if settings service respects block_settings_key value """ self.assertEqual(getattr(settings, 'XBLOCK_SETTINGS'), {self.xblock_setting_key2: "I'm a setting"}) self.xblock_mock.block_settings_key = self.xblock_setting_key2 self.assertEqual(self.settings_service.get_settings_bucket(self.xblock_mock), "I'm a setting") @override_settings(XBLOCK_SETTINGS={_DummyBlock.__name__: [1, 2, 3]}) def test_get_uses_class_name_if_block_settings_key_is_not_set(self): """ Test if settings service uses class name if block_settings_key attribute does not exist """ mixologist = Mixologist([]) block = mixologist.mix(_DummyBlock) self.assertEqual(getattr(settings, 'XBLOCK_SETTINGS'), {"_DummyBlock": [1, 2, 3]}) self.assertEqual(self.settings_service.get_settings_bucket(block), [1, 2, 3])
def __init__(self, **kwargs): request_cache_dict = DEFAULT_REQUEST_CACHE.data store = modulestore() services = kwargs.setdefault('services', {}) user = kwargs.get('user') if user and user.is_authenticated: services['completion'] = CompletionService( user=user, context_key=kwargs.get('course_id')) services['fs'] = xblock.reference.plugins.FSService() services['i18n'] = ModuleI18nService services['library_tools'] = LibraryToolsService( store, user_id=user.id if user else None) services['partitions'] = PartitionService( course_id=kwargs.get('course_id'), cache=request_cache_dict) services['settings'] = SettingsService() services['user_tags'] = UserTagsService(self) if badges_enabled(): services['badging'] = BadgingService( course_id=kwargs.get('course_id'), modulestore=store) self.request_token = kwargs.pop('request_token', None) services['teams'] = TeamsService() services['teams_configuration'] = TeamsConfigurationService() services['call_to_action'] = CallToActionService() super(LmsModuleSystem, self).__init__(**kwargs)
def _preview_module_system(request, descriptor, field_data): """ Returns a ModuleSystem for the specified descriptor that is specialized for rendering module previews. request: The active django request descriptor: An XModuleDescriptor """ course_id = descriptor.location.course_key display_name_only = (descriptor.category == 'static_tab') wrappers = [ # This wrapper wraps the module in the template specified above partial( wrap_xblock, 'PreviewRuntime', display_name_only=display_name_only, usage_id_serializer=unicode, request_token=request_token(request) ), # This wrapper replaces urls in the output that start with /static # with the correct course-specific url for the static content partial(replace_static_urls, None, course_id=course_id), _studio_wrap_xblock, ] descriptor.runtime._services['studio_user_permissions'] = StudioPermissionsService(request) # pylint: disable=protected-access return PreviewModuleSystem( static_url=settings.STATIC_URL, # TODO (cpennington): Do we want to track how instructors are using the preview problems? track_function=lambda event_type, event: None, filestore=descriptor.runtime.resources_fs, get_module=partial(_load_preview_module, request), render_template=render_from_lms, debug=True, replace_urls=partial(static_replace.replace_static_urls, data_directory=None, course_id=course_id), user=request.user, can_execute_unsafe_code=(lambda: can_execute_unsafe_code(course_id)), get_python_lib_zip=(lambda: get_python_lib_zip(contentstore, course_id)), mixins=settings.XBLOCK_MIXINS, course_id=course_id, anonymous_student_id='student', # Set up functions to modify the fragment produced by student_view wrappers=wrappers, error_descriptor_class=ErrorDescriptor, get_user_role=lambda: get_user_role(request.user, course_id), # Get the raw DescriptorSystem, not the CombinedSystem descriptor_runtime=descriptor._runtime, # pylint: disable=protected-access services={ "i18n": ModuleI18nService(), "field-data": field_data, "library_tools": LibraryToolsService(modulestore()), "settings": SettingsService(), "user": DjangoXBlockUserService(request.user), }, )
def __init__(self, **kwargs): services = kwargs.setdefault('services', {}) services['user_tags'] = UserTagsService(self) services['partitions'] = LmsPartitionService( user=kwargs.get('user'), course_id=kwargs.get('course_id'), track_function=kwargs.get('track_function', None), ) services['library_tools'] = LibraryToolsService(modulestore()) services['fs'] = xblock.reference.plugins.FSService() services['settings'] = SettingsService() self.request_token = kwargs.pop('request_token', None) super(LmsModuleSystem, self).__init__(**kwargs)
def __init__(self, **kwargs): request_cache_dict = RequestCache.get_request_cache().data services = kwargs.setdefault('services', {}) services['fs'] = xblock.reference.plugins.FSService() services['i18n'] = ModuleI18nService services['library_tools'] = LibraryToolsService(modulestore()) services['partitions'] = PartitionService( course_id=kwargs.get('course_id'), cache=request_cache_dict) store = modulestore() services['settings'] = SettingsService() services['user_tags'] = UserTagsService(self) if badges_enabled(): services['badging'] = BadgingService( course_id=kwargs.get('course_id'), modulestore=store) self.request_token = kwargs.pop('request_token', None) super(LmsModuleSystem, self).__init__(**kwargs)
def get_available_xblock_services(request=None, field_data=None, course_id=None): """ Returns a dict of available services for xBlocks """ services = { "i18n": ModuleI18nService, "settings": SettingsService(), "courseware_parent_info": CoursewareParentInfoService(), } if course_id: services['partitions'] = StudioPartitionService(course_id=course_id) if request: services['user'] = DjangoXBlockUserService(request.user) if field_data: services['field-data'] = field_data if settings.FEATURES.get('ENABLE_NOTIFICATIONS', False): services.update({"notifications": NotificationsService()}) return services
def _preview_module_system(request, descriptor, field_data): """ Returns a ModuleSystem for the specified descriptor that is specialized for rendering module previews. request: The active django request descriptor: An XModuleDescriptor """ course_id = descriptor.location.course_key display_name_only = (descriptor.category == 'static_tab') replace_url_service = ReplaceURLService(course_id=course_id) wrappers = [ # This wrapper wraps the module in the template specified above partial(wrap_xblock, 'PreviewRuntime', display_name_only=display_name_only, usage_id_serializer=str, request_token=request_token(request)), # This wrapper replaces urls in the output that start with /static # with the correct course-specific url for the static content partial(replace_urls_wrapper, replace_url_service=replace_url_service, static_replace_only=True), _studio_wrap_xblock, ] wrappers_asides = [ partial(wrap_xblock_aside, 'PreviewRuntime', usage_id_serializer=str, request_token=request_token(request)) ] mako_service = MakoService(namespace_prefix='lms.') if settings.FEATURES.get("LICENSING", False): # stick the license wrapper in front wrappers.insert(0, partial(wrap_with_license, mako_service=mako_service)) return PreviewModuleSystem( static_url=settings.STATIC_URL, # TODO (cpennington): Do we want to track how instructors are using the preview problems? track_function=lambda event_type, event: None, get_module=partial(_load_preview_module, request), debug=True, mixins=settings.XBLOCK_MIXINS, course_id=course_id, # Set up functions to modify the fragment produced by student_view wrappers=wrappers, wrappers_asides=wrappers_asides, error_descriptor_class=ErrorBlock, # Get the raw DescriptorSystem, not the CombinedSystem descriptor_runtime=descriptor._runtime, # pylint: disable=protected-access services={ "field-data": field_data, "i18n": ModuleI18nService, 'mako': mako_service, "settings": SettingsService(), "user": DjangoXBlockUserService( request.user, anonymous_user_id='student', user_role=get_user_role(request.user, course_id), ), "partitions": StudioPartitionService(course_id=course_id), "teams_configuration": TeamsConfigurationService(), "sandbox": SandboxService(contentstore=contentstore, course_id=course_id), "cache": CacheService(cache), 'replace_urls': replace_url_service }, )