def setUp(self) -> None:
super(ActivityReferenceDomainUnitTests, self).setUp()
self.exp_activity_reference = activity_domain.ActivityReference(
'exploration', '1234')
self.collection_activity_reference = activity_domain.ActivityReference(
'collection', '1234')
self.invalid_activity_reference_with_invalid_type = (
activity_domain.ActivityReference('invalid_activity_type', '1234'))
def test_requiring_nonexistent_activities_be_public_raises_exception(self):
with self.assertRaisesRegex(Exception, 'non-existent exploration'):
summary_services.require_activities_to_be_public([
activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_EXPLORATION, 'fake')])
with self.assertRaisesRegex(Exception, 'non-existent collection'):
summary_services.require_activities_to_be_public([
activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_COLLECTION, 'fake')])
def setUp(self) -> None:
super(ActivityReferencesDomainUnitTests, self).setUp()
exp_activity_reference = activity_domain.ActivityReference(
'exploration', '1234')
collection_activity_reference = activity_domain.ActivityReference(
'collection', '1234')
invalid_activity_reference = (activity_domain.ActivityReference(
'invalid_activity_type', '1234'))
self.valid_activity_references = (activity_domain.ActivityReferences(
[exp_activity_reference, collection_activity_reference]))
self.invalid_activity_references = (activity_domain.ActivityReferences(
[exp_activity_reference, invalid_activity_reference]))
def test_language_code_filter(self):
"""Note that both EXP_ID_1 is in Spanish and EXP_ID_2 is in English."""
activity_services.update_featured_activity_references([
activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID_1),
activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID_2)
])
featured_activity_summaries = (
summary_services.get_featured_activity_summary_dicts(
[constants.DEFAULT_LANGUAGE_CODE]))
self.assertEqual(len(featured_activity_summaries), 1)
self.assertDictContainsSubset(
{
'language_code': constants.DEFAULT_LANGUAGE_CODE,
'id': self.EXP_ID_2,
}, featured_activity_summaries[0])
featured_activity_summaries = (
summary_services.get_featured_activity_summary_dicts(
[self.LANGUAGE_CODE_ES]))
self.assertEqual(len(featured_activity_summaries), 1)
self.assertDictContainsSubset(
{
'language_code': self.LANGUAGE_CODE_ES,
'id': self.EXP_ID_1,
}, featured_activity_summaries[0])
featured_activity_summaries = (
summary_services.get_featured_activity_summary_dicts(
[constants.DEFAULT_LANGUAGE_CODE, self.LANGUAGE_CODE_ES]))
self.assertEqual(len(featured_activity_summaries), 2)
self.assertDictContainsSubset(
{
'language_code': self.LANGUAGE_CODE_ES,
'id': self.EXP_ID_1,
}, featured_activity_summaries[0])
self.assertDictContainsSubset(
{
'language_code': constants.DEFAULT_LANGUAGE_CODE,
'id': self.EXP_ID_2,
}, featured_activity_summaries[1])
featured_activity_summaries = (
summary_services.get_featured_activity_summary_dicts(
['nonexistent_language_code']))
self.assertEqual(len(featured_activity_summaries), 0)
featured_activity_summaries = (
summary_services.get_featured_activity_summary_dicts([]))
self.assertEqual(len(featured_activity_summaries), 0)
def test_requiring_private_activities_to_be_public_raises_exception(self):
self.save_new_valid_exploration(self.EXP_ID_0, self.owner_id)
self.save_new_valid_exploration(self.EXP_ID_1, self.owner_id)
self.save_new_valid_collection(
self.COL_ID_2, self.owner_id, exploration_id=self.EXP_ID_0)
with self.assertRaisesRegex(Exception, 'private exploration'):
summary_services.require_activities_to_be_public([
activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID_0)])
with self.assertRaisesRegex(Exception, 'private collection'):
summary_services.require_activities_to_be_public([
activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_COLLECTION, self.COL_ID_2)])
def test_requiring_public_activities_to_be_public_succeeds(self):
self.save_new_valid_exploration(self.EXP_ID_0, self.owner_id)
self.save_new_valid_collection(
self.COL_ID_2, self.owner_id, exploration_id=self.EXP_ID_0)
rights_manager.publish_exploration(self.owner, self.EXP_ID_0)
rights_manager.publish_collection(self.owner, self.COL_ID_2)
# There are no validation errors.
summary_services.require_activities_to_be_public([
activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID_0),
activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_COLLECTION, self.COL_ID_2)])
def test_split_by_type_raises_error_if_given_invalid_activity_ref(self):
exploration_123 = self._create_exploration_reference('123')
with self.assertRaisesRegexp(Exception, 'Invalid activity reference'):
activity_services.split_by_type([
exploration_123,
activity_domain.ActivityReference('invalid_type', 'bbb')
])
def _create_collection_reference(
self, collection_id: str) -> activity_domain.ActivityReference:
"""Creates and returns the collection reference corresponding to the
given collection id.
"""
return activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_COLLECTION, collection_id)
def test_for_featured_explorations(self):
"""Note that both EXP_ID_1 and EXP_ID_2 are public. However, only
EXP_ID_2 is featured, so the call to get_featured_explorations() should
only return [EXP_ID_2].
"""
activity_services.update_featured_activity_references([
activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID_2)
])
featured_activity_summaries = (
summary_services.get_featured_activity_summary_dicts([
constants.DEFAULT_LANGUAGE_CODE]))
self.assertEqual(len(featured_activity_summaries), 1)
self.assertDictContainsSubset({
'status': 'public',
'thumbnail_bg_color': '#a33f40',
'community_owned': False,
'tags': [],
'thumbnail_icon_url': '/subjects/Lightbulb.svg',
'language_code': constants.DEFAULT_LANGUAGE_CODE,
'id': self.EXP_ID_2,
'category': 'A category',
'ratings': feconf.get_empty_ratings(),
'title': 'A title',
'num_views': 0,
'objective': 'An objective'
}, featured_activity_summaries[0])
def _create_exploration_reference(
self, exploration_id: str) -> activity_domain.ActivityReference:
"""Creates and returns the exploration reference corresponding to the
given exploration id.
"""
return activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_EXPLORATION, exploration_id)
def get_featured_activity_references():
featured_model_instance = (
activity_models.ActivityReferencesModel.get_or_create(
activity_models.ACTIVITY_REFERENCE_LIST_FEATURED))
return [
activity_domain.ActivityReference(reference['type'], reference['id'])
for reference in featured_model_instance.activity_references
]
def test_validate_with_invalid_id(self) -> None:
# TODO(#13528): Remove this test after the backend is fully
# type-annotated. Here ignore[arg-type] is used to test the constructor
# for ActivityReference for invalid argument type.
invalid_activity_reference_with_invalid_id = (
activity_domain.ActivityReference('exploration',
1234)) # type: ignore[arg-type]
with self.assertRaisesRegex( # type: ignore[no-untyped-call]
Exception, ('Expected id to be a string but found 1234')):
invalid_activity_reference_with_invalid_id.validate()
def get_featured_activity_references():
"""Gets a list of ActivityReference domain models.
Returns:
list(ActivityReference). A list of all ActivityReference domain objects
that are currently featured.
"""
featured_model_instance = (
activity_models.ActivityReferencesModel.get_or_create(
feconf.ACTIVITY_REFERENCE_LIST_FEATURED))
return [
activity_domain.ActivityReference(reference['type'], reference['id'])
for reference in featured_model_instance.activity_references]
def test_library_index_handler_updates_featured_activity_summary_dict(
self):
"""Test the handler for featured explorations."""
response_dict = self.get_json(feconf.LIBRARY_INDEX_DATA_URL)
self.assertDictContainsSubset(
{
'activity_summary_dicts_by_category': [],
'preferred_language_codes': ['en'],
}, response_dict)
# Load a demo.
exp_services.load_demo('0')
exploration_ref = activity_domain.ActivityReference(
constants.ACTIVITY_TYPE_EXPLORATION, '0')
activity_services.update_featured_activity_references(
[exploration_ref])
response_dict = self.get_json(feconf.LIBRARY_INDEX_DATA_URL)
self.assertEqual(
len(response_dict['activity_summary_dicts_by_category']), 1)
self.assertDictContainsSubset({
'preferred_language_codes': ['en'],
}, response_dict)
activity_summary_dicts_by_category = (
response_dict['activity_summary_dicts_by_category'][0])
self.assertDictContainsSubset(
{
'categories': [],
'header_i18n_id':
(feconf.LIBRARY_CATEGORY_FEATURED_ACTIVITIES),
'has_full_results_page': False,
'full_results_url': None,
}, activity_summary_dicts_by_category)
activity_summary_dicts = (
activity_summary_dicts_by_category['activity_summary_dicts'])
self.assertEqual(len(activity_summary_dicts), 1)
self.assertDictContainsSubset(
{
'id': '0',
'category': 'Welcome',
'title': 'Welcome to Oppia!',
'language_code': 'en',
'objective': 'become familiar with Oppia\'s capabilities',
'status': rights_domain.ACTIVITY_STATUS_PUBLIC,
}, activity_summary_dicts[0])
def _get_model_domain_object_instance(cls, item):
activity_references_list = []
try:
for reference in item.activity_references:
activity_references_list.append(
activity_domain.ActivityReference(reference['type'],
reference['id']))
except Exception as e:
cls._add_error(
base_model_validators.ERROR_CATEGORY_PROPERTY_FETCH_CHECK,
'Entity id %s: Entity properties cannot be fetched completely '
'with the error %s' % (item.id, e))
return None
return activity_domain.ActivityReferences(activity_references_list)
def post(self):
"""Handles POST requests."""
featured_activity_reference_dicts = self.payload.get(
'featured_activity_reference_dicts')
featured_activity_references = [
activity_domain.ActivityReference(
reference_dict['type'], reference_dict['id'])
for reference_dict in featured_activity_reference_dicts]
try:
summary_services.require_activities_to_be_public(
featured_activity_references)
except Exception as e:
raise self.InvalidInputException(e)
activity_services.update_featured_activity_references(
featured_activity_references)
self.render_json({})
def _create_collection_reference(self, collection_id):
return activity_domain.ActivityReference(
feconf.ACTIVITY_TYPE_COLLECTION, collection_id)
def _create_exploration_reference(self, exploration_id):
return activity_domain.ActivityReference(
feconf.ACTIVITY_TYPE_EXPLORATION, exploration_id)
