def test_get_questions_succeeds(self):
for _ in python_utils.RANGE(0, 4):
question_id = question_services.get_new_question_id()
self.save_new_question(question_id, self.admin_id,
self._create_valid_question_data('ABC'),
[self.skill_id, self.skill_id_2])
question_services.create_new_question_skill_link(
self.admin_id, question_id, self.skill_id, 0.5)
question_services.create_new_question_skill_link(
self.admin_id, question_id, self.skill_id_2, 0.3)
self.login(self.ADMIN_EMAIL)
with self.swap(constants, 'NUM_QUESTIONS_PER_PAGE', 2):
json_response = self.get_json('%s/%s,%s?cursor=' %
(feconf.QUESTIONS_LIST_URL_PREFIX,
self.skill_id, self.skill_id_2))
question_summary_dicts = json_response['question_summary_dicts']
self.assertEqual(len(question_summary_dicts), 2)
next_start_cursor = json_response['next_start_cursor']
json_response = self.get_json(
'%s/%s,%s?cursor=%s' %
(feconf.QUESTIONS_LIST_URL_PREFIX, self.skill_id,
self.skill_id_2, next_start_cursor))
question_summary_dicts_2 = (
json_response['question_summary_dicts'])
self.assertEqual(len(question_summary_dicts_2), 2)
for i in python_utils.RANGE(0, 2):
self.assertEqual(
question_summary_dicts[i]['skill_descriptions'],
['Skill Description 2', 'Skill Description'])
self.assertEqual(
question_summary_dicts_2[i]['skill_descriptions'],
['Skill Description 2', 'Skill Description'])
self.assertEqual(question_summary_dicts[i]['skill_ids'],
[self.skill_id_2, self.skill_id])
self.assertEqual(question_summary_dicts_2[i]['skill_ids'],
[self.skill_id_2, self.skill_id])
self.assertEqual(
question_summary_dicts[i]['skill_difficulties'],
[0.3, 0.5])
self.assertEqual(
question_summary_dicts_2[i]['skill_difficulties'],
[0.3, 0.5])
json_response = self.get_json(
'%s/%s?cursor=' %
(feconf.QUESTIONS_LIST_URL_PREFIX, self.skill_id))
question_summary_dicts_3 = (
json_response['question_summary_dicts'])
self.assertEqual(len(question_summary_dicts_3), 2)
for i in python_utils.RANGE(0, 2):
self.assertEqual(
question_summary_dicts_3[i]['skill_description'],
'Skill Description')
self.assertEqual(question_summary_dicts_3[i]['skill_id'],
self.skill_id)
self.assertEqual(
question_summary_dicts_3[i]['skill_difficulty'], 0.5)
self.assertNotEqual(question_summary_dicts[0]['summary']['id'],
question_summary_dicts_2[0]['summary']['id'])
self.logout()
def setUp(self):
super(OpportunityServicesIntegrationTest, self).setUp()
self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME)
self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME)
self.admin_id = self.get_user_id_from_email(self.ADMIN_EMAIL)
self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL)
self.set_admins([self.ADMIN_USERNAME])
self.admin = user_services.UserActionsInfo(self.admin_id)
self.TOPIC_ID = 'topic'
self.STORY_ID = 'story'
self.USER_ID = 'user'
self.SKILL_ID = 'skill'
self.QUESTION_ID = question_services.get_new_question_id()
explorations = [exp_domain.Exploration.create_default_exploration(
'%s' % i,
title='title %d' % i,
category='category%d' % i,
) for i in python_utils.RANGE(5)]
for exp in explorations:
exp_services.save_new_exploration(self.owner_id, exp)
topic = topic_domain.Topic.create_default_topic(
topic_id=self.TOPIC_ID, name='topic')
topic_services.save_new_topic(self.owner_id, topic)
story = story_domain.Story.create_default_story(
self.STORY_ID, title='A story',
corresponding_topic_id=self.TOPIC_ID)
story_services.save_new_story(self.owner_id, story)
topic_services.add_canonical_story(
self.owner_id, self.TOPIC_ID, self.STORY_ID)
def setUp(self):
super(SkillOpportunityModelValidatorTests, self).setUp()
self.job_class = (
prod_validation_jobs_one_off.SkillOpportunityModelAuditOneOffJob)
self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME)
self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME)
self.admin_id = self.get_user_id_from_email(self.ADMIN_EMAIL)
self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL)
self.set_admins([self.ADMIN_USERNAME])
self.admin = user_services.UserActionsInfo(self.admin_id)
for i in python_utils.RANGE(3):
skill_id = '%s' % i
self.save_new_skill(skill_id,
self.admin_id,
description='description %d' % i)
self.QUESTION_ID = question_services.get_new_question_id()
self.save_new_question(self.QUESTION_ID, self.owner_id,
self._create_valid_question_data('ABC'), ['0'])
question_services.create_new_question_skill_link(
self.owner_id, self.QUESTION_ID, '0', 0.3)
self.model_instance_0 = (
opportunity_models.SkillOpportunityModel.get('0'))
self.model_instance_1 = (
opportunity_models.SkillOpportunityModel.get('1'))
self.model_instance_2 = (
opportunity_models.SkillOpportunityModel.get('2'))
def _generate_dummy_skill_and_questions(self):
"""Generate and loads the database with a skill and 15 questions
linked to the skill.
Raises:
Exception. Cannot load new structures data in production mode.
Exception. User does not have enough rights to generate data.
"""
if constants.DEV_MODE:
if self.user.role != feconf.ROLE_ID_ADMIN:
raise Exception(
'User does not have enough rights to generate data.')
skill_id = skill_services.get_new_skill_id()
skill_name = 'Dummy Skill %s' % python_utils.UNICODE(
random.getrandbits(32))
skill = self._create_dummy_skill(
skill_id, skill_name, '<p>Dummy Explanation 1</p>')
skill_services.save_new_skill(self.user_id, skill)
for i in python_utils.RANGE(15):
question_id = question_services.get_new_question_id()
question_name = 'Question number %s %s' % (
python_utils.UNICODE(i), skill_name)
question = self._create_dummy_question(
question_id, question_name, [skill_id])
question_services.add_question(self.user_id, question)
question_difficulty = list(
constants.SKILL_DIFFICULTY_LABEL_TO_FLOAT.values())
random_difficulty = random.choice(question_difficulty)
question_services.create_new_question_skill_link(
self.user_id, question_id, skill_id, random_difficulty)
else:
raise Exception('Cannot generate dummy skills in production.')
def setUp(self):
"""Before each individual test, create dummy user."""
super(QuestionServicesUnitTest, 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.ADMIN_EMAIL, self.ADMIN_USERNAME)
self.admin_id = self.get_user_id_from_email(self.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_admins([self.ADMIN_USERNAME])
self.set_topic_managers([self.TOPIC_MANAGER_USERNAME])
self.topic_manager = user_services.UserActionsInfo(
self.topic_manager_id)
self.admin = user_services.UserActionsInfo(self.admin_id)
self.new_user = user_services.UserActionsInfo(self.new_user_id)
self.editor = user_services.UserActionsInfo(self.editor_id)
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'))
def accept(self, unused_commit_message):
"""Accepts the suggestion.
Args:
unused_commit_message: str. This parameter is passed in for
consistency with the existing suggestions. As a default commit
message is used in the add_question function, the arg is unused.
"""
question_dict = self.change.question_dict
question_dict['version'] = 1
question_dict['id'] = (question_services.get_new_question_id())
question_dict['linked_skill_ids'] = [self.change.skill_id]
question = question_domain.Question.from_dict(question_dict)
question.validate()
self._copy_new_images_to_target_entity_storage()
question_services.add_question(self.author_id, question)
skill = skill_fetchers.get_skill_by_id(self.change.skill_id,
strict=False)
if skill is None:
raise utils.ValidationError(
'The skill with the given id doesn\'t exist.')
question_services.create_new_question_skill_link(
self.author_id, question_dict['id'], self.change.skill_id,
self._get_skill_difficulty())
def accept(self, unused_commit_message):
"""Accepts the suggestion.
Args:
unused_commit_message: str. This parameter is passed in for
consistency with the existing suggestions. As a default commit
message is used in the add_question function, the arg is unused.
"""
question_dict = self.change.question_dict
question_dict['version'] = 1
question_dict['id'] = (question_services.get_new_question_id())
html_list = self.get_all_html_content_strings()
filenames = (
html_cleaner.get_image_filenames_from_html_strings(html_list))
image_context = fs_services.get_image_context_for_suggestion_target(
self.target_type)
fs_services.copy_images(image_context, self.target_id,
feconf.ENTITY_TYPE_QUESTION, self.target_id,
filenames)
question_dict['linked_skill_ids'] = [self.change.skill_id]
question = question_domain.Question.from_dict(question_dict)
question.validate()
question_services.add_question(self.author_id, question)
skill = skill_fetchers.get_skill_by_id(self.change.skill_id,
strict=False)
if skill is None:
raise utils.ValidationError(
'The skill with the given id doesn\'t exist.')
question_services.create_new_question_skill_link(
self.author_id, question_dict['id'], self.change.skill_id,
self._get_skill_difficulty())
def test_linking_same_skill_to_question_twice(self):
question_id_2 = question_services.get_new_question_id()
self.save_new_question(question_id_2, self.editor_id,
self._create_valid_question_data('ABC'),
['skill_1'])
skill_ids = [
skill.id for skill in
question_services.get_skills_linked_to_question(question_id_2)
]
self.assertEqual(len(skill_ids), 1)
self.assertEqual(skill_ids[0], 'skill_1')
question_services.create_new_question_skill_link(
self.editor_id, question_id_2, 'skill_1', 0.3)
skill_ids = [
skill.id for skill in
question_services.get_skills_linked_to_question(question_id_2)
]
self.assertEqual(len(skill_ids), 1)
self.assertEqual(skill_ids[0], 'skill_1')
question_services.create_new_question_skill_link(
self.editor_id, question_id_2, 'skill_2', 0.3)
skill_ids = [
skill.id for skill in
question_services.get_skills_linked_to_question(question_id_2)
]
self.assertEqual(len(skill_ids), 2)
self.assertItemsEqual(skill_ids, ['skill_1', 'skill_2'])
def test_cannot_get_question_from_model_with_invalid_schema_version(self):
# Delete all question models.
all_question_models = question_models.QuestionModel.get_all()
question_models.QuestionModel.delete_multi(all_question_models)
all_question_models = question_models.QuestionModel.get_all()
self.assertEqual(all_question_models.count(), 0)
question_id = question_services.get_new_question_id()
question_model = question_models.QuestionModel(
id=question_id,
question_state_data=(
self._create_valid_question_data('ABC').to_dict()),
language_code='en',
version=0,
question_state_data_schema_version=0)
question_model.commit(self.editor_id, 'question model created',
[{
'cmd': question_domain.CMD_CREATE_NEW
}])
all_question_models = question_models.QuestionModel.get_all()
self.assertEqual(all_question_models.count(), 1)
question_model = all_question_models.get()
with self.assertRaisesRegexp(
Exception,
'Sorry, we can only process v25-v%d state schemas at present.'
% feconf.CURRENT_STATE_SCHEMA_VERSION):
question_services.get_question_from_model(question_model)
def post(self, skill_id):
"""Handles POST requests."""
if not constants.ENABLE_NEW_STRUCTURE_EDITORS:
raise self.PageNotFoundException
skill_domain.Skill.require_valid_skill_id(skill_id)
skill = skill_services.get_skill_by_id(skill_id, strict=False)
if skill is None:
raise self.PageNotFoundException(
'The skill with the given id doesn\'t exist.')
question_dict = self.payload.get('question_dict')
if (
(question_dict['id'] is not None) or
('question_state_data' not in question_dict) or
('language_code' not in question_dict) or
(question_dict['version'] != 1) or
(question_dict['question_state_schema_version'] != (
feconf.CURRENT_STATES_SCHEMA_VERSION))):
raise self.InvalidInputException
question_dict['id'] = question_services.get_new_question_id()
question = question_domain.Question.from_dict(question_dict)
question_services.add_question(self.user_id, question)
question_services.create_new_question_skill_link(
question.id, skill_id)
self.values.update({
'question_id': question.id
})
self.render_json(self.values)
def post(self, skill_id):
"""Handles POST requests."""
skill_domain.Skill.require_valid_skill_id(skill_id)
skill = skill_services.get_skill_by_id(skill_id, strict=False)
if skill is None:
raise self.PageNotFoundException(
'The skill with the given id doesn\'t exist.')
question_dict = self.payload.get('question_dict')
if ((question_dict['id'] is not None)
or ('question_state_data' not in question_dict)
or ('language_code' not in question_dict)
or (question_dict['version'] != 1)):
raise self.InvalidInputException
question_dict['question_state_data_schema_version'] = (
feconf.CURRENT_STATE_SCHEMA_VERSION)
question_dict['id'] = question_services.get_new_question_id()
try:
question = question_domain.Question.from_dict(question_dict)
except:
raise self.InvalidInputException
question_services.add_question(self.user_id, question)
# TODO(vinitamurthi): Replace DEFAULT_SKILL_DIFFICULTY
# with a value passed from the frontend.
question_services.create_new_question_skill_link(
question.id, skill_id, constants.DEFAULT_SKILL_DIFFICULTY)
self.values.update({'question_id': question.id})
self.render_json(self.values)
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.ADMIN_EMAIL, self.ADMIN_USERNAME)
self.admin_id = self.get_user_id_from_email(self.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_admins([self.ADMIN_USERNAME])
self.set_topic_managers([self.TOPIC_MANAGER_USERNAME])
self.topic_manager = user_services.UserActionsInfo(
self.topic_manager_id)
self.admin = user_services.UserActionsInfo(self.admin_id)
self.new_user = user_services.UserActionsInfo(self.new_user_id)
self.editor = user_services.UserActionsInfo(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])
def setUp(self):
super(QuestionFetchersUnitTests, self).setUp()
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.editor_id = self.get_user_id_from_email(self.EDITOR_EMAIL)
self.set_curriculum_admins([self.CURRICULUM_ADMIN_USERNAME])
self.admin = user_services.get_user_actions_info(self.admin_id)
self.editor = user_services.get_user_actions_info(self.editor_id)
self.save_new_skill('skill_1',
self.admin_id,
description='Skill Description 1')
self.save_new_skill('skill_2',
self.admin_id,
description='Skill Description 2')
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'), ['skill_1'])
def test_get_question_from_model_with_current_valid_schema_version(self):
# Delete all question models.
all_question_models = question_models.QuestionModel.get_all()
question_models.QuestionModel.delete_multi(
[question_model.id for question_model in all_question_models],
feconf.SYSTEM_COMMITTER_ID,
'',
force_deletion=True)
all_question_models = question_models.QuestionModel.get_all()
self.assertEqual(all_question_models.count(), 0)
question_id = question_services.get_new_question_id()
question_model = question_models.QuestionModel(
id=question_id,
question_state_data=(
self._create_valid_question_data('ABC').to_dict()),
language_code='en',
version=0,
question_state_data_schema_version=48)
question_model.commit(self.editor_id, 'question model created',
[{
'cmd': question_domain.CMD_CREATE_NEW
}])
all_question_models = question_models.QuestionModel.get_all()
self.assertEqual(all_question_models.count(), 1)
question_model = all_question_models.get()
updated_question_model = question_fetchers.get_question_from_model(
question_model)
self.assertEqual(
updated_question_model.question_state_data_schema_version,
feconf.CURRENT_STATE_SCHEMA_VERSION)
def test_get_question_skill_links_of_skill(self):
# If the skill id doesnt exist at all, it returns an empty list.
question_skill_links = (
question_services.get_question_skill_links_of_skill(
'non_existent_skill_id', 'Skill Description'))
self.assertEqual(len(question_skill_links), 0)
# If the question ids dont exist for a skill, it returns an empty list.
question_skill_links = (
question_services.get_question_skill_links_of_skill(
'skill_1', 'Skill Description 1'))
self.assertEqual(len(question_skill_links), 0)
question_id_2 = question_services.get_new_question_id()
self.save_new_question(question_id_2, self.editor_id,
self._create_valid_question_data('ABC'),
['skill_1'])
question_id_3 = question_services.get_new_question_id()
self.save_new_question(question_id_3, self.editor_id,
self._create_valid_question_data('ABC'),
['skill_2'])
# Setting skill difficulty for self.question_id.
question_services.create_new_question_skill_link(
self.editor_id, self.question_id, 'skill_1', 0.5)
question_services.create_new_question_skill_link(
self.editor_id, question_id_2, 'skill_1', 0.3)
question_services.create_new_question_skill_link(
self.editor_id, question_id_3, 'skill_2', 0.1)
# When question ids exist, it returns a list of questionskilllinks.
question_skill_links = (
question_services.get_question_skill_links_of_skill(
'skill_1', 'Skill Description 1'))
self.assertEqual(len(question_skill_links), 2)
self.assertTrue(
isinstance(question_skill_links[0],
question_domain.QuestionSkillLink))
question_ids = [
question_skill.question_id
for question_skill in question_skill_links
]
self.assertItemsEqual(question_ids, [self.question_id, question_id_2])
for question_skill in question_skill_links:
if question_skill.question_id == self.question_id:
self.assertEqual(question_skill.skill_difficulty, 0.5)
def setUp(self):
"""Completes the setup for QuestionSkillLinkHandlerTest."""
super(QuestionSkillLinkHandlerTest, self).setUp()
self.skill_id = skill_services.get_new_skill_id()
self.save_new_skill(self.skill_id, self.admin_id, 'Skill Description')
self.question_id_2 = question_services.get_new_question_id()
self.save_new_question(self.question_id_2, self.editor_id,
self._create_valid_question_data('ABC'))
def setUp(self):
super(VoiceoverApplicationServicesUnitTests, self).setUp()
self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME)
self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME)
self.signup(self.APPLICANT_EMAIL, self.APPLICANT_USERNAME)
self.admin_id = self.get_user_id_from_email(self.ADMIN_EMAIL)
self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL)
self.applicant_id = self.get_user_id_from_email(self.APPLICANT_EMAIL)
self.applicant = user_services.UserActionsInfo(self.applicant_id)
self.set_admins([self.ADMIN_USERNAME])
self.admin = user_services.UserActionsInfo(self.admin_id)
self.TOPIC_ID = 'topic'
self.STORY_ID = 'story'
self.USER_ID = 'user'
self.SKILL_ID = 'skill'
self.QUESTION_ID = question_services.get_new_question_id()
explorations = [
self.save_new_valid_exploration('%s' % i,
self.owner_id,
title='title %d' % i,
category='category%d' % i,
end_state_name='End State')
for i in python_utils.RANGE(2)
]
for exp in explorations:
self.publish_exploration(self.owner_id, exp.id)
topic = topic_domain.Topic.create_default_topic(
self.TOPIC_ID, 'topic', 'abbrev', 'description')
topic_services.save_new_topic(self.owner_id, topic)
story = story_domain.Story.create_default_story(
self.STORY_ID,
title='A story',
corresponding_topic_id=self.TOPIC_ID)
story_services.save_new_story(self.owner_id, story)
topic_services.add_canonical_story(self.owner_id, self.TOPIC_ID,
self.STORY_ID)
story_services.update_story(self.owner_id, self.STORY_ID, [
story_domain.StoryChange({
'cmd': 'add_story_node',
'node_id': 'node_1',
'title': 'Node1',
}),
story_domain.StoryChange({
'cmd': 'update_story_node_property',
'property_name': 'exploration_id',
'node_id': 'node_1',
'old_value': None,
'new_value': '0'
})
], 'Changes.')
def test_create_and_get_question_skill_link(self):
question_id_2 = question_services.get_new_question_id()
self.save_new_question(
question_id_2, self.editor_id,
self._create_valid_question_data('ABC'))
question_id_3 = question_services.get_new_question_id()
self.save_new_question(
question_id_3, self.editor_id,
self._create_valid_question_data('ABC'))
question_services.create_new_question_skill_link(
self.question_id, 'skill_1')
question_services.create_new_question_skill_link(
question_id_2, 'skill_1')
question_services.create_new_question_skill_link(
question_id_3, 'skill_2')
question_summaries, _ = (
question_services.get_question_summaries_linked_to_skills(
5, ['skill_1', 'skill_2', 'skill_3'], ''))
with self.assertRaisesRegexp(
Exception, 'Querying linked question summaries for more than 3 '
'skills at a time is not supported currently.'):
question_services.get_question_summaries_linked_to_skills(
5, ['skill_1', 'skill_2', 'skill_3', 'skill_4'], '')
question_ids = [summary.id for summary in question_summaries]
self.assertEqual(len(question_ids), 3)
self.assertItemsEqual(
question_ids, [self.question_id, question_id_2, question_id_3])
question_summaries, _ = (
question_services.get_question_summaries_linked_to_skills(
5, ['skill_1', 'skill_3'], ''))
question_ids = [summary.id for summary in question_summaries]
self.assertEqual(len(question_ids), 2)
self.assertItemsEqual(
question_ids, [self.question_id, question_id_2])
with self.assertRaisesRegexp(
Exception, 'The given question is already linked to given skill'):
question_services.create_new_question_skill_link(
self.question_id, 'skill_1')
def test_update_skill_ids_of_questions(self):
question_id_2 = question_services.get_new_question_id()
self.save_new_question(question_id_2, self.editor_id,
self._create_valid_question_data('ABC'))
question_id_3 = question_services.get_new_question_id()
self.save_new_question(question_id_3, self.editor_id,
self._create_valid_question_data('ABC'))
question_services.create_new_question_skill_link(
self.question_id, 'skill_1')
question_services.create_new_question_skill_link(
question_id_2, 'skill_1')
question_services.create_new_question_skill_link(
question_id_3, 'skill_2')
question_skill_links = (
question_services.get_question_skill_links_of_skill(
'skill_1', 'Skill Description 1'))
self.assertEqual(len(question_skill_links), 2)
question_ids = [
question_skill.question_id
for question_skill in question_skill_links
]
self.assertItemsEqual(question_ids, [self.question_id, question_id_2])
question_services.update_skill_ids_of_questions(
'skill_1', 'Description 1', 'skill_3')
question_skill_links = (
question_services.get_question_skill_links_of_skill(
'skill_1', 'Description 1'))
self.assertEqual(len(question_skill_links), 0)
question_skill_links = (
question_services.get_question_skill_links_of_skill(
'skill_3', 'Skill Description 3'))
question_ids = [
question_skill.question_id
for question_skill in question_skill_links
]
self.assertItemsEqual(question_ids, [self.question_id, question_id_2])
def setUp(self):
super(MergeSkillHandlerTests, self).setUp()
self.url = feconf.MERGE_SKILLS_URL
self.question_id = question_services.get_new_question_id()
self.question = self.save_new_question(
self.question_id, self.admin_id,
self._create_valid_question_data('ABC'), [self.linked_skill_id])
question_services.create_new_question_skill_link(
self.admin_id, self.question_id, self.linked_skill_id, 0.5)
def test_get_questions_by_ids(self):
question_id_2 = question_services.get_new_question_id()
self.save_new_question(question_id_2, self.editor_id,
self._create_valid_question_data('DEF'))
questions = question_services.get_questions_by_ids(
[self.question_id, 'invalid_question_id', question_id_2])
self.assertEqual(len(questions), 3)
self.assertEqual(questions[0].id, self.question_id)
self.assertIsNone(questions[1])
self.assertEqual(questions[2].id, question_id_2)
def test_get(self):
# Create 5 questions linked to the same skill.
for i in range(0, 3): #pylint: disable=unused-variable
question_id = question_services.get_new_question_id()
self.save_new_question(question_id, self.admin_id,
self._create_valid_question_data('ABC'))
question_services.create_new_question_skill_link(
question_id, self.skill_id)
with self.swap(constants, 'ENABLE_NEW_STRUCTURES', True):
self.login(self.ADMIN_EMAIL)
with self.swap(constants, 'NUM_QUESTIONS_PER_PAGE', 1):
json_response = self.get_json(
'%s/%s?cursor=' %
(feconf.TOPIC_EDITOR_QUESTION_URL, self.topic_id))
question_summary_dicts = json_response[
'question_summary_dicts']
self.assertEqual(len(question_summary_dicts), 1)
next_start_cursor = json_response['next_start_cursor']
json_response = self.get_json(
'%s/%s?cursor=%s' % (feconf.TOPIC_EDITOR_QUESTION_URL,
self.topic_id, next_start_cursor))
question_summary_dicts_2 = (
json_response['question_summary_dicts'])
self.assertEqual(len(question_summary_dicts_2), 1)
self.assertNotEqual(question_summary_dicts[0]['id'],
question_summary_dicts_2[0]['id'])
self.logout()
self.login(self.TOPIC_MANAGER_EMAIL)
response = self.testapp.get(
'%s/%s?cursor=' %
(feconf.TOPIC_EDITOR_QUESTION_URL, self.topic_id))
self.assertEqual(response.status_int, 200)
self.logout()
topic_services.assign_role(self.admin, self.topic_manager,
topic_domain.ROLE_MANAGER,
self.topic_id)
self.login(self.TOPIC_MANAGER_EMAIL)
json_response = self.get_json(
'%s/%s' % (feconf.TOPIC_EDITOR_QUESTION_URL, self.topic_id))
question_summary_dicts = json_response['question_summary_dicts']
self.assertEqual(len(question_summary_dicts), 3)
self.logout()
self.login(self.NEW_USER_EMAIL)
response = self.testapp.get(
'%s/%s?cursor=' %
(feconf.TOPIC_EDITOR_QUESTION_URL, self.topic_id),
expect_errors=True)
self.assertEqual(response.status_int, 401)
self.logout()
def test_get_question_count_succeeds(self):
self.login(self.CURRICULUM_ADMIN_EMAIL)
question_id = question_services.get_new_question_id()
question_id_1 = question_services.get_new_question_id()
self.save_new_question(
question_id, self.admin_id,
self._create_valid_question_data('ABC'),
[self.skill_id])
self.save_new_question(
question_id_1, self.admin_id,
self._create_valid_question_data('ABC2'),
[self.skill_id_2])
question_services.create_new_question_skill_link(
self.admin_id, question_id, self.skill_id, 0.5)
question_services.create_new_question_skill_link(
self.admin_id, question_id_1, self.skill_id_2, 0.3)
json_response = self.get_json(
'%s/%s,%s' % (
feconf.QUESTION_COUNT_URL_PREFIX,
self.skill_id, self.skill_id_2
))
self.assertEqual(json_response['total_question_count'], 2)
json_response = self.get_json(
'%s/%s' % (
feconf.QUESTION_COUNT_URL_PREFIX,
self.skill_id
))
self.assertEqual(json_response['total_question_count'], 1)
json_response = self.get_json(
'%s/%s' % (
feconf.QUESTION_COUNT_URL_PREFIX,
self.skill_id_2
))
self.assertEqual(json_response['total_question_count'], 1)
def test_get_with_twenty_or_more_questions(self):
number_of_questions = 50
self.topic_id = 'new_topic'
self.skill_id_1 = skill_services.get_new_skill_id()
self.skill_id_2 = skill_services.get_new_skill_id()
self.topic = topic_domain.Topic.create_default_topic(
self.topic_id, 'new_topic', 'new-topic', 'description', 'fragm')
self.topic.uncategorized_skill_ids.append(self.skill_id_1)
self.topic.thumbnail_filename = 'Image.svg'
self.topic.thumbnail_bg_color = (
constants.ALLOWED_THUMBNAIL_BG_COLORS['topic'][0])
self.topic.practice_tab_is_displayed = True
subtopic_1 = topic_domain.Subtopic.create_default_subtopic(
1, 'Subtopic Title 1', 'url-frag-one')
subtopic_1.skill_ids = [self.skill_id_2]
subtopic_1.url_fragment = 'sub-one-frag'
self.topic.subtopics = [subtopic_1]
self.topic.next_subtopic_id = 2
self.topic.skill_ids_for_diagnostic_test = [self.skill_id_2]
topic_services.save_new_topic(self.admin_id, self.topic)
topic_services.publish_topic(self.topic_id, self.admin_id)
self.save_new_skill(self.skill_id_1,
self.admin_id,
description='Skill Description 1')
for index in range(number_of_questions):
question_id = question_services.get_new_question_id()
self.save_new_question(question_id, self.admin_id,
self._create_valid_question_data(index),
[self.skill_id_1])
question_services.create_new_question_skill_link(
self.admin_id, question_id, self.skill_id_1, 0.5)
json_response = self.get_json('%s/staging/%s' %
(feconf.TOPIC_DATA_HANDLER, 'new-topic'))
expected_dict = {
'topic_name': 'new_topic',
'topic_id': self.topic_id,
'canonical_story_dicts': [],
'additional_story_dicts': [],
'uncategorized_skill_ids': [self.skill_id_1],
'subtopics': [subtopic_1.to_dict()],
'degrees_of_mastery': {
self.skill_id_1: None,
self.skill_id_2: None
},
'skill_descriptions': {
self.skill_id_1: 'Skill Description 1',
self.skill_id_2: None
},
'practice_tab_is_displayed': True
}
self.assertDictContainsSubset(expected_dict, json_response)
self.logout()
def test_get_question_skill_links_of_skill(self):
# If the skill id doesnt exist at all, it returns an empty list.
question_skill_links = (
question_services.get_question_skill_links_of_skill(
'non_existent_skill_id'))
self.assertEqual(len(question_skill_links), 0)
# If the question ids dont exist for a skill, it returns an empty list.
question_skill_links = (
question_services.get_question_skill_links_of_skill('skill_1'))
self.assertEqual(len(question_skill_links), 0)
question_id_2 = question_services.get_new_question_id()
self.save_new_question(question_id_2, self.editor_id,
self._create_valid_question_data('ABC'))
question_id_3 = question_services.get_new_question_id()
self.save_new_question(question_id_3, self.editor_id,
self._create_valid_question_data('ABC'))
question_services.create_new_question_skill_link(
self.question_id, 'skill_1')
question_services.create_new_question_skill_link(
question_id_2, 'skill_1')
question_services.create_new_question_skill_link(
question_id_3, 'skill_2')
# When question ids exist, it returns a list of questionskilllinks.
question_skill_links = (
question_services.get_question_skill_links_of_skill('skill_1'))
self.assertEqual(len(question_skill_links), 2)
self.assertTrue(
isinstance(question_skill_links[0],
question_domain.QuestionSkillLink))
question_ids = [
question_skill.question_id
for question_skill in question_skill_links
]
self.assertItemsEqual(question_ids, [self.question_id, question_id_2])
def test_get_with_more_questions_with_fifty_or_more_skills(self):
number_of_skills = 60
number_of_questions = [0] * 60
number_of_questions[46] = 2
number_of_questions[20] = 3
number_of_questions[29] = 10
self.topic_id = 'new_topic'
skill_ids = ([
skill_services.get_new_skill_id()
for _ in python_utils.RANGE(number_of_skills)
])
self.topic = topic_domain.Topic.create_default_topic(
self.topic_id, 'new_topic', 'new-topic', 'description')
for index in python_utils.RANGE(number_of_skills):
self.topic.uncategorized_skill_ids.append(skill_ids[index])
self.topic.thumbnail_filename = 'Image.svg'
self.topic.thumbnail_bg_color = (
constants.ALLOWED_THUMBNAIL_BG_COLORS['topic'][0])
self.topic.practice_tab_is_displayed = True
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.topic.subtopics = [subtopic_1]
self.topic.next_subtopic_id = 2
topic_services.save_new_topic(self.admin_id, self.topic)
topic_services.publish_topic(self.topic_id, self.admin_id)
for i in python_utils.RANGE(number_of_skills):
self.save_new_skill(skill_ids[i],
self.admin_id,
description='Skill Description')
for i in python_utils.RANGE(number_of_skills):
for j in python_utils.RANGE(number_of_questions[i]):
question_id = question_services.get_new_question_id()
self.save_new_question(question_id, self.admin_id,
self._create_valid_question_data(j),
[skill_ids[i]])
question_services.create_new_question_skill_link(
self.admin_id, question_id, skill_ids[i], 0.5)
json_response = self.get_json('%s/staging/%s' %
(feconf.TOPIC_DATA_HANDLER, 'new-topic'))
expected_dict = {
'topic_name': 'new_topic',
'topic_id': self.topic_id,
'canonical_story_dicts': [],
'additional_story_dicts': [],
'practice_tab_is_displayed': True
}
self.assertDictContainsSubset(expected_dict, json_response)
self.logout()
def test_get_questions_with_multi_skill_ids(self):
question_id_1 = question_services.get_new_question_id()
question_1 = self.save_new_question(
question_id_1, self.editor_id,
self._create_valid_question_data('ABC'), ['skill_1', 'skill_2'])
question_services.create_new_question_skill_link(
self.editor_id, question_id_1, 'skill_1', 0.3)
question_services.create_new_question_skill_link(
self.editor_id, question_id_1, 'skill_2', 0.5)
questions, _, _ = (question_services.
get_questions_and_skill_descriptions_by_skill_ids(
2, ['skill_1', 'skill_2'], ''))
self.assertEqual(len(questions), 1)
self.assertEqual(questions[0].to_dict(), question_1.to_dict())
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])
def test_get_question_summaries_and_skill_descriptions_with_no_skill_ids(
self):
question_id = question_services.get_new_question_id()
self.save_new_question(question_id, self.editor_id,
self._create_valid_question_data('ABC'))
question_services.create_new_question_skill_link(
question_id, 'skill_1', 0.5)
question_summaries, skill_descriptions, _ = (
question_services.get_question_summaries_and_skill_descriptions(
2, [], ''))
self.assertEqual(question_summaries, [])
self.assertEqual(skill_descriptions, [])
def setUp(self):
super(OpportunityServicesIntegrationTest, self).setUp()
self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME)
self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME)
self.admin_id = self.get_user_id_from_email(self.ADMIN_EMAIL)
self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL)
self.set_admins([self.ADMIN_USERNAME])
self.admin = user_services.UserActionsInfo(self.admin_id)
self.TOPIC_ID = 'topic'
self.STORY_ID = 'story'
self.USER_ID = 'user'
self.SKILL_ID = 'skill'
self.QUESTION_ID = question_services.get_new_question_id()
self.THREAD_ID = 'exploration.exp1.thread_1'
# Since a valid exploration is created here, it has EndExploration
# state as well, so the content in that has to be taken into account as
# well when checking content_count in the tests.
explorations = [
self.save_new_valid_exploration('%s' % i,
self.owner_id,
title='title %d' % i,
category='category%d' % i,
end_state_name='End State')
for i in python_utils.RANGE(5)
]
for exp in explorations:
self.publish_exploration(self.owner_id, exp.id)
topic = topic_domain.Topic.create_default_topic(
self.TOPIC_ID, 'topic', 'abbrev', 'description')
topic.thumbnail_filename = 'thumbnail.svg'
topic.thumbnail_bg_color = '#C6DCDA'
topic_services.save_new_topic(self.owner_id, topic)
topic_services.publish_topic(self.TOPIC_ID, self.admin_id)
story = story_domain.Story.create_default_story(
self.STORY_ID, 'A story', 'description', self.TOPIC_ID,
'story-one')
story_services.save_new_story(self.owner_id, story)
topic_services.add_canonical_story(self.owner_id, self.TOPIC_ID,
self.STORY_ID)
topic_services.publish_story(self.TOPIC_ID, self.STORY_ID,
self.admin_id)
