def setUp(self):
"""Before each individual test, create a dummy exploration."""
super(ExplorationServicesUnitTests, self).setUp()
self.EXP_ID = 'An exploration_id'
self.OWNER_EMAIL = '*****@*****.**'
self.EDITOR_EMAIL = '*****@*****.**'
self.VIEWER_EMAIL = '*****@*****.**'
self.OWNER_ID = self.get_user_id_from_email(self.OWNER_EMAIL)
self.EDITOR_ID = self.get_user_id_from_email(self.EDITOR_EMAIL)
self.VIEWER_ID = self.get_user_id_from_email(self.VIEWER_EMAIL)
self.OWNER_NAME = 'owner'
self.EDITOR_NAME = 'editor'
self.VIEWER_NAME = 'viewer'
user_services.get_or_create_user(self.OWNER_ID, self.OWNER_EMAIL)
user_services.get_or_create_user(self.EDITOR_ID, self.EDITOR_EMAIL)
user_services.get_or_create_user(self.VIEWER_ID, self.VIEWER_EMAIL)
self.register_editor(self.OWNER_EMAIL, username=self.OWNER_NAME)
self.register_editor(self.EDITOR_EMAIL, username=self.EDITOR_NAME)
self.register_editor(self.VIEWER_EMAIL, username=self.VIEWER_NAME)
config_services.set_property(
feconf.ADMIN_COMMITTER_ID, 'admin_emails', ['*****@*****.**'])
self.user_id_admin = self.get_user_id_from_email('*****@*****.**')
def post(self):
"""Handles POST requests."""
try:
if self.payload.get('action') == 'reload_exploration':
exploration_id = self.payload.get('explorationId')
logging.info(
'[ADMIN] %s reloaded exploration %s' %
(self.user_id, exploration_id))
exp_services.delete_demo(unicode(exploration_id))
exp_services.load_demo(unicode(exploration_id))
elif self.payload.get('action') == 'save_config_properties':
new_config_property_values = self.payload.get(
'new_config_property_values')
logging.info('[ADMIN] %s saved config property values: %s' %
(self.user_id, new_config_property_values))
for (name, value) in new_config_property_values.iteritems():
config_services.set_property(self.user_id, name, value)
elif self.payload.get('action') == 'revert_config_property':
config_property_id = self.payload.get('config_property_id')
logging.info('[ADMIN] %s reverted config property: %s' %
(self.user_id, config_property_id))
config_services.revert_property(
self.user_id, config_property_id)
elif self.payload.get('action') == 'refresh_computed_property':
computed_property_name = self.payload.get(
'computed_property_name')
config_domain.Registry.get_config_property(
computed_property_name).refresh_default_value()
self.render_json({})
except Exception as e:
self.render_json({'error': unicode(e)})
raise
def test_send_email_does_not_resend_within_duplicate_interval(self):
can_send_emails_ctx = self.swap(
feconf, 'CAN_SEND_EMAILS_TO_USERS', True)
duplicate_email_ctx = self.swap(
feconf, 'DUPLICATE_EMAIL_INTERVAL_MINS', 2)
logged_errors = []
def _log_error_for_tests(error_message):
logged_errors.append(error_message)
log_new_error_counter = test_utils.CallCounter(_log_error_for_tests)
log_new_error_ctx = self.swap(
email_manager, 'log_new_error', log_new_error_counter)
with can_send_emails_ctx, duplicate_email_ctx, log_new_error_ctx:
config_services.set_property(
self.admin_id, email_manager.EMAIL_SENDER_NAME.name,
'Email Sender')
all_models = email_models.SentEmailModel.get_all().fetch()
self.assertEqual(len(all_models), 0)
# pylint: disable=protected-access
email_manager._send_email(
self.new_user_id, feconf.SYSTEM_COMMITTER_ID,
feconf.EMAIL_INTENT_SIGNUP, 'Email Subject', 'Email Body',
feconf.SYSTEM_EMAIL_ADDRESS)
# Check that a new email was sent.
messages = self.mail_stub.get_sent_messages(to=self.NEW_USER_EMAIL)
self.assertEqual(1, len(messages))
# Check that the content of this email was recorded in
# SentEmailModel.
all_models = email_models.SentEmailModel.get_all().fetch()
self.assertEqual(len(all_models), 1)
# No error should be recorded in the logs.
self.assertEqual(log_new_error_counter.times_called, 0)
email_manager._send_email(
self.new_user_id, feconf.SYSTEM_COMMITTER_ID,
feconf.EMAIL_INTENT_SIGNUP, 'Email Subject', 'Email Body',
feconf.SYSTEM_EMAIL_ADDRESS)
# pylint: enable=protected-access
# An error should be recorded in the logs.
self.assertEqual(log_new_error_counter.times_called, 1)
self.assertRegexpMatches(logged_errors[0], 'Duplicate email')
# Check that a new email was not sent.
messages = self.mail_stub.get_sent_messages(to=self.NEW_USER_EMAIL)
self.assertEqual(1, len(messages))
# Check that the content of this email was not recorded in
# SentEmailModel.
all_models = email_models.SentEmailModel.get_all().fetch()
self.assertEqual(len(all_models), 1)
def setUp(self):
super(EmailDashboardDataHandlerTests, self).setUp()
self.signup(self.SUBMITTER_EMAIL, self.SUBMITTER_USERNAME)
self.submitter_id = self.get_user_id_from_email(self.SUBMITTER_EMAIL)
self.signup(self.USER_A_EMAIL, self.USER_A_USERNAME)
self.user_a_id = self.get_user_id_from_email(self.USER_A_EMAIL)
config_services.set_property(self.submitter_id, "whitelisted_email_senders", [self.SUBMITTER_USERNAME])
def setUp(self):
super(ModeratorEmailsTest, self).setUp()
self.signup(self.EDITOR_EMAIL, self.EDITOR_USERNAME)
self.EDITOR_ID = self.get_user_id_from_email(self.EDITOR_EMAIL)
self.signup(self.MODERATOR_EMAIL, self.MODERATOR_USERNAME)
self.MODERATOR_ID = self.get_user_id_from_email(self.MODERATOR_EMAIL)
self.set_moderators([self.MODERATOR_EMAIL])
# The editor publishes an exploration.
self.EXP_ID = 'eid'
self.save_new_valid_exploration(
self.EXP_ID, self.EDITOR_ID, title='My Exploration',
end_state_name='END')
rights_manager.publish_exploration(self.EDITOR_ID, self.EXP_ID)
# Set the default email config.
self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME)
self.ADMIN_ID = self.get_user_id_from_email(self.ADMIN_EMAIL)
config_services.set_property(
self.ADMIN_ID, 'publicize_exploration_email_html_body',
'Default publicization email body')
config_services.set_property(
self.ADMIN_ID, 'unpublish_exploration_email_html_body',
'Default unpublishing email body')
def test_email_only_sent_once_for_repeated_signups_by_same_user(self):
with self.swap(feconf, 'CAN_SEND_EMAILS_TO_USERS', True):
config_services.set_property(
self.admin_id, email_manager.EMAIL_FOOTER.name,
self.new_footer)
config_services.set_property(
self.admin_id, email_manager.SIGNUP_EMAIL_CONTENT.name,
self.new_email_content)
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.SIGNUP_URL)
csrf_token = self.get_csrf_token_from_response(response)
self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
}, csrf_token=csrf_token)
# Check that an email was sent.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(1, len(messages))
# Send a second POST request.
self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
}, csrf_token=csrf_token)
# Check that no new email was sent.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(1, len(messages))
def test_email_only_sent_if_signup_was_successful(self):
with self.swap(feconf, 'CAN_SEND_EMAILS_TO_USERS', True):
config_services.set_property(
self.ADMIN_ID, email_manager.EMAIL_FOOTER.name,
self.NEW_FOOTER)
config_services.set_property(
self.ADMIN_ID, email_manager.SIGNUP_EMAIL_CONTENT.name,
self.NEW_EMAIL_CONTENT)
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.SIGNUP_URL)
csrf_token = self.get_csrf_token_from_response(response)
self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': '******'
},
csrf_token=csrf_token, expect_errors=True, expected_status_int=400)
# Check that no email was sent.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(0, len(messages))
# Redo the signup process with a good username.
self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
}, csrf_token=csrf_token)
# Check that a new email was sent.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(1, len(messages))
def post(self):
"""Handles POST requests."""
try:
if self.payload.get('action') == 'reload_exploration':
exploration_id = self.payload.get('exploration_id')
logging.info(
'[ADMIN] %s reloaded exploration %s' %
(self.user_id, exploration_id))
exp_services.delete_demo(unicode(exploration_id))
exp_services.load_demo(unicode(exploration_id))
elif self.payload.get('action') == 'clear_search_index':
exp_services.clear_search_index()
elif self.payload.get('action') == 'save_config_properties':
new_config_property_values = self.payload.get(
'new_config_property_values')
logging.info('[ADMIN] %s saved config property values: %s' %
(self.user_id, new_config_property_values))
for (name, value) in new_config_property_values.iteritems():
config_services.set_property(self.user_id, name, value)
elif self.payload.get('action') == 'revert_config_property':
config_property_id = self.payload.get('config_property_id')
logging.info('[ADMIN] %s reverted config property: %s' %
(self.user_id, config_property_id))
config_services.revert_property(
self.user_id, config_property_id)
elif self.payload.get('action') == 'refresh_computed_property':
computed_property_name = self.payload.get(
'computed_property_name')
config_domain.Registry.get_config_property(
computed_property_name).refresh_default_value()
elif self.payload.get('action') == 'start_new_job':
for klass in jobs_registry.ONE_OFF_JOB_MANAGERS:
if klass.__name__ == self.payload.get('job_type'):
klass.enqueue(klass.create_new())
break
elif self.payload.get('action') == 'cancel_job':
job_id = self.payload.get('job_id')
job_type = self.payload.get('job_type')
for klass in jobs_registry.ONE_OFF_JOB_MANAGERS:
if klass.__name__ == job_type:
klass.cancel(job_id, self.user_id)
break
elif self.payload.get('action') == 'start_computation':
computation_type = self.payload.get('computation_type')
for klass in jobs_registry.ALL_CONTINUOUS_COMPUTATION_MANAGERS:
if klass.__name__ == computation_type:
klass.start_computation()
break
elif self.payload.get('action') == 'stop_computation':
computation_type = self.payload.get('computation_type')
for klass in jobs_registry.ALL_CONTINUOUS_COMPUTATION_MANAGERS:
if klass.__name__ == computation_type:
klass.stop_computation(self.user_id)
break
self.render_json({})
except Exception as e:
self.render_json({'error': unicode(e)})
raise
def test_derived_config_properties_cannot_be_set_directly(self):
self.signup(self.MODERATOR_EMAIL, self.MODERATOR_USERNAME)
with self.assertRaisesRegexp(Exception, "Cannot modify value of config property moderator_ids directly"):
config_services.set_property(
self.MODERATOR_EMAIL,
config_domain.MODERATOR_IDS.name,
[self.get_user_id_from_email(self.MODERATOR_EMAIL)],
)
def test_unpublished_explorations_are_visible_to_admins(self):
config_services.set_property(
feconf.ADMIN_COMMITTER_ID, 'admin_emails', ['*****@*****.**'])
self.login('*****@*****.**')
response = self.testapp.get(
'%s/%s' % (feconf.EXPLORATION_URL_PREFIX, self.EXP_ID))
self.assertEqual(response.status_int, 200)
self.assertIn('This is a preview', response.body)
self.logout()
def init_csrf_secret(cls):
"""Verify that non-default CSRF secret exists; creates one if not."""
# Any non-default value is fine.
if CSRF_SECRET.value and CSRF_SECRET.value != DEFAULT_CSRF_SECRET:
return
# Initialize to random value.
config_services.set_property(
CSRF_SECRET.name, base64.urlsafe_b64encode(os.urandom(20)))
def init_csrf_secret(cls):
"""Verify that non-default CSRF secret exists; creates one if not."""
# Any non-default value is fine.
if CSRF_SECRET.value and CSRF_SECRET.value != DEFAULT_CSRF_SECRET:
return
# Initialize to random value.
config_services.set_property(feconf.SYSTEM_COMMITTER_ID,
CSRF_SECRET.name,
base64.urlsafe_b64encode(os.urandom(20)))
def test_guest_user_check_contribution_rights(self):
response = self.get_json('/usercontributionrightsdatahandler')
config_services.set_property(
'admin', 'contributor_can_suggest_questions', False)
self.assertEqual(
response, {
'can_review_translation_for_language_codes': [],
'can_review_voiceover_for_language_codes': [],
'can_review_questions': False,
'can_suggest_questions': False
})
def put(self):
promo_bar_enabled_value = self.payload.get('promo_bar_enabled')
promo_bar_message_value = self.payload.get('promo_bar_message')
logging.info(
'[RELEASE COORDINATOR] %s saved promo-bar config property values: '
'%s' % (self.user_id, promo_bar_message_value))
config_services.set_property(self.user_id, 'promo_bar_enabled',
promo_bar_enabled_value)
config_services.set_property(self.user_id, 'promo_bar_message',
promo_bar_message_value)
self.render_json({})
def test_can_get_classroom_by_url_fragment(self):
topic_id = topic_services.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 test_splash_page_demo_exploration(self):
config_services.set_property(feconf.ADMIN_COMMITTER_ID,
'splash_page_exploration_id', '1')
exp_services.load_demo('1')
self.assertTrue(rights_manager.Actor(self.user_id_a).can_view('1'))
self.assertTrue(rights_manager.Actor(self.user_id_a).can_edit('1'))
self.assertFalse(rights_manager.Actor(self.user_id_a).can_delete('1'))
self.assertTrue(rights_manager.Actor(self.user_id_admin).can_view('1'))
self.assertTrue(rights_manager.Actor(self.user_id_admin).can_edit('1'))
self.assertTrue(
rights_manager.Actor(self.user_id_admin).can_delete('1'))
def test_get_featured_translation_languages(self):
response = self.get_json('/retrivefeaturedtranslationlanguages')
self.assertEqual(response, {'featured_translation_languages': []})
new_value = [{
'language_code': 'en',
'explanation': 'Partnership with ABC'
}]
config_services.set_property('admin', 'featured_translation_languages',
new_value)
response = self.get_json('/retrivefeaturedtranslationlanguages')
self.assertEqual(response,
{'featured_translation_languages': new_value})
def test_handler_with_disabled_dashboard_flag_raise_404(self):
config_services.set_property(
'admin', 'contributor_dashboard_is_enabled', True)
self.get_json(
'%s/skill' % feconf.CONTRIBUTOR_OPPORTUNITIES_DATA_URL,
params={}, expected_status_int=200)
config_services.set_property(
'admin', 'contributor_dashboard_is_enabled', False)
self.get_json(
'%s/skill' % feconf.CONTRIBUTOR_OPPORTUNITIES_DATA_URL,
params={}, expected_status_int=404)
def test_splash_page_demo_exploration(self):
config_services.set_property(
feconf.ADMIN_COMMITTER_ID, 'splash_page_exploration_id', '1')
exp_services.load_demo('1')
self.assertTrue(rights_manager.Actor(self.user_id_a).can_view('1'))
self.assertTrue(rights_manager.Actor(self.user_id_a).can_edit('1'))
self.assertFalse(rights_manager.Actor(self.user_id_a).can_delete('1'))
self.assertTrue(rights_manager.Actor(self.user_id_admin).can_view('1'))
self.assertTrue(rights_manager.Actor(self.user_id_admin).can_edit('1'))
self.assertTrue(
rights_manager.Actor(self.user_id_admin).can_delete('1'))
def test_get_classroom_url_fragment_for_topic_id(self):
topic_id = topic_services.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_exploration_upload_button(self):
"""Test that the exploration upload button appears when appropriate."""
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.GALLERY_URL)
self.assertEqual(response.status_int, 200)
response.mustcontain(no=['Upload Exploration'])
config_services.set_property(
feconf.SYSTEM_COMMITTER_ID, 'allow_yaml_file_upload', True)
response = self.testapp.get(feconf.GALLERY_URL)
self.assertEqual(response.status_int, 200)
response.mustcontain('Upload Exploration')
self.logout()
def test_exploration_upload_button(self):
"""Test that the exploration upload button appears when appropriate."""
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.GALLERY_URL)
self.assertEqual(response.status_int, 200)
response.mustcontain(no=['Upload Exploration'])
config_services.set_property(feconf.SYSTEM_COMMITTER_ID,
'allow_yaml_file_upload', True)
response = self.testapp.get(feconf.GALLERY_URL)
self.assertEqual(response.status_int, 200)
response.mustcontain('Upload Exploration')
self.logout()
def test_return_default_if_associated_classroom_is_not_found(self):
topic_id = topic_services.get_new_topic_id()
config_services.set_property(
self.user_id_admin, 'classroom_pages_data', [{
'name': 'math',
'url_fragment': 'math-two',
'topic_ids': [],
'course_details': '',
'topic_list_intro': ''
}])
classroom_url_fragment = (
classroom_services.get_classroom_url_fragment_for_topic_id(
topic_id))
self.assertNotEqual(classroom_url_fragment, 'math-two')
self.assertEqual(
classroom_url_fragment,
constants.CLASSROOM_URL_FRAGMENT_FOR_UNATTACHED_TOPICS)
def test_exploration_upload_button(self):
"""Test that the exploration upload button appears when appropriate."""
self.register_editor('*****@*****.**')
self.login('*****@*****.**')
response = self.testapp.get(feconf.CONTRIBUTE_GALLERY_URL)
self.assertEqual(response.status_int, 200)
response.mustcontain(no=['Upload Existing Exploration'])
config_services.set_property(
feconf.ADMIN_COMMITTER_ID, 'allow_yaml_file_upload', True)
response = self.testapp.get(feconf.CONTRIBUTE_GALLERY_URL)
self.assertEqual(response.status_int, 200)
response.mustcontain('Upload Existing Exploration')
self.logout()
def test_exploration_upload_button(self):
"""Test that the exploration upload button appears when appropriate."""
self.register_editor('*****@*****.**')
self.login('*****@*****.**')
response = self.testapp.get(feconf.CONTRIBUTE_GALLERY_URL)
self.assertEqual(response.status_int, 200)
response.mustcontain(no=['Upload Existing Exploration'])
config_services.set_property(
feconf.ADMIN_COMMITTER_ID, 'allow_yaml_file_upload', True)
response = self.testapp.get(feconf.CONTRIBUTE_GALLERY_URL)
self.assertEqual(response.status_int, 200)
response.mustcontain('Upload Existing Exploration')
self.logout()
def post(self) -> None:
"""Handles POST requests."""
result = {}
if self.normalized_payload.get('action') == 'save_config_properties':
new_config_property_values = self.normalized_payload.get(
'new_config_property_values')
for (name, value) in new_config_property_values.items():
config_services.set_property(self.user_id, name, value)
logging.info('[BLOG ADMIN] %s saved config property values: %s' %
(self.user_id, new_config_property_values))
elif self.normalized_payload.get('action') == 'revert_config_property':
config_property_id = (
self.normalized_payload.get('config_property_id'))
config_services.revert_property(self.user_id, config_property_id)
logging.info('[BLOG ADMIN] %s reverted config property: %s' %
(self.user_id, config_property_id))
self.render_json(result)
def test_email_not_sent_if_content_config_is_partially_modified(self):
can_send_emails_ctx = self.swap(feconf, 'CAN_SEND_EMAILS_TO_USERS',
True)
config_services.set_property(
self.ADMIN_ID, email_manager.SIGNUP_EMAIL_CONTENT.name, {
'subject':
(email_manager.SIGNUP_EMAIL_CONTENT.default_value['subject']),
'html_body':
'New HTML body.',
})
logged_errors = []
def _log_error_for_tests(error_message):
logged_errors.append(error_message)
log_new_error_counter = test_utils.CallCounter(_log_error_for_tests)
log_new_error_ctx = self.swap(email_manager, 'log_new_error',
log_new_error_counter)
with can_send_emails_ctx, log_new_error_ctx:
self.assertEqual(log_new_error_counter.times_called, 0)
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.SIGNUP_URL)
csrf_token = self.get_csrf_token_from_response(response)
# No user-facing error should surface.
response_dict = self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
},
csrf_token=csrf_token)
# However, an error should be recorded in the logs.
self.assertEqual(log_new_error_counter.times_called, 1)
self.assertEqual(
logged_errors[0],
'Please ensure that the value for the admin config property '
'SIGNUP_EMAIL_CONTENT is set, before allowing post-signup '
'emails to be sent.')
# Check that no email was sent.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(0, len(messages))
def setUp(self) -> None:
super(ClassroomPageAccessValidationHandlerTests, self).setUp()
self.signup(
self.CURRICULUM_ADMIN_EMAIL, self.CURRICULUM_ADMIN_USERNAME)
self.set_curriculum_admins([self.CURRICULUM_ADMIN_USERNAME]) # 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.signup(self.EDITOR_EMAIL, self.EDITOR_USERNAME)
self.editor_id = self.get_user_id_from_email(self.EDITOR_EMAIL) # type: ignore[no-untyped-call]
config_services.set_property( # type: ignore[no-untyped-call]
self.user_id_admin, 'classroom_pages_data', [{
'name': 'math',
'url_fragment': 'math',
'topic_ids': [],
'course_details': '',
'topic_list_intro': ''
}])
def test_can_get_classroom_by_url_fragment(self) -> None:
topic_id = topic_fetchers.get_new_topic_id(
) # type: ignore[no-untyped-call]
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')
assert classroom is not None
self.assertEqual(classroom.name, 'math')
self.assertEqual(classroom.url_fragment, 'math')
self.assertEqual(classroom.topic_ids, [topic_id])
def test_email_not_sent_if_content_config_is_partially_modified(self):
can_send_emails_ctx = self.swap(
feconf, 'CAN_SEND_EMAILS_TO_USERS', True)
config_services.set_property(
self.admin_id, email_manager.SIGNUP_EMAIL_CONTENT.name, {
'subject': (
email_manager.SIGNUP_EMAIL_CONTENT.default_value[
'subject']),
'html_body': 'New HTML body.',
})
logged_errors = []
def _log_error_for_tests(error_message):
logged_errors.append(error_message)
log_new_error_counter = test_utils.CallCounter(_log_error_for_tests)
log_new_error_ctx = self.swap(
email_manager, 'log_new_error', log_new_error_counter)
with can_send_emails_ctx, log_new_error_ctx:
self.assertEqual(log_new_error_counter.times_called, 0)
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.SIGNUP_URL)
csrf_token = self.get_csrf_token_from_response(response)
# No user-facing error should surface.
self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
}, csrf_token=csrf_token)
# However, an error should be recorded in the logs.
self.assertEqual(log_new_error_counter.times_called, 1)
self.assertEqual(
logged_errors[0],
'Please ensure that the value for the admin config property '
'SIGNUP_EMAIL_CONTENT is set, before allowing post-signup '
'emails to be sent.')
# Check that no email was sent.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(0, len(messages))
def test_email_not_sent_if_sending_emails_is_not_enabled(self):
self.login(self.ADMIN_EMAIL, is_super_admin=True)
config_services.set_property(
'committer_id', 'contributor_dashboard_reviewer_emails_is_enabled',
True)
with self.cannot_send_emails, self.testapp_swap:
with self.swap(
email_manager,
'send_mail_to_notify_contributor_dashboard_reviewers',
self._mock_send_contributor_dashboard_reviewers_emails):
self.get_html_response(
'/cron/mail/reviewers/contributor_dashboard_suggestions')
self.assertEqual(len(self.reviewer_ids), 0)
self.assertEqual(len(self.reviewers_suggestion_email_infos), 0)
self.logout()
def setUp(self):
super(EmailDashboardResultTests, self).setUp()
self.signup(self.USER_A_EMAIL, self.USER_A_USERNAME)
# User A has one created exploration.
# User B has one created exploration.
# Submitter and new_submitter are submitter of query.
self.user_a_id = self.get_user_id_from_email(self.USER_A_EMAIL)
self.signup(self.USER_B_EMAIL, self.USER_B_USERNAME)
self.user_b_id = self.get_user_id_from_email(self.USER_B_EMAIL)
self.save_new_valid_exploration(self.EXP_ID_1, self.user_a_id, end_state_name="End")
self.save_new_valid_exploration(self.EXP_ID_2, self.user_b_id, end_state_name="End")
self.signup(self.SUBMITTER_EMAIL, self.SUBMITTER_USERNAME)
self.submitter_id = self.get_user_id_from_email(self.SUBMITTER_EMAIL)
self.signup(self.NEW_SUBMITTER_EMAIL, self.NEW_SUBMITTER_USERNAME)
self.new_submitter_id = self.get_user_id_from_email(self.NEW_SUBMITTER_EMAIL)
config_services.set_property(
self.submitter_id, "whitelisted_email_senders", [self.SUBMITTER_USERNAME, self.NEW_SUBMITTER_USERNAME]
)
def test_email_not_sent_if_notifying_admins_about_suggestions_is_disabled(
self):
self.login(self.CURRICULUM_ADMIN_EMAIL, is_super_admin=True)
config_services.set_property(
'committer_id',
'notify_admins_suggestions_waiting_too_long_is_enabled', False)
with self.can_send_emails, self.testapp_swap:
with self.swap(
email_manager,
'send_mail_to_notify_admins_that_reviewers_are_needed',
self.mock_send_mail_to_notify_admins_that_reviewers_are_needed):
self.get_json(
'/cron/mail/admins/contributor_dashboard_bottlenecks')
self.assertEqual(len(self.admin_ids), 0)
self.assertDictEqual(self.suggestion_types_needing_reviewers, {})
self.logout()
def test_user_banning(self):
"""Test that banned users are banned."""
exp_id = '0'
exp_services.load_demo(exp_id)
rights_manager.release_ownership_of_exploration(
feconf.SYSTEM_COMMITTER_ID, exp_id)
# Sign-up new editors Joe and Sandra.
self.signup('*****@*****.**', 'joe')
self.signup('*****@*****.**', 'sandra')
# Joe logs in.
self.login('*****@*****.**')
response = self.testapp.get(feconf.LIBRARY_INDEX_URL)
self.assertEqual(response.status_int, 200)
response = self.testapp.get('/create/%s' % exp_id)
self.assertEqual(response.status_int, 200)
self.assert_can_edit(response.body)
# Ban joe.
config_services.set_property(
feconf.SYSTEM_COMMITTER_ID, 'banned_usernames', ['joe'])
# Test that Joe is banned. (He can still access the library page.)
response = self.testapp.get(
feconf.LIBRARY_INDEX_URL, expect_errors=True)
self.assertEqual(response.status_int, 200)
response = self.testapp.get('/create/%s' % exp_id, expect_errors=True)
self.assertEqual(response.status_int, 200)
self.assert_cannot_edit(response.body)
# Joe logs out.
self.logout()
# Sandra logs in and is unaffected.
self.login('*****@*****.**')
response = self.testapp.get('/create/%s' % exp_id)
self.assertEqual(response.status_int, 200)
self.assert_can_edit(response.body)
self.logout()
def setUp(self):
super(ExplorationRightsTests, self).setUp()
self.register_editor('*****@*****.**', 'A')
self.register_editor('*****@*****.**', 'B')
self.register_editor('*****@*****.**', 'C')
self.register_editor('*****@*****.**', 'D')
self.register_editor('*****@*****.**', 'E')
self.register_editor('*****@*****.**', 'adm')
self.user_id_a = self.get_user_id_from_email('*****@*****.**')
self.user_id_b = self.get_user_id_from_email('*****@*****.**')
self.user_id_c = self.get_user_id_from_email('*****@*****.**')
self.user_id_d = self.get_user_id_from_email('*****@*****.**')
self.user_id_e = self.get_user_id_from_email('*****@*****.**')
self.user_id_admin = self.get_user_id_from_email('*****@*****.**')
config_services.set_property(feconf.ADMIN_COMMITTER_ID, 'admin_emails',
['*****@*****.**'])
self.EXP_ID = 'exp_id'
def setUp(self):
super(ExplorationRightsTests, self).setUp()
self.register_editor('*****@*****.**', 'A')
self.register_editor('*****@*****.**', 'B')
self.register_editor('*****@*****.**', 'C')
self.register_editor('*****@*****.**', 'D')
self.register_editor('*****@*****.**', 'E')
self.register_editor('*****@*****.**', 'adm')
self.user_id_a = self.get_user_id_from_email('*****@*****.**')
self.user_id_b = self.get_user_id_from_email('*****@*****.**')
self.user_id_c = self.get_user_id_from_email('*****@*****.**')
self.user_id_d = self.get_user_id_from_email('*****@*****.**')
self.user_id_e = self.get_user_id_from_email('*****@*****.**')
self.user_id_admin = self.get_user_id_from_email('*****@*****.**')
config_services.set_property(
feconf.ADMIN_COMMITTER_ID, 'admin_emails', ['*****@*****.**'])
self.EXP_ID = 'exp_id'
def test_email_sent_to_admin_if_sending_admin_need_reviewers_emails_enabled(
self):
self.login(self.ADMIN_EMAIL, is_super_admin=True)
config_services.set_property(
'committer_id', 'enable_admin_notifications_for_reviewer_shortage',
True)
with self.can_send_emails, self.testapp_swap:
with self.swap(
email_manager,
'send_mail_to_notify_admins_that_reviewers_are_needed',
self.
mock_send_mail_to_notify_admins_that_reviewers_are_needed):
self.get_html_response(
'/cron/mail/admins/contributor_dashboard_bottlenecks')
self.assertEqual(len(self.admin_ids), 1)
self.assertEqual(self.admin_ids[0], self.admin_id)
self.assertDictEqual(self.suggestion_types_needing_reviewers,
self.expected_suggestion_types_needing_reviewers)
def test_email_not_sent_if_reviewer_ids_is_empty(self):
self.login(self.CURRICULUM_ADMIN_EMAIL, is_super_admin=True)
config_services.set_property(
'committer_id', 'contributor_dashboard_reviewer_emails_is_enabled',
True)
user_services.remove_translation_review_rights_in_language(
self.reviewer_id, self.language_code)
with self.can_send_emails, self.testapp_swap:
with self.swap(
email_manager,
'send_mail_to_notify_contributor_dashboard_reviewers',
self._mock_send_contributor_dashboard_reviewers_emails):
self.get_html_response(
'/cron/mail/reviewers/contributor_dashboard_suggestions')
self.assertEqual(len(self.reviewer_ids), 0)
self.assertEqual(len(self.reviewers_suggestion_email_infos), 0)
self.logout()
def test_email_with_bad_content_is_not_sent(self):
can_send_emails_ctx = self.swap(feconf, 'CAN_SEND_EMAILS_TO_USERS',
True)
config_services.set_property(
self.ADMIN_ID, email_manager.SIGNUP_EMAIL_CONTENT.name, {
'subject': 'New email subject',
'html_body': 'New HTML body.<script>alert(3);</script>',
})
logged_errors = []
def _log_error_for_tests(error_message):
logged_errors.append(error_message)
log_new_error_counter = test_utils.CallCounter(_log_error_for_tests)
log_new_error_ctx = self.swap(email_manager, 'log_new_error',
log_new_error_counter)
with can_send_emails_ctx, log_new_error_ctx:
self.assertEqual(log_new_error_counter.times_called, 0)
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.SIGNUP_URL)
csrf_token = self.get_csrf_token_from_response(response)
# No user-facing error should surface.
response_dict = self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
},
csrf_token=csrf_token)
# However, an error should be recorded in the logs.
self.assertEqual(log_new_error_counter.times_called, 1)
self.assertTrue(logged_errors[0].startswith(
'Original email HTML body does not match cleaned HTML body'))
# Check that no email was sent.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(0, len(messages))
def test_user_banning(self):
"""Test that banned users are banned."""
exp_id = '0'
exp_services.load_demo(exp_id)
rights_manager.release_ownership_of_exploration(
feconf.SYSTEM_COMMITTER_ID, exp_id)
# Sign-up new editors Joe and Sandra.
self.signup('*****@*****.**', 'joe')
self.signup('*****@*****.**', 'sandra')
# Joe logs in.
self.login('*****@*****.**')
response = self.testapp.get(feconf.GALLERY_URL)
self.assertEqual(response.status_int, 200)
response = self.testapp.get('/create/%s' % exp_id)
self.assertEqual(response.status_int, 200)
self.assert_can_edit(response.body)
# Ban joe.
config_services.set_property(
feconf.SYSTEM_COMMITTER_ID, 'banned_usernames', ['joe'])
# Test that Joe is banned. (He can still access the gallery.)
response = self.testapp.get(feconf.GALLERY_URL, expect_errors=True)
self.assertEqual(response.status_int, 200)
response = self.testapp.get('/create/%s' % exp_id, expect_errors=True)
self.assertEqual(response.status_int, 200)
self.assert_cannot_edit(response.body)
# Joe logs out.
self.logout()
# Sandra logs in and is unaffected.
self.login('*****@*****.**')
response = self.testapp.get('/create/%s' % exp_id)
self.assertEqual(response.status_int, 200)
self.assert_can_edit(response.body)
self.logout()
def setUp(self):
"""Creates dummy users."""
super(ExplorationDeletionRightsTest, self).setUp()
self.admin_email = '*****@*****.**'
self.owner_email = '*****@*****.**'
self.editor_email = '*****@*****.**'
self.viewer_email = '*****@*****.**'
# Usernames containing the string 'admin' are reserved.
self.register_editor(self.admin_email, username='******')
self.register_editor(self.owner_email, username='******')
self.register_editor(self.editor_email, username='******')
self.register_editor(self.viewer_email, 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.editor_id = self.get_user_id_from_email(self.editor_email)
self.viewer_id = self.get_user_id_from_email(self.viewer_email)
config_services.set_property(
feconf.ADMIN_COMMITTER_ID, 'admin_emails', ['*****@*****.**'])
def test_email_sent_to_reviewer_if_sending_reviewer_emails_is_enabled(self):
self.login(self.CURRICULUM_ADMIN_EMAIL, is_super_admin=True)
config_services.set_property(
'committer_id',
'contributor_dashboard_reviewer_emails_is_enabled', True)
with self.can_send_emails, self.testapp_swap:
with self.swap(
email_manager,
'send_mail_to_notify_contributor_dashboard_reviewers',
self._mock_send_contributor_dashboard_reviewers_emails):
self.get_json(
'/cron/mail/reviewers/contributor_dashboard_suggestions')
self.assertEqual(len(self.reviewer_ids), 1)
self.assertEqual(self.reviewer_ids[0], self.reviewer_id)
self.assertEqual(len(self.reviewers_suggestion_email_infos), 1)
self.assertEqual(len(self.reviewers_suggestion_email_infos[0]), 1)
self._assert_reviewable_suggestion_email_infos_are_equal(
self.reviewers_suggestion_email_infos[0][0],
self.expected_reviewable_suggestion_email_info)
def test_email_not_sent_if_config_does_not_permit_it(self):
with self.swap(feconf, 'CAN_SEND_EMAILS_TO_USERS', False):
config_services.set_property(
self.admin_id, email_manager.EMAIL_FOOTER.name,
self.new_footer)
config_services.set_property(
self.admin_id, email_manager.SIGNUP_EMAIL_CONTENT.name,
self.new_email_content)
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.SIGNUP_URL)
csrf_token = self.get_csrf_token_from_response(response)
self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
}, csrf_token=csrf_token)
# Check that no email was sent.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(0, len(messages))
def test_email_with_bad_content_is_not_sent(self):
can_send_emails_ctx = self.swap(
feconf, 'CAN_SEND_EMAILS_TO_USERS', True)
config_services.set_property(
self.admin_id, email_manager.SIGNUP_EMAIL_CONTENT.name, {
'subject': 'New email subject',
'html_body': 'New HTML body.<script>alert(3);</script>',
})
logged_errors = []
def _log_error_for_tests(error_message):
logged_errors.append(error_message)
log_new_error_counter = test_utils.CallCounter(_log_error_for_tests)
log_new_error_ctx = self.swap(
email_manager, 'log_new_error', log_new_error_counter)
with can_send_emails_ctx, log_new_error_ctx:
self.assertEqual(log_new_error_counter.times_called, 0)
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.SIGNUP_URL)
csrf_token = self.get_csrf_token_from_response(response)
# No user-facing error should surface.
self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
}, csrf_token=csrf_token)
# However, an error should be recorded in the logs.
self.assertEqual(log_new_error_counter.times_called, 1)
self.assertTrue(logged_errors[0].startswith(
'Original email HTML body does not match cleaned HTML body'))
# Check that no email was sent.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(0, len(messages))
def test_contents_of_signup_email_are_correct(self):
with self.swap(feconf, 'CAN_SEND_EMAILS_TO_USERS', True):
config_services.set_property(
self.admin_id, email_manager.EMAIL_FOOTER.name,
self.new_footer)
config_services.set_property(
self.admin_id, email_manager.SIGNUP_EMAIL_CONTENT.name,
self.new_email_content)
config_services.set_property(
self.admin_id, email_manager.EMAIL_SENDER_NAME.name,
'Email Sender')
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.SIGNUP_URL)
csrf_token = self.get_csrf_token_from_response(response)
self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
}, csrf_token=csrf_token)
# Check that an email was sent with the correct content.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(1, len(messages))
self.assertEqual(
messages[0].sender,
'Email Sender <%s>' % feconf.SYSTEM_EMAIL_ADDRESS)
self.assertEqual(messages[0].to, self.EDITOR_EMAIL)
self.assertEqual(messages[0].subject, 'Welcome!')
self.assertEqual(
messages[0].body.decode(), self.expected_text_email_content)
self.assertEqual(
messages[0].html.decode(), self.expected_html_email_content)
def test_contents_of_signup_email_are_correct(self):
with self.swap(feconf, 'CAN_SEND_EMAILS_TO_USERS', True):
config_services.set_property(self.ADMIN_ID,
email_manager.EMAIL_FOOTER.name,
self.NEW_FOOTER)
config_services.set_property(
self.ADMIN_ID, email_manager.SIGNUP_EMAIL_CONTENT.name,
self.NEW_EMAIL_CONTENT)
config_services.set_property(self.ADMIN_ID,
email_manager.EMAIL_SENDER_NAME.name,
'Email Sender')
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.SIGNUP_URL)
csrf_token = self.get_csrf_token_from_response(response)
response_dict = self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
},
csrf_token=csrf_token)
# Check that an email was sent with the correct content.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(1, len(messages))
self.assertEqual(messages[0].sender,
'Email Sender <%s>' % feconf.SYSTEM_EMAIL_ADDRESS)
self.assertEqual(messages[0].to, self.EDITOR_EMAIL)
self.assertEqual(messages[0].subject, 'Welcome!')
self.assertEqual(messages[0].body.decode(),
self.EXPECTED_PLAINTEXT_EMAIL_CONTENT)
self.assertEqual(messages[0].html.decode(),
self.EXPECTED_HTML_EMAIL_CONTENT)
def test_can_suggest_questions_flag_in_response(self):
user_email = '*****@*****.**'
self.signup(user_email, 'user')
user_id = self.get_user_id_from_email(user_email)
self.login(user_email)
config_services.set_property('admin',
'contributor_can_suggest_questions',
False)
response = self.get_json('/usercontributionrightsdatahandler')
self.assertEqual(
response, {
'can_review_translation_for_language_codes': [],
'can_review_voiceover_for_language_codes': [],
'can_review_questions': False,
'can_suggest_questions': False
})
user_services.allow_user_to_submit_question(user_id)
response = self.get_json('/usercontributionrightsdatahandler')
self.assertEqual(
response, {
'can_review_translation_for_language_codes': [],
'can_review_voiceover_for_language_codes': [],
'can_review_questions': False,
'can_suggest_questions': False
})
config_services.set_property('admin',
'contributor_can_suggest_questions', True)
response = self.get_json('/usercontributionrightsdatahandler')
self.assertEqual(
response, {
'can_review_translation_for_language_codes': [],
'can_review_voiceover_for_language_codes': [],
'can_review_questions': False,
'can_suggest_questions': True
})
def test_user_banning(self):
"""Test that banned users are banned."""
EXP_ID = '0'
exp_services.delete_demo(EXP_ID)
exp_services.load_demo(EXP_ID)
# Register new editors Joe and Sandra.
self.register_editor('*****@*****.**', username='******')
self.register_editor('*****@*****.**', username='******')
# Joe logs in.
self.login('*****@*****.**')
response = self.testapp.get('/contribute', expect_errors=True)
self.assertEqual(response.status_int, 200)
response = self.testapp.get('/create/%s' % EXP_ID)
self.assertEqual(response.status_int, 200)
self.assert_can_edit(response.body)
# Ban joe.
config_services.set_property(
feconf.ADMIN_COMMITTER_ID, 'banned_usernames', ['joe'])
# Test that Joe is banned.
response = self.testapp.get('/contribute', expect_errors=True)
self.assertEqual(response.status_int, 401)
response = self.testapp.get('/create/%s' % EXP_ID, expect_errors=True)
self.assertEqual(response.status_int, 200)
self.assert_cannot_edit(response.body)
# Joe logs out.
self.logout()
# Sandra logs in and is unaffected.
self.login('*****@*****.**')
response = self.testapp.get('/create/%s' % EXP_ID)
self.assertEqual(response.status_int, 200)
self.assert_can_edit(response.body)
self.logout()
def test_email_not_sent_if_config_does_not_permit_it(self):
with self.swap(feconf, 'CAN_SEND_EMAILS_TO_USERS', False):
config_services.set_property(self.ADMIN_ID,
email_manager.EMAIL_FOOTER.name,
self.NEW_FOOTER)
config_services.set_property(
self.ADMIN_ID, email_manager.SIGNUP_EMAIL_CONTENT.name,
self.NEW_EMAIL_CONTENT)
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.SIGNUP_URL)
csrf_token = self.get_csrf_token_from_response(response)
response_dict = self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
},
csrf_token=csrf_token)
# Check that no email was sent.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(0, len(messages))
def test_user_banning(self):
"""Test that banned users are banned."""
EXP_ID = '0'
exp_services.delete_demo(EXP_ID)
exp_services.load_demo(EXP_ID)
# Sign-up new editors Joe and Sandra.
self.signup('*****@*****.**', 'joe')
self.signup('*****@*****.**', 'sandra')
# Joe logs in.
self.login('*****@*****.**')
response = self.testapp.get(feconf.GALLERY_URL)
self.assertEqual(response.status_int, 200)
response = self.testapp.get('/create/%s' % EXP_ID)
self.assertEqual(response.status_int, 200)
self.assert_can_edit(response.body)
# Ban joe.
config_services.set_property(
feconf.SYSTEM_COMMITTER_ID, 'banned_usernames', ['joe'])
# Test that Joe is banned. (He can still access the gallery.)
response = self.testapp.get(feconf.GALLERY_URL, expect_errors=True)
self.assertEqual(response.status_int, 200)
response = self.testapp.get('/create/%s' % EXP_ID, expect_errors=True)
self.assertEqual(response.status_int, 200)
self.assert_cannot_edit(response.body)
# Joe logs out.
self.logout()
# Sandra logs in and is unaffected.
self.login('*****@*****.**')
response = self.testapp.get('/create/%s' % EXP_ID)
self.assertEqual(response.status_int, 200)
self.assert_can_edit(response.body)
self.logout()
def test_user_banning(self):
"""Test that banned users are banned."""
EXP_ID = "0"
exp_services.load_demo(EXP_ID)
rights_manager.release_ownership_of_exploration(feconf.SYSTEM_COMMITTER_ID, EXP_ID)
# Sign-up new editors Joe and Sandra.
self.signup("*****@*****.**", "joe")
self.signup("*****@*****.**", "sandra")
# Joe logs in.
self.login("*****@*****.**")
response = self.testapp.get(feconf.GALLERY_URL)
self.assertEqual(response.status_int, 200)
response = self.testapp.get("/create/%s" % EXP_ID)
self.assertEqual(response.status_int, 200)
self.assert_can_edit(response.body)
# Ban joe.
config_services.set_property(feconf.SYSTEM_COMMITTER_ID, "banned_usernames", ["joe"])
# Test that Joe is banned. (He can still access the gallery.)
response = self.testapp.get(feconf.GALLERY_URL, expect_errors=True)
self.assertEqual(response.status_int, 200)
response = self.testapp.get("/create/%s" % EXP_ID, expect_errors=True)
self.assertEqual(response.status_int, 200)
self.assert_cannot_edit(response.body)
# Joe logs out.
self.logout()
# Sandra logs in and is unaffected.
self.login("*****@*****.**")
response = self.testapp.get("/create/%s" % EXP_ID)
self.assertEqual(response.status_int, 200)
self.assert_can_edit(response.body)
self.logout()
def setUp(self):
super(EmailDashboardResultTests, self).setUp()
self.signup(self.USER_A_EMAIL, self.USER_A_USERNAME)
# User A has one created exploration.
# User B has one created exploration.
# Submitter and new_submitter are submitter of query.
self.user_a_id = self.get_user_id_from_email(self.USER_A_EMAIL)
self.signup(self.USER_B_EMAIL, self.USER_B_USERNAME)
self.user_b_id = self.get_user_id_from_email(self.USER_B_EMAIL)
self.save_new_valid_exploration(self.EXP_ID_1,
self.user_a_id,
end_state_name='End')
self.save_new_valid_exploration(self.EXP_ID_2,
self.user_b_id,
end_state_name='End')
self.signup(self.SUBMITTER_EMAIL, self.SUBMITTER_USERNAME)
self.submitter_id = self.get_user_id_from_email(self.SUBMITTER_EMAIL)
self.signup(self.NEW_SUBMITTER_EMAIL, self.NEW_SUBMITTER_USERNAME)
self.new_submitter_id = self.get_user_id_from_email(
self.NEW_SUBMITTER_EMAIL)
config_services.set_property(
self.submitter_id, 'whitelisted_email_senders',
[self.SUBMITTER_USERNAME, self.NEW_SUBMITTER_USERNAME])
def setUp(self):
super(ModeratorEmailsTest, self).setUp()
self.signup(self.EDITOR_EMAIL, self.EDITOR_USERNAME)
self.editor_id = self.get_user_id_from_email(self.EDITOR_EMAIL)
self.signup(self.MODERATOR_EMAIL, self.MODERATOR_USERNAME)
self.set_moderators([self.MODERATOR_EMAIL])
# The editor publishes an exploration.
self.save_new_valid_exploration(
self.EXP_ID, self.editor_id, title='My Exploration',
end_state_name='END')
rights_manager.publish_exploration(self.editor_id, self.EXP_ID)
# Set the default email config.
self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME)
self.admin_id = self.get_user_id_from_email(self.ADMIN_EMAIL)
config_services.set_property(
self.admin_id, 'publicize_exploration_email_html_body',
'Default publicization email body')
config_services.set_property(
self.admin_id, 'unpublish_exploration_email_html_body',
'Default unpublishing email body')
def test_record_of_sent_email_is_written_to_datastore(self):
with self.swap(feconf, 'CAN_SEND_EMAILS_TO_USERS', True):
config_services.set_property(
self.admin_id, email_manager.EMAIL_FOOTER.name,
self.new_footer)
config_services.set_property(
self.admin_id, email_manager.SIGNUP_EMAIL_CONTENT.name,
self.new_email_content)
config_services.set_property(
self.admin_id, email_manager.EMAIL_SENDER_NAME.name,
'Email Sender')
all_models = email_models.SentEmailModel.get_all().fetch()
self.assertEqual(len(all_models), 0)
self.login(self.EDITOR_EMAIL)
response = self.testapp.get(feconf.SIGNUP_URL)
csrf_token = self.get_csrf_token_from_response(response)
self.post_json(feconf.SIGNUP_DATA_URL, {
'agreed_to_terms': True,
'username': self.EDITOR_USERNAME
}, csrf_token=csrf_token)
# Check that a new email was sent.
messages = self.mail_stub.get_sent_messages(to=self.EDITOR_EMAIL)
self.assertEqual(1, len(messages))
# Check that the content of this email was recorded in
# SentEmailModel.
all_models = email_models.SentEmailModel.get_all().fetch()
self.assertEqual(len(all_models), 1)
# Check that the contents of the model are correct.
sent_email_model = all_models[0]
self.assertEqual(
sent_email_model.recipient_id,
self.get_user_id_from_email(self.EDITOR_EMAIL))
self.assertEqual(
sent_email_model.recipient_email, self.EDITOR_EMAIL)
self.assertEqual(
sent_email_model.sender_id, feconf.SYSTEM_COMMITTER_ID)
self.assertEqual(
sent_email_model.sender_email,
'Email Sender <%s>' % feconf.SYSTEM_EMAIL_ADDRESS)
self.assertEqual(
sent_email_model.intent, feconf.EMAIL_INTENT_SIGNUP)
self.assertEqual(
sent_email_model.subject, 'Welcome!')
self.assertEqual(
sent_email_model.html_body, self.expected_html_email_content)
def post(self):
"""Handles POST requests."""
try:
if self.payload.get('action') == 'reload_exploration':
exploration_id = self.payload.get('exploration_id')
logging.info(
'[ADMIN] %s reloaded exploration %s' %
(self.user_id, exploration_id))
exp_services.load_demo(unicode(exploration_id))
rights_manager.release_ownership_of_exploration(
feconf.SYSTEM_COMMITTER_ID, unicode(exploration_id))
elif self.payload.get('action') == 'reload_collection':
collection_id = self.payload.get('collection_id')
logging.info(
'[ADMIN] %s reloaded collection %s' %
(self.user_id, collection_id))
collection_services.load_demo(unicode(collection_id))
rights_manager.release_ownership_of_collection(
feconf.SYSTEM_COMMITTER_ID, unicode(collection_id))
elif self.payload.get('action') == 'clear_search_index':
exp_services.clear_search_index()
elif self.payload.get('action') == 'save_config_properties':
new_config_property_values = self.payload.get(
'new_config_property_values')
logging.info('[ADMIN] %s saved config property values: %s' %
(self.user_id, new_config_property_values))
for (name, value) in new_config_property_values.iteritems():
config_services.set_property(self.user_id, name, value)
elif self.payload.get('action') == 'revert_config_property':
config_property_id = self.payload.get('config_property_id')
logging.info('[ADMIN] %s reverted config property: %s' %
(self.user_id, config_property_id))
config_services.revert_property(
self.user_id, config_property_id)
elif self.payload.get('action') == 'start_new_job':
for klass in jobs_registry.ONE_OFF_JOB_MANAGERS:
if klass.__name__ == self.payload.get('job_type'):
klass.enqueue(klass.create_new())
break
elif self.payload.get('action') == 'cancel_job':
job_id = self.payload.get('job_id')
job_type = self.payload.get('job_type')
for klass in jobs_registry.ONE_OFF_JOB_MANAGERS:
if klass.__name__ == job_type:
klass.cancel(job_id, self.user_id)
break
elif self.payload.get('action') == 'start_computation':
computation_type = self.payload.get('computation_type')
for klass in jobs_registry.ALL_CONTINUOUS_COMPUTATION_MANAGERS:
if klass.__name__ == computation_type:
klass.start_computation()
break
elif self.payload.get('action') == 'stop_computation':
computation_type = self.payload.get('computation_type')
for klass in jobs_registry.ALL_CONTINUOUS_COMPUTATION_MANAGERS:
if klass.__name__ == computation_type:
klass.stop_computation(self.user_id)
break
elif self.payload.get('action') == 'upload_topic_similarities':
data = self.payload.get('data')
recommendations_services.update_topic_similarities(data)
self.render_json({})
except Exception as e:
self.render_json({'error': unicode(e)})
raise
def test_exploration_rights_handler(self):
"""Test exploration rights handler."""
# Create several users
self.register_editor(self.ADMIN_EMAIL, username='******')
self.register_editor(self.OWNER_EMAIL, username='******')
self.register_editor(self.COLLABORATOR_EMAIL, username='******')
self.register_editor(self.VIEWER_EMAIL, 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.collaborator_id = self.get_user_id_from_email(
self.COLLABORATOR_EMAIL)
self.viewer_id = self.get_user_id_from_email(self.VIEWER_EMAIL)
config_services.set_property(
feconf.ADMIN_COMMITTER_ID, 'admin_emails', ['*****@*****.**'])
# Owner creates exploration
self.login(self.OWNER_EMAIL)
EXP_ID = 'eid'
exploration = exp_domain.Exploration.create_default_exploration(
EXP_ID, 'Title for rights handler test!',
'My category')
exploration.add_states(['State A', 'State 2', 'State 3'])
exp_services.save_new_exploration(self.owner_id, exploration)
response = self.testapp.get(
'%s/%s' % (feconf.EDITOR_URL_PREFIX, EXP_ID))
csrf_token = self.get_csrf_token_from_response(response)
# Owner adds rights for other users
rights_url = '%s/%s' % (feconf.EXPLORATION_RIGHTS_PREFIX, EXP_ID)
response_dict = self.put_json(
rights_url, {
'version': exploration.version,
'new_member_email': self.VIEWER_EMAIL,
'new_member_role': rights_manager.ROLE_VIEWER
}, csrf_token)
response_dict = self.put_json(
rights_url, {
'version': exploration.version,
'new_member_email': self.COLLABORATOR_EMAIL,
'new_member_role': rights_manager.ROLE_EDITOR
}, csrf_token)
self.logout()
# Check that viewer can access editor page but cannot edit.
self.login(self.VIEWER_EMAIL)
response = self.testapp.get('/create/%s' % EXP_ID, expect_errors=True)
self.assertEqual(response.status_int, 200)
self.assert_cannot_edit(response.body)
self.logout()
# Check that collaborator can access editor page and can edit.
self.login(self.COLLABORATOR_EMAIL)
response = self.testapp.get('/create/%s' % EXP_ID)
self.assertEqual(response.status_int, 200)
self.assert_can_edit(response.body)
csrf_token = self.get_csrf_token_from_response(response)
# Check that collaborator can add a new state called 'State 4'
add_url = '%s/%s' % (feconf.EXPLORATION_DATA_PREFIX, EXP_ID)
response_dict = self.put_json(
add_url,
{
'version': exploration.version,
'commit_message': 'Added State 4',
'change_list': [{
'cmd': 'add_state',
'state_name': 'State 4'
}]
},
csrf_token=csrf_token,
expected_status_int=200
)
self.assertIn('State 4', response_dict['states'])
# Check that collaborator cannot add new members
exploration = exp_services.get_exploration_by_id(EXP_ID)
rights_url = '%s/%s' % (feconf.EXPLORATION_RIGHTS_PREFIX, EXP_ID)
response_dict = self.put_json(
rights_url, {
'version': exploration.version,
'new_member_email': self.VIEWER2_EMAIL,
'new_member_role': rights_manager.ROLE_VIEWER
}, csrf_token, expect_errors=True, expected_status_int=401)
self.assertEqual(response_dict['code'], 401)
response_dict = self.put_json(
rights_url, {
'version': exploration.version,
'new_member_email': self.COLLABORATOR2_EMAIL,
'new_member_role': rights_manager.ROLE_EDITOR,
}, csrf_token, expect_errors=True, expected_status_int=401)
self.assertEqual(response_dict['code'], 401)
self.logout()
