def test_skill_which_is_assigned_to_multiple_topics(self):
skill_id = skill_services.get_new_skill_id()
self.save_new_skill(skill_id,
self.admin_id,
description='DescriptionSkill')
subtopic = topic_domain.Subtopic.create_default_subtopic(
1, 'Addition', 'addition')
subtopic.skill_ids = [skill_id]
topic_id = topic_fetchers.get_new_topic_id()
self.save_new_topic(topic_id,
self.admin_id,
name='Maths',
abbreviated_name='maths',
url_fragment='maths',
description='Description',
canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[],
subtopics=[subtopic],
next_subtopic_id=2)
subtopic = topic_domain.Subtopic.create_default_subtopic(
1, 'Chemistry', 'chemistry')
subtopic.skill_ids = [skill_id]
topic_id = topic_fetchers.get_new_topic_id()
self.save_new_topic(topic_id,
self.admin_id,
name='Science',
abbreviated_name='science',
url_fragment='science',
description='Description',
canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[],
subtopics=[subtopic],
next_subtopic_id=2)
url = '%s/%s' % (feconf.SKILL_EDITOR_DATA_URL_PREFIX, skill_id)
json_response = self.get_json(url)
self.assertEqual(skill_id, json_response['skill']['id'])
self.assertEqual(2,
len(json_response['assigned_skill_topic_data_dict']))
self.assertEqual(
json_response['assigned_skill_topic_data_dict']['Maths'],
'Addition')
self.assertEqual(
json_response['assigned_skill_topic_data_dict']['Science'],
'Chemistry')
self.assertEqual(1,
len(json_response['grouped_skill_summaries']['Name']))
self.logout()
def setUp(self) -> None:
super(SubtopicPageServicesUnitTests, self).setUp()
self.signup(self.CURRICULUM_ADMIN_EMAIL,
self.CURRICULUM_ADMIN_USERNAME)
self.admin_id = self.get_user_id_from_email( # type: ignore[no-untyped-call]
self.CURRICULUM_ADMIN_EMAIL)
self.set_curriculum_admins([self.CURRICULUM_ADMIN_USERNAME
]) # type: ignore[no-untyped-call]
self.TOPIC_ID = topic_fetchers.get_new_topic_id()
self.subtopic_page = (
subtopic_page_domain.SubtopicPage.create_default_subtopic_page(
self.subtopic_id, self.TOPIC_ID))
subtopic_page_services.save_subtopic_page(
self.user_id, self.subtopic_page, 'Added subtopic', [
topic_domain.TopicChange({
'cmd': topic_domain.CMD_ADD_SUBTOPIC,
'subtopic_id': 1,
'title': 'Sample',
'url_fragment': 'sample-fragment'
})
])
self.subtopic_page_id = (
subtopic_page_domain.SubtopicPage.get_subtopic_page_id(
self.TOPIC_ID, 1))
self.TOPIC_ID_1 = topic_fetchers.get_new_topic_id()
# Set up topic and subtopic.
topic = topic_domain.Topic.create_default_topic(
self.TOPIC_ID_1, 'Place Values', 'abbrev', 'description', 'fragm')
topic.thumbnail_filename = 'thumbnail.svg'
topic.thumbnail_bg_color = '#C6DCDA'
topic.subtopics = [
topic_domain.Subtopic(
1, 'Naming Numbers', ['skill_id_1'], 'image.svg',
constants.ALLOWED_THUMBNAIL_BG_COLORS['subtopic'][0], 21131,
'dummy-subtopic-url'),
topic_domain.Subtopic(
2, 'Subtopic Name', ['skill_id_2'], 'image.svg',
constants.ALLOWED_THUMBNAIL_BG_COLORS['subtopic'][0], 21131,
'other-subtopic-url')
]
topic.next_subtopic_id = 3
topic.skill_ids_for_diagnostic_test = ['skill_id_1']
topic_services.save_new_topic(self.admin_id,
topic) # type: ignore[no-untyped-call]
# Publish the topic and its stories.
topic_services.publish_topic(
self.TOPIC_ID_1, self.admin_id) # type: ignore[no-untyped-call]
def test_get(self):
self.login(self.CURRICULUM_ADMIN_EMAIL)
skill_id = skill_services.get_new_skill_id()
self.save_new_skill(
skill_id, self.admin_id, description='Skill description')
json_response = self.get_json(
'%s/%s' % (feconf.UNASSIGN_SKILL_DATA_HANDLER_URL, skill_id))
self.assertEqual(len(json_response['topic_assignment_dicts']), 0)
topic_id_1 = topic_fetchers.get_new_topic_id()
topic_id_2 = topic_fetchers.get_new_topic_id()
self.save_new_topic(
topic_id_1, self.admin_id, name='Topic1',
abbreviated_name='topic-one', url_fragment='topic-one',
description='Description1', canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[skill_id],
subtopics=[], next_subtopic_id=1)
subtopic = topic_domain.Subtopic.from_dict({
'id': 1,
'title': 'subtopic1',
'skill_ids': [skill_id],
'thumbnail_filename': None,
'thumbnail_bg_color': None,
'thumbnail_size_in_bytes': None,
'url_fragment': 'subtopic-url'
})
self.save_new_topic(
topic_id_2, self.admin_id, name='Topic2',
abbreviated_name='topic-two', url_fragment='topic-two',
description='Description2', canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[],
subtopics=[subtopic], next_subtopic_id=2)
json_response = self.get_json(
'%s/%s' % (feconf.UNASSIGN_SKILL_DATA_HANDLER_URL, skill_id))
topic_assignment_dicts = sorted(
json_response['topic_assignment_dicts'],
key=lambda i: i['topic_name'])
self.assertEqual(len(topic_assignment_dicts), 2)
self.assertEqual(topic_assignment_dicts[0]['topic_name'], 'Topic1')
self.assertEqual(topic_assignment_dicts[0]['topic_id'], topic_id_1)
self.assertIsNone(topic_assignment_dicts[0]['subtopic_id'])
self.assertEqual(topic_assignment_dicts[1]['topic_name'], 'Topic2')
self.assertEqual(topic_assignment_dicts[1]['topic_id'], topic_id_2)
self.assertEqual(topic_assignment_dicts[1]['subtopic_id'], 1)
def setUp(self):
"""Completes the sign-up process for the various users."""
super(BaseStoryEditorControllerTests, self).setUp()
self.signup(self.CURRICULUM_ADMIN_EMAIL,
self.CURRICULUM_ADMIN_USERNAME)
self.signup(self.NEW_USER_EMAIL, self.NEW_USER_USERNAME)
self.admin_id = self.get_user_id_from_email(
self.CURRICULUM_ADMIN_EMAIL)
self.new_user_id = self.get_user_id_from_email(self.NEW_USER_EMAIL)
self.set_curriculum_admins([self.CURRICULUM_ADMIN_USERNAME])
self.admin = user_services.get_user_actions_info(self.admin_id)
self.topic_id = topic_fetchers.get_new_topic_id()
self.story_id = story_services.get_new_story_id()
self.save_new_story(self.story_id, self.admin_id, self.topic_id)
self.save_new_topic(self.topic_id,
self.admin_id,
name='Name',
abbreviated_name='name',
url_fragment='name',
description='Description',
canonical_story_ids=[self.story_id],
additional_story_ids=[],
uncategorized_skill_ids=[],
subtopics=[],
next_subtopic_id=1)
def setUp(self):
"""Completes the sign-up process for the various users."""
super(BaseSkillEditorControllerTests, self).setUp()
self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME)
self.signup(self.NEW_USER_EMAIL, self.NEW_USER_USERNAME)
self.admin_id = self.get_user_id_from_email(self.ADMIN_EMAIL)
self.new_user_id = self.get_user_id_from_email(self.NEW_USER_EMAIL)
self.set_admins([self.ADMIN_USERNAME])
self.admin = user_services.UserActionsInfo(self.admin_id)
self.skill_id = skill_services.get_new_skill_id()
self.save_new_skill(self.skill_id,
self.admin_id,
description='Description')
self.skill_id_2 = skill_services.get_new_skill_id()
self.save_new_skill(self.skill_id_2,
self.admin_id,
description='Description')
self.topic_id = topic_fetchers.get_new_topic_id()
subtopic = topic_domain.Subtopic.create_default_subtopic(
1, 'Subtopic1')
subtopic.skill_ids = [self.skill_id]
self.save_new_topic(self.topic_id,
self.admin_id,
name='Name',
abbreviated_name='name',
url_fragment='name',
description='Description',
canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[],
subtopics=[subtopic],
next_subtopic_id=2)
def setUp(self):
"""Completes the sign-up process for the various users."""
super(BaseQuestionsListControllerTests, self).setUp()
self.signup(self.CURRICULUM_ADMIN_EMAIL, self.CURRICULUM_ADMIN_USERNAME)
self.admin_id = self.get_user_id_from_email(self.CURRICULUM_ADMIN_EMAIL)
self.set_curriculum_admins([self.CURRICULUM_ADMIN_USERNAME])
self.admin = user_services.get_user_actions_info(self.admin_id)
self.skill_id = skill_services.get_new_skill_id()
self.save_new_skill(
self.skill_id, self.admin_id, description='Skill Description')
self.skill_id_2 = skill_services.get_new_skill_id()
self.save_new_skill(
self.skill_id_2, self.admin_id, description='Skill Description 2')
self.topic_id = topic_fetchers.get_new_topic_id()
self.save_new_topic(
self.topic_id, self.admin_id, name='Name',
description='Description', canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[self.skill_id, self.skill_id_2],
subtopics=[], next_subtopic_id=1)
self.skill_id_3 = skill_services.get_new_skill_id()
changelist = [topic_domain.TopicChange({
'cmd': topic_domain.CMD_ADD_SUBTOPIC,
'title': 'Title',
'subtopic_id': 1
})]
topic_services.update_topic_and_subtopic_pages(
self.admin_id, self.topic_id, changelist, 'Added subtopic.')
def test_get_topic_by_version(self):
topic_id = topic_fetchers.get_new_topic_id()
self.save_new_topic(topic_id,
self.user_id,
name='topic name',
abbreviated_name='topic-name',
url_fragment='topic-name',
description='Description',
canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[],
subtopics=[],
next_subtopic_id=1)
changelist = [
topic_domain.TopicChange({
'cmd': topic_domain.CMD_UPDATE_TOPIC_PROPERTY,
'property_name': topic_domain.TOPIC_PROPERTY_LANGUAGE_CODE,
'old_value': 'en',
'new_value': 'bn'
})
]
topic_services.update_topic_and_subtopic_pages(self.user_id, topic_id,
changelist,
'Change language code')
topic_v0 = topic_fetchers.get_topic_by_id(topic_id, version=0)
topic_v1 = topic_fetchers.get_topic_by_id(topic_id, version=1)
self.assertEqual(topic_v1.language_code, 'en')
self.assertEqual(topic_v0.language_code, 'bn')
def test_skill_which_is_assigned_to_topic_but_not_subtopic(self):
skill_id = skill_services.get_new_skill_id()
self.save_new_skill(skill_id,
self.admin_id,
description='DescriptionSkill')
topic_id = topic_fetchers.get_new_topic_id()
self.save_new_topic(topic_id,
self.admin_id,
name='TopicName1',
abbreviated_name='topicname',
url_fragment='topic-one',
description='DescriptionTopic',
canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[skill_id],
subtopics=[],
next_subtopic_id=1)
url = '%s/%s' % (feconf.SKILL_EDITOR_DATA_URL_PREFIX, skill_id)
json_response = self.get_json(url)
self.assertEqual(skill_id, json_response['skill']['id'])
self.assertIsNone(
json_response['assigned_skill_topic_data_dict']['TopicName1'])
self.assertEqual(1,
len(json_response['grouped_skill_summaries']['Name']))
self.logout()
def setUp(self):
"""Completes the sign-up process for the various users."""
super(BaseTopicsAndSkillsDashboardTests, self).setUp()
self.signup(self.CURRICULUM_ADMIN_EMAIL, self.CURRICULUM_ADMIN_USERNAME)
self.signup(self.TOPIC_MANAGER_EMAIL, self.TOPIC_MANAGER_USERNAME)
self.signup(self.NEW_USER_EMAIL, self.NEW_USER_USERNAME)
self.admin_id = self.get_user_id_from_email(self.CURRICULUM_ADMIN_EMAIL)
self.topic_manager_id = self.get_user_id_from_email(
self.TOPIC_MANAGER_EMAIL)
self.new_user_id = self.get_user_id_from_email(
self.NEW_USER_EMAIL)
self.set_curriculum_admins([self.CURRICULUM_ADMIN_USERNAME])
self.topic_id = topic_fetchers.get_new_topic_id()
self.linked_skill_id = skill_services.get_new_skill_id()
self.save_new_skill(
self.linked_skill_id, self.admin_id, description='Description 3')
self.subtopic_skill_id = skill_services.get_new_skill_id()
self.save_new_skill(
self.subtopic_skill_id, self.admin_id, description='Subtopic Skill')
subtopic = topic_domain.Subtopic.create_default_subtopic(
1, 'Subtopic Title')
subtopic.skill_ids = [self.subtopic_skill_id]
self.save_new_topic(
self.topic_id, self.admin_id, name='Name',
abbreviated_name='name', url_fragment='name',
description='Description', canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[self.linked_skill_id],
subtopics=[subtopic], next_subtopic_id=2)
self.set_topic_managers([self.TOPIC_MANAGER_USERNAME], self.topic_id)
def test_editable_skill_handler_delete_when_associated_topics_exist(self):
self.login(self.CURRICULUM_ADMIN_EMAIL)
# Check DELETE removes skill from the topic and returns 200 when the
# skill still has associated topics.
topic_id = topic_fetchers.get_new_topic_id()
self.save_new_topic(topic_id,
self.admin_id,
name='Topic1',
abbreviated_name='topic-one',
url_fragment='topic-one',
description='Description1',
canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[self.skill_id],
subtopics=[],
next_subtopic_id=1)
topic = topic_fetchers.get_topic_by_id(topic_id)
self.assertTrue(self.skill_id in topic.get_all_skill_ids())
self.delete_json(self.url, expected_status_int=200)
topic = topic_fetchers.get_topic_by_id(topic_id)
self.assertFalse(self.skill_id in topic.get_all_skill_ids())
self.logout()
def test_editable_topic_handler_delete(self):
# Check that admins can delete a topic.
self.login(self.CURRICULUM_ADMIN_EMAIL)
self.delete_json(
'%s/%s' % (
feconf.TOPIC_EDITOR_DATA_URL_PREFIX, self.topic_id),
expected_status_int=200)
self.logout()
# Check that non-admins cannot delete a topic.
self.login(self.NEW_USER_EMAIL)
self.delete_json(
'%s/%s' % (
feconf.TOPIC_EDITOR_DATA_URL_PREFIX, self.topic_id),
expected_status_int=401)
self.logout()
# Check that topic can not be deleted when the topic id passed does
# not have a topic associated with it.
self.login(self.CURRICULUM_ADMIN_EMAIL)
self.delete_json(
'%s/%s' % (
feconf.TOPIC_EDITOR_DATA_URL_PREFIX,
topic_fetchers.get_new_topic_id()), expected_status_int=404)
self.logout()
def setUp(self):
super(RegenerateTopicSummaryOneOffJobTests, self).setUp()
self.signup(self.ALBERT_EMAIL, self.ALBERT_NAME)
self.albert_id = self.get_user_id_from_email(self.ALBERT_EMAIL)
self.TOPIC_ID = topic_fetchers.get_new_topic_id()
self.process_and_flush_pending_mapreduce_tasks()
def test_story_creation_fails_with_duplicate_story_url_fragment(self):
self.login(self.CURRICULUM_ADMIN_EMAIL)
csrf_token = self.get_new_csrf_token()
payload = {
'title': 'Story title',
'description': 'Story Description',
'filename': 'test_svg.svg',
'thumbnailBgColor': '#F8BF74',
'story_url_fragment': 'original'
}
self.save_new_story(story_services.get_new_story_id(),
self.admin_id,
topic_fetchers.get_new_topic_id(),
title='title',
description='description',
notes='note',
url_fragment='original')
with python_utils.open_file(os.path.join(feconf.TESTS_DATA_DIR,
'test_svg.svg'),
'rb',
encoding=None) as f:
raw_image = f.read()
json_response = self.post_json(
'%s/%s' % (feconf.TOPIC_EDITOR_STORY_URL, self.topic_id),
payload,
csrf_token=csrf_token,
upload_files=(('image', 'unused_filename', raw_image), ),
expected_status_int=400)
self.assertEqual(json_response['error'],
'Story url fragment is not unique across the site.')
def test_get_all_skill_ids_assigned_to_some_topic(self):
change_list = [
topic_domain.TopicChange({
'cmd': topic_domain.CMD_MOVE_SKILL_ID_TO_SUBTOPIC,
'old_subtopic_id': None,
'new_subtopic_id': 1,
'skill_id': self.skill_id_1
})
]
topic_services.update_topic_and_subtopic_pages(
self.user_id_admin, self.TOPIC_ID, change_list,
'Moved skill to subtopic.')
topic_id = topic_fetchers.get_new_topic_id()
self.save_new_topic(
topic_id,
self.user_id,
name='Name 2',
description='Description',
abbreviated_name='random',
url_fragment='name-three',
canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[self.skill_id_1, 'skill_3'],
subtopics=[],
next_subtopic_id=1)
self.assertEqual(
topic_fetchers.get_all_skill_ids_assigned_to_some_topic(),
{self.skill_id_1, self.skill_id_2, 'skill_3'})
def test_get_topic_by_id(self):
expected_topic = self.topic.to_dict()
topic = topic_fetchers.get_topic_by_id(self.TOPIC_ID)
self.assertEqual(topic.to_dict(), expected_topic)
fake_topic_id = topic_fetchers.get_new_topic_id()
fake_topic = topic_fetchers.get_topic_by_id(
fake_topic_id, strict=False)
self.assertIsNone(fake_topic)
def test_get_can_not_access_topic_page_with_nonexistent_topic_id(self):
self.login(self.CURRICULUM_ADMIN_EMAIL)
self.get_html_response('%s/%s' % (feconf.TOPIC_EDITOR_URL_PREFIX,
topic_fetchers.get_new_topic_id()),
expected_status_int=404)
self.logout()
def test_get_can_not_access_handler_with_invalid_topic_id(self):
self.login(self.CURRICULUM_ADMIN_EMAIL)
self.get_json('%s/%s/%s' %
(feconf.SUBTOPIC_PAGE_EDITOR_DATA_URL_PREFIX,
self.topic_id, topic_fetchers.get_new_topic_id()),
expected_status_int=404)
self.logout()
def test_with_delete_topic_id(self):
self.login(self.NEW_USER_EMAIL)
topic_id_1 = topic_fetchers.get_new_topic_id()
topic_id_2 = topic_fetchers.get_new_topic_id()
with self.swap_to_always_return(topic_fetchers, 'get_topics_by_ids',
[None, 'random_topic']):
json_response = self.get_json(
'%s' % feconf.SUBTOPIC_MASTERY_DATA_URL,
params={
'selected_topic_ids': json.dumps([topic_id_1, topic_id_2])
},
expected_status_int=400)
self.assertEqual(json_response['error'],
'Invalid topic ID %s' % topic_id_1)
self.logout()
def test_get_can_not_access_handler_with_invalid_topic_id(self):
self.login(self.CURRICULUM_ADMIN_EMAIL)
csrf_token = self.get_new_csrf_token()
new_topic_id = topic_fetchers.get_new_topic_id()
self.put_json('%s/%s' % (feconf.TOPIC_STATUS_URL_PREFIX, new_topic_id),
{'publish_status': True},
csrf_token=csrf_token,
expected_status_int=404)
def setUp(self) -> None:
super(TopicFetchersUnitTests, self).setUp()
self.TOPIC_ID = topic_fetchers.get_new_topic_id()
changelist = [
topic_domain.TopicChange({
'cmd': topic_domain.CMD_ADD_SUBTOPIC,
'title': 'Title',
'subtopic_id': 1,
'url_fragment': 'sample-fragment'
})
]
self.save_new_topic( # type: ignore[no-untyped-call]
self.TOPIC_ID,
self.user_id,
name='Name',
abbreviated_name='name',
url_fragment='name-one',
description='Description',
canonical_story_ids=[self.story_id_1, self.story_id_2],
additional_story_ids=[self.story_id_3],
uncategorized_skill_ids=[self.skill_id_1, self.skill_id_2],
subtopics=[],
next_subtopic_id=1)
self.save_new_story(self.story_id_1, self.user_id,
self.TOPIC_ID) # type: ignore[no-untyped-call]
self.save_new_story( # type: ignore[no-untyped-call]
self.story_id_3,
self.user_id,
self.TOPIC_ID,
title='Title 3',
description='Description 3')
self.signup('*****@*****.**', 'A')
self.signup('*****@*****.**', 'B')
self.signup(self.CURRICULUM_ADMIN_EMAIL,
self.CURRICULUM_ADMIN_USERNAME)
self.user_id_a = self.get_user_id_from_email(
'*****@*****.**') # type: ignore[no-untyped-call]
self.user_id_b = self.get_user_id_from_email(
'*****@*****.**') # type: ignore[no-untyped-call]
self.user_id_admin = (self.get_user_id_from_email(
self.CURRICULUM_ADMIN_EMAIL)) # type: ignore[no-untyped-call]
topic_services.update_topic_and_subtopic_pages( # type: ignore[no-untyped-call]
self.user_id_admin, self.TOPIC_ID, changelist, 'Added a subtopic')
self.topic: Optional[topic_domain.Topic] = (
topic_fetchers.get_topic_by_id(self.TOPIC_ID))
self.set_curriculum_admins([self.CURRICULUM_ADMIN_USERNAME
]) # type: ignore[no-untyped-call]
self.set_topic_managers( # type: ignore[no-untyped-call]
[user_services.get_username(self.user_id_a)], self.TOPIC_ID)
self.user_a = user_services.get_user_actions_info(self.user_id_a)
self.user_b = user_services.get_user_actions_info(self.user_id_b)
self.user_admin = user_services.get_user_actions_info(
self.user_id_admin)
def setUp(self) -> None:
super(StoryFetchersUnitTests, self).setUp()
self.story_id = story_services.get_new_story_id()
self.TOPIC_ID = topic_fetchers.get_new_topic_id(
) # type: ignore[no-untyped-call]
self.save_new_topic( # type: ignore[no-untyped-call]
self.TOPIC_ID,
self.USER_ID,
name='Topic',
description='A new topic',
canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[],
subtopics=[],
next_subtopic_id=0)
self.save_new_story( # type: ignore[no-untyped-call]
self.story_id,
self.USER_ID,
self.TOPIC_ID,
url_fragment='story-one')
topic_services.add_canonical_story( # type: ignore[no-untyped-call]
self.USER_ID, self.TOPIC_ID, self.story_id)
changelist = [
story_domain.StoryChange({
'cmd': story_domain.CMD_ADD_STORY_NODE,
'node_id': self.NODE_ID_1,
'title': 'Title 1'
})
]
story_services.update_story( # type: ignore[no-untyped-call]
self.USER_ID, self.story_id, changelist, 'Added node.')
self.story = story_fetchers.get_story_by_id(self.story_id)
self.signup('*****@*****.**', 'A')
self.signup('*****@*****.**', 'B')
self.signup(self.CURRICULUM_ADMIN_EMAIL,
self.CURRICULUM_ADMIN_USERNAME)
self.user_id_a = self.get_user_id_from_email(
'*****@*****.**') # type: ignore[no-untyped-call]
self.user_id_b = self.get_user_id_from_email(
'*****@*****.**') # type: ignore[no-untyped-call]
self.user_id_admin = (self.get_user_id_from_email(
self.CURRICULUM_ADMIN_EMAIL)) # type: ignore[no-untyped-call]
self.set_curriculum_admins([self.CURRICULUM_ADMIN_USERNAME
]) # type: ignore[no-untyped-call]
self.set_topic_managers( # type: ignore[no-untyped-call]
[user_services.get_username(self.user_id_a)],
self.TOPIC_ID) # type: ignore[no-untyped-call]
self.user_a = user_services.get_user_actions_info(
self.user_id_a) # type: ignore[no-untyped-call]
self.user_b = user_services.get_user_actions_info(
self.user_id_b) # type: ignore[no-untyped-call]
self.user_admin = user_services.get_user_actions_info( # type: ignore[no-untyped-call]
self.user_id_admin)
def test_can_not_get_topic_rights_when_topic_id_has_no_associated_topic(
self):
self.login(self.CURRICULUM_ADMIN_EMAIL)
json_response = self.get_json('%s/%s' %
(feconf.TOPIC_RIGHTS_URL_PREFIX,
topic_fetchers.get_new_topic_id()),
expected_status_int=400)
self.assertEqual(json_response['error'],
'Expected a valid topic id to be provided.')
self.logout()
def test_editable_topic_handler_get(self):
skill_services.delete_skill(self.admin_id, self.skill_id_2)
# Check that non-admins cannot access the editable topic data.
self.login(self.NEW_USER_EMAIL)
self.get_json(
'%s/%s' % (
feconf.TOPIC_EDITOR_DATA_URL_PREFIX, self.topic_id),
expected_status_int=401)
self.logout()
# Check that admins can access the editable topic data.
self.login(self.CURRICULUM_ADMIN_EMAIL)
with self.swap(feconf, 'CAN_SEND_EMAILS', True):
messages = self._get_sent_email_messages(
feconf.ADMIN_EMAIL_ADDRESS)
self.assertEqual(len(messages), 0)
json_response = self.get_json(
'%s/%s' % (
feconf.TOPIC_EDITOR_DATA_URL_PREFIX, self.topic_id))
self.assertEqual(self.topic_id, json_response['topic_dict']['id'])
self.assertTrue(
self.skill_id in json_response['skill_question_count_dict'])
self.assertEqual(
json_response['skill_question_count_dict'][self.skill_id], 0)
self.assertTrue(
self.skill_id_2 in json_response['skill_question_count_dict'])
self.assertEqual(
json_response['skill_question_count_dict'][self.skill_id_2], 0)
self.assertEqual(
'Skill Description',
json_response['skill_id_to_description_dict'][self.skill_id])
messages = self._get_sent_email_messages(
feconf.ADMIN_EMAIL_ADDRESS)
expected_email_html_body = (
'The deleted skills: %s are still'
' present in topic with id %s' % (
self.skill_id_2, self.topic_id))
self.assertEqual(len(messages), 1)
self.assertIn(expected_email_html_body, messages[0].html)
self.logout()
# Check that editable topic handler is accessed only when a topic id
# passed has an associated topic.
self.login(self.CURRICULUM_ADMIN_EMAIL)
self.get_json(
'%s/%s' % (
feconf.TOPIC_EDITOR_DATA_URL_PREFIX,
topic_fetchers.get_new_topic_id()), expected_status_int=404)
self.logout()
def setUp(self):
super(ThreadListHandlerForTopicsHandlerTests, self).setUp()
self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME)
self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL)
self.set_curriculum_admins([self.OWNER_USERNAME])
self.topic_id = topic_fetchers.get_new_topic_id()
self.save_new_topic(
self.topic_id, self.owner_id, name='Name',
description='Description', canonical_story_ids=[],
additional_story_ids=[], uncategorized_skill_ids=[],
subtopics=[], next_subtopic_id=1)
def post(self):
"""Handles POST requests."""
name = self.payload.get('name')
url_fragment = self.payload.get('url_fragment')
description = self.payload.get('description')
thumbnail_filename = self.payload.get('filename')
thumbnail_bg_color = self.payload.get('thumbnailBgColor')
raw_image = self.request.get('image')
page_title_frag = self.payload.get('page_title_fragment')
try:
topic_domain.Topic.require_valid_name(name)
except Exception as e:
raise self.InvalidInputException(
'Invalid topic name, received %s.' % name) from e
new_topic_id = topic_fetchers.get_new_topic_id()
topic = topic_domain.Topic.create_default_topic(
new_topic_id, name, url_fragment, description, page_title_frag)
topic_services.save_new_topic(self.user_id, topic)
try:
file_format = image_validation_services.validate_image_and_filename(
raw_image, thumbnail_filename)
except utils.ValidationError as e:
raise self.InvalidInputException(e)
entity_id = new_topic_id
filename_prefix = 'thumbnail'
image_is_compressible = (file_format
in feconf.COMPRESSIBLE_IMAGE_FORMATS)
fs_services.save_original_and_compressed_versions_of_image(
thumbnail_filename, feconf.ENTITY_TYPE_TOPIC, entity_id, raw_image,
filename_prefix, image_is_compressible)
topic_services.update_topic_and_subtopic_pages(
self.user_id, new_topic_id, [
topic_domain.TopicChange({
'cmd': 'update_topic_property',
'property_name': 'thumbnail_filename',
'old_value': None,
'new_value': thumbnail_filename
}),
topic_domain.TopicChange({
'cmd': 'update_topic_property',
'property_name': 'thumbnail_bg_color',
'old_value': None,
'new_value': thumbnail_bg_color
}),
], 'Add topic thumbnail.')
self.render_json({'topicId': new_topic_id})
def test_get_topic_by_id(self) -> None:
# Ruling out the possibility of None for mypy type checking.
assert self.topic is not None
expected_topic = self.topic.to_dict()
topic: Optional[topic_domain.Topic] = (topic_fetchers.get_topic_by_id(
self.TOPIC_ID))
# Ruling out the possibility of None for mypy type checking.
assert topic is not None
self.assertEqual(topic.to_dict(), expected_topic)
fake_topic_id = topic_fetchers.get_new_topic_id()
fake_topic: Optional[topic_domain.Topic] = (
topic_fetchers.get_topic_by_id(fake_topic_id, strict=False))
self.assertIsNone(fake_topic)
def setUp(self):
super(StoryThumbnailSizeAuditOneOffJobTests, self).setUp()
# Setup user who will own the test story nodes.
self.signup(self.ALBERT_EMAIL, self.ALBERT_NAME)
self.albert_id = self.get_user_id_from_email(self.ALBERT_EMAIL)
self.TOPIC_ID = topic_fetchers.get_new_topic_id()
self.story_id_1 = 'story_id_1'
self.save_new_topic(self.TOPIC_ID,
self.albert_id,
name='Name',
description='Description',
canonical_story_ids=[self.story_id_1])
self.process_and_flush_pending_mapreduce_tasks()
def test_get_classroom_url_fragment_for_topic_id(self):
topic_id = topic_fetchers.get_new_topic_id()
config_services.set_property(
self.user_id_admin, 'classroom_pages_data', [{
'name': 'math',
'url_fragment': 'math-one',
'topic_ids': [topic_id],
'course_details': '',
'topic_list_intro': ''
}])
classroom_url_fragment = (
classroom_services.get_classroom_url_fragment_for_topic_id(
topic_id))
self.assertEqual(classroom_url_fragment, 'math-one')
def test_can_get_classroom_by_url_fragment(self):
topic_id = topic_fetchers.get_new_topic_id()
config_services.set_property(
self.user_id_admin, 'classroom_pages_data', [{
'name': 'math',
'url_fragment': 'math',
'topic_ids': [topic_id],
'course_details': '',
'topic_list_intro': ''
}])
classroom = classroom_services.get_classroom_by_url_fragment('math')
self.assertEqual(classroom.name, 'math')
self.assertEqual(classroom.url_fragment, 'math')
self.assertEqual(classroom.topic_ids, [topic_id])
def setUp(self):
"""Completes the sign-up process for the various users."""
super(BaseQuestionEditorControllerTests, self).setUp()
self.signup(self.TOPIC_MANAGER_EMAIL, self.TOPIC_MANAGER_USERNAME)
self.signup(self.NEW_USER_EMAIL, self.NEW_USER_USERNAME)
self.signup(self.EDITOR_EMAIL, self.EDITOR_USERNAME)
self.signup(self.CURRICULUM_ADMIN_EMAIL,
self.CURRICULUM_ADMIN_USERNAME)
self.admin_id = self.get_user_id_from_email(
self.CURRICULUM_ADMIN_EMAIL)
self.topic_manager_id = self.get_user_id_from_email(
self.TOPIC_MANAGER_EMAIL)
self.new_user_id = self.get_user_id_from_email(self.NEW_USER_EMAIL)
self.editor_id = self.get_user_id_from_email(self.EDITOR_EMAIL)
self.set_curriculum_admins([self.CURRICULUM_ADMIN_USERNAME])
self.topic_id = topic_fetchers.get_new_topic_id()
subtopic_1 = topic_domain.Subtopic.create_default_subtopic(
1, 'Subtopic Title 1')
subtopic_1.skill_ids = ['skill_id_1']
subtopic_1.url_fragment = 'sub-one-frag'
self.save_new_topic(self.topic_id,
self.admin_id,
name='Name',
description='Description',
canonical_story_ids=[],
additional_story_ids=[],
uncategorized_skill_ids=[],
subtopics=[subtopic_1],
next_subtopic_id=2)
self.set_topic_managers([self.TOPIC_MANAGER_USERNAME], self.topic_id)
self.topic_manager = user_services.get_user_actions_info(
self.topic_manager_id)
self.admin = user_services.get_user_actions_info(self.admin_id)
self.new_user = user_services.get_user_actions_info(self.new_user_id)
self.editor = user_services.get_user_actions_info(self.editor_id)
self.skill_id = skill_services.get_new_skill_id()
self.save_new_skill(self.skill_id,
self.admin_id,
description='Skill Description')
self.question_id = question_services.get_new_question_id()
self.question = self.save_new_question(
self.question_id, self.editor_id,
self._create_valid_question_data('ABC'), [self.skill_id])
