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_published_explorations_are_visible_to_logged_in_users(self): rights_manager.publish_exploration(self.editor_id, self.EXP_ID) self.signup(self.VIEWER_EMAIL, self.VIEWER_USERNAME) self.login(self.VIEWER_EMAIL) response = self.testapp.get("%s/%s" % (feconf.EXPLORATION_URL_PREFIX, self.EXP_ID), expect_errors=True) self.assertEqual(response.status_int, 200)
def test_deletion_rights_for_published_exploration(self): """Test rights management for deletion of published explorations.""" PUBLISHED_EXP_ID = "published_eid" exploration = exp_domain.Exploration.create_default_exploration(PUBLISHED_EXP_ID, "A title", "A category") exp_services.save_new_exploration(self.owner_id, exploration) rights_manager.assign_role(self.owner_id, PUBLISHED_EXP_ID, self.editor_id, rights_manager.ROLE_EDITOR) rights_manager.publish_exploration(self.owner_id, PUBLISHED_EXP_ID) self.login(self.EDITOR_EMAIL) response = self.testapp.delete("/createhandler/data/%s" % PUBLISHED_EXP_ID, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.VIEWER_EMAIL) response = self.testapp.delete("/createhandler/data/%s" % PUBLISHED_EXP_ID, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.OWNER_EMAIL) response = self.testapp.delete("/createhandler/data/%s" % PUBLISHED_EXP_ID, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.ADMIN_EMAIL) response = self.testapp.delete("/createhandler/data/%s" % PUBLISHED_EXP_ID) self.assertEqual(response.status_int, 200) self.logout()
def setUp(self): """Before each individual test, set up dummy explorations, users and admin.""" super(RecommendationsServicesUnitTests, self).setUp() for name, user in self.USER_DATA.iteritems(): user["id"] = self.get_user_id_from_email(user["email"]) user_services.get_or_create_user(user["id"], user["email"]) self.signup(user["email"], name) self.USER_DATA[name]["id"] = user["id"] self.EXP_DATA["exp_id_1"]["owner_id"] = self.USER_DATA["alice"]["id"] self.EXP_DATA["exp_id_2"]["owner_id"] = self.USER_DATA["alice"]["id"] self.EXP_DATA["exp_id_3"]["owner_id"] = self.USER_DATA["bob"]["id"] self.EXP_DATA["exp_id_4"]["owner_id"] = self.USER_DATA["charlie"]["id"] self.explorations = [] for exp_id, exp in self.EXP_DATA.iteritems(): self.save_new_valid_exploration(exp_id, exp["owner_id"], category=exp["category"]) rights_manager.publish_exploration(exp["owner_id"], exp_id) self.ADMIN_ID = self.get_user_id_from_email(self.ADMIN_EMAIL) user_services.get_or_create_user(self.ADMIN_ID, self.ADMIN_EMAIL) self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME) self.set_admins([self.ADMIN_EMAIL])
def test_managers_can_see_explorations(self): self.save_new_default_exploration( self.EXP_ID, self.owner_id, title=self.EXP_TITLE) self.set_admins([self.OWNER_EMAIL]) self.login(self.OWNER_EMAIL) response = self.get_json(self.MY_EXPLORATIONS_DATA_URL) self.assertEqual(len(response['explorations_list']), 1) self.assertEqual( response['explorations_list'][0]['status'], rights_manager.ACTIVITY_STATUS_PRIVATE) rights_manager.publish_exploration(self.owner_id, self.EXP_ID) response = self.get_json(self.MY_EXPLORATIONS_DATA_URL) self.assertEqual(len(response['explorations_list']), 1) self.assertEqual( response['explorations_list'][0]['status'], rights_manager.ACTIVITY_STATUS_PUBLIC) rights_manager.publicize_exploration(self.owner_id, self.EXP_ID) response = self.get_json(self.MY_EXPLORATIONS_DATA_URL) self.assertEqual(len(response['explorations_list']), 1) self.assertEqual( response['explorations_list'][0]['status'], rights_manager.ACTIVITY_STATUS_PUBLICIZED) self.logout()
def setUp(self): """Before each individual test, set up dummy explorations, users and admin.""" super(RecommendationsServicesUnitTests, self).setUp() for name, user in self.USER_DATA.iteritems(): user['id'] = self.get_user_id_from_email( user['email']) user_services.get_or_create_user(user['id'], user['email']) self.signup(user['email'], name) self.USER_DATA[name]['id'] = user['id'] self.EXP_DATA['exp_id_1']['owner_id'] = self.USER_DATA['alice']['id'] self.EXP_DATA['exp_id_2']['owner_id'] = self.USER_DATA['alice']['id'] self.EXP_DATA['exp_id_3']['owner_id'] = self.USER_DATA['bob']['id'] self.EXP_DATA['exp_id_4']['owner_id'] = self.USER_DATA['charlie']['id'] for exp_id, exp in self.EXP_DATA.iteritems(): self.save_new_valid_exploration( exp_id, exp['owner_id'], category=exp['category']) rights_manager.publish_exploration(exp['owner_id'], exp_id) self.admin_id = self.get_user_id_from_email(self.ADMIN_EMAIL) user_services.get_or_create_user( self.admin_id, self.ADMIN_EMAIL) self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME) self.set_admins([self.ADMIN_USERNAME])
def test_deletion_rights_for_published_exploration(self): """Test rights management for deletion of published explorations.""" published_exp_id = 'published_eid' exploration = exp_domain.Exploration.create_default_exploration( published_exp_id, 'A title', 'A category') exp_services.save_new_exploration(self.owner_id, exploration) rights_manager.assign_role_for_exploration( self.owner_id, published_exp_id, self.editor_id, rights_manager.ROLE_EDITOR) rights_manager.publish_exploration(self.owner_id, published_exp_id) self.login(self.EDITOR_EMAIL) response = self.testapp.delete( '/createhandler/data/%s' % published_exp_id, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.VIEWER_EMAIL) response = self.testapp.delete( '/createhandler/data/%s' % published_exp_id, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.OWNER_EMAIL) response = self.testapp.delete( '/createhandler/data/%s' % published_exp_id, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.ADMIN_EMAIL) response = self.testapp.delete( '/createhandler/data/%s' % published_exp_id) self.assertEqual(response.status_int, 200) self.logout()
def test_no_username_shown_for_logged_out_learners(self): NEW_EXP_ID = 'new_eid' exploration = exp_domain.Exploration.create_default_exploration( NEW_EXP_ID, 'A title', 'A category') exp_services.save_new_exploration(self.EDITOR_ID, exploration) rights_manager.publish_exploration(self.EDITOR_ID, NEW_EXP_ID) response = self.testapp.get('/create/%s' % NEW_EXP_ID) csrf_token = self.get_csrf_token_from_response(response) self.post_json( '/explorehandler/give_feedback/%s' % NEW_EXP_ID, { 'state_name': None, 'subject': 'Test thread', 'feedback': 'Test thread text', 'include_author': False, }, csrf_token) response_dict = self.get_json( '%s/%s' % (feconf.FEEDBACK_THREADLIST_URL_PREFIX, NEW_EXP_ID)) threadlist = response_dict['threads'] self.assertIsNone(threadlist[0]['original_author_username']) response_dict = self.get_json('%s/%s/%s' % ( feconf.FEEDBACK_THREAD_URL_PREFIX, NEW_EXP_ID, threadlist[0]['thread_id'])) self.assertIsNone(response_dict['messages'][0]['author_username'])
def test_collaborators_can_see_explorations(self): self.save_new_default_exploration( self.EXP_ID, self.owner_id, title=self.EXP_TITLE) rights_manager.assign_role_for_exploration( self.owner_id, self.EXP_ID, self.collaborator_id, rights_manager.ROLE_EDITOR) self.set_admins([self.OWNER_USERNAME]) self.login(self.COLLABORATOR_EMAIL) response = self.get_json(feconf.DASHBOARD_DATA_URL) self.assertEqual(len(response['explorations_list']), 1) self.assertEqual( response['explorations_list'][0]['status'], rights_manager.ACTIVITY_STATUS_PRIVATE) rights_manager.publish_exploration(self.owner_id, self.EXP_ID) response = self.get_json(feconf.DASHBOARD_DATA_URL) self.assertEqual(len(response['explorations_list']), 1) self.assertEqual( response['explorations_list'][0]['status'], rights_manager.ACTIVITY_STATUS_PUBLIC) rights_manager.publicize_exploration(self.owner_id, self.EXP_ID) response = self.get_json(feconf.DASHBOARD_DATA_URL) self.assertEqual(len(response['explorations_list']), 1) self.assertEqual( response['explorations_list'][0]['status'], rights_manager.ACTIVITY_STATUS_PUBLICIZED) self.logout()
def test_community_owned_exploration(self): with self.swap( subscription_services, 'subscribe_to_thread', self._null_fn ), self.swap( subscription_services, 'subscribe_to_exploration', self._null_fn): # User A adds user B as an editor to the exploration. rights_manager.assign_role_for_exploration( self.user_a_id, self.EXP_ID_1, self.user_b_id, rights_manager.ROLE_EDITOR) # The exploration becomes community-owned. rights_manager.publish_exploration(self.user_a_id, self.EXP_ID_1) rights_manager.release_ownership_of_exploration( self.user_a_id, self.EXP_ID_1) # User C edits the exploration. exp_services.update_exploration( self.user_c_id, self.EXP_ID_1, [], 'Update exploration') self._run_one_off_job() # User A and user B are subscribed to the exploration; user C is not. user_a_subscriptions_model = user_models.UserSubscriptionsModel.get( self.user_a_id) user_b_subscriptions_model = user_models.UserSubscriptionsModel.get( self.user_b_id) user_c_subscriptions_model = user_models.UserSubscriptionsModel.get( self.user_c_id, strict=False) self.assertEqual( user_a_subscriptions_model.activity_ids, [self.EXP_ID_1]) self.assertEqual( user_b_subscriptions_model.activity_ids, [self.EXP_ID_1]) self.assertEqual(user_c_subscriptions_model, None)
def setUp(self): super(FlagExplorationHandlerTests, self).setUp() # Register users. self.signup(self.EDITOR_EMAIL, self.EDITOR_USERNAME) self.signup(self.NEW_USER_EMAIL, self.NEW_USER_USERNAME) self.signup(self.MODERATOR_EMAIL, self.MODERATOR_USERNAME) self.editor_id = self.get_user_id_from_email(self.EDITOR_EMAIL) self.new_user_id = self.get_user_id_from_email(self.NEW_USER_EMAIL) self.moderator_id = self.get_user_id_from_email(self.MODERATOR_EMAIL) self.set_moderators([self.MODERATOR_USERNAME]) # Load exploration 0. exp_services.load_demo(self.EXP_ID) # Login and create exploration. self.login(self.EDITOR_EMAIL) # Create exploration. self.save_new_valid_exploration( self.EXP_ID, self.editor_id, title="Welcome to Oppia!", category="This is just a spam category", objective="Test a spam exploration.", ) self.can_send_emails_ctx = self.swap(feconf, "CAN_SEND_EMAILS", True) rights_manager.publish_exploration(self.editor_id, self.EXP_ID) self.logout()
def test_published_explorations_are_visible_to_logged_out_users(self): rights_manager.publish_exploration(self.editor_id, self.EXP_ID) response = self.testapp.get( '%s/%s' % (feconf.EXPLORATION_URL_PREFIX, self.EXP_ID), expect_errors=True) self.assertEqual(response.status_int, 200)
def test_deleted_activity_is_removed_from_featured_list(self): rights_manager.publish_exploration(self.owner_id, self.EXP_ID_0) rights_manager.publish_exploration(self.owner_id, self.EXP_ID_1) rights_manager.publish_collection(self.owner_id, self.COL_ID_2) activity_services.update_featured_activity_references([ self._create_exploration_reference(self.EXP_ID_0), self._create_collection_reference(self.COL_ID_2)]) self._compare_lists( activity_services.get_featured_activity_references(), [ self._create_exploration_reference(self.EXP_ID_0), self._create_collection_reference(self.COL_ID_2)]) # Deleting an unfeatured activity does not affect the featured list. exp_services.delete_exploration(self.owner_id, self.EXP_ID_1) self._compare_lists( activity_services.get_featured_activity_references(), [ self._create_exploration_reference(self.EXP_ID_0), self._create_collection_reference(self.COL_ID_2)]) # Deleting a featured activity removes it from the featured list. collection_services.delete_collection(self.owner_id, self.COL_ID_2) self._compare_lists( activity_services.get_featured_activity_references(), [ self._create_exploration_reference(self.EXP_ID_0)]) exp_services.delete_exploration(self.owner_id, self.EXP_ID_0) self._compare_lists( activity_services.get_featured_activity_references(), [])
def test_edited(self): # Check that the profile page for a user who has created # a single exploration shows 0 created and 1 edited exploration. self.signup(self.EMAIL_A, self.USERNAME_A) user_a_id = self.get_user_id_from_email(self.EMAIL_A) self.signup(self.EMAIL_B, self.USERNAME_B) user_b_id = self.get_user_id_from_email(self.EMAIL_B) self.save_new_valid_exploration( self.EXP_ID_1, user_a_id, end_state_name='End') rights_manager.publish_exploration(user_a_id, self.EXP_ID_1) exp_services.update_exploration(user_b_id, self.EXP_ID_1, [{ 'cmd': 'edit_exploration_property', 'property_name': 'objective', 'new_value': 'the objective' }], 'Test edit') response_dict = self.get_json( '/profilehandler/data/%s' % self.USERNAME_B) self.assertEqual(len( response_dict['created_exp_summary_dicts']), 0) self.assertEqual(len( response_dict['edited_exp_summary_dicts']), 1) self.assertEqual( response_dict['edited_exp_summary_dicts'][0]['id'], self.EXP_ID_1) self.assertEqual( response_dict['edited_exp_summary_dicts'][0]['objective'], 'the objective')
def test_publish_or_publicize_activity_does_not_affect_featured_list(self): self._compare_lists( activity_services.get_featured_activity_references(), []) rights_manager.publish_exploration(self.owner_id, self.EXP_ID_0) self._compare_lists( activity_services.get_featured_activity_references(), []) rights_manager.publicize_exploration(self.moderator_id, self.EXP_ID_0) self._compare_lists( activity_services.get_featured_activity_references(), []) rights_manager.unpublicize_exploration( self.moderator_id, self.EXP_ID_0) self._compare_lists( activity_services.get_featured_activity_references(), []) rights_manager.publish_collection(self.owner_id, self.COL_ID_2) self._compare_lists( activity_services.get_featured_activity_references(), []) rights_manager.publicize_collection(self.moderator_id, self.COL_ID_2) self._compare_lists( activity_services.get_featured_activity_references(), []) rights_manager.unpublicize_collection( self.moderator_id, self.COL_ID_2) self._compare_lists( activity_services.get_featured_activity_references(), [])
def test_no_username_shown_for_nonregistered_users(self): NEW_EXP_ID = 'new_eid' exploration = exp_domain.Exploration.create_default_exploration( NEW_EXP_ID, 'A title', 'A category') exp_services.save_new_exploration(self.EDITOR_ID, exploration) rights_manager.publish_exploration(self.EDITOR_ID, NEW_EXP_ID) self.login('*****@*****.**') response = self.testapp.get('/create/%s' % NEW_EXP_ID) csrf_token = self.get_csrf_token_from_response(response) self.post_json( '%s/%s' % (feconf.FEEDBACK_THREADLIST_URL_PREFIX, NEW_EXP_ID), { 'state_name': None, 'subject': 'Test thread', 'text': 'Test thread text', }, csrf_token) response_dict = self.get_json( '%s/%s' % (feconf.FEEDBACK_THREADLIST_URL_PREFIX, NEW_EXP_ID)) threadlist = response_dict['threads'] self.assertIsNone(threadlist[0]['original_author_username']) response_dict = self.get_json('%s/%s/%s' % ( feconf.FEEDBACK_THREAD_URL_PREFIX, NEW_EXP_ID, threadlist[0]['thread_id'])) self.assertIsNone(response_dict['messages'][0]['author_username']) self.logout()
def load_demo(exploration_id): """Loads a demo exploration. The resulting exploration will have version 2 (one for its initial creation and one for its subsequent modification.) """ # TODO(sll): Speed this method up. It is too slow. delete_demo(exploration_id) if not (0 <= int(exploration_id) < len(feconf.DEMO_EXPLORATIONS)): raise Exception('Invalid demo exploration id %s' % exploration_id) exploration_info = feconf.DEMO_EXPLORATIONS[int(exploration_id)] if len(exploration_info) == 3: (exp_filename, title, category) = exploration_info else: raise Exception('Invalid demo exploration: %s' % exploration_info) yaml_content, assets_list = get_demo_exploration_components(exp_filename) save_new_exploration_from_yaml_and_assets( feconf.ADMIN_COMMITTER_ID, yaml_content, title, category, exploration_id, assets_list) rights_manager.publish_exploration( feconf.ADMIN_COMMITTER_ID, exploration_id) # Release ownership of all explorations. rights_manager.release_ownership( feconf.ADMIN_COMMITTER_ID, exploration_id) logging.info('Exploration with id %s was loaded.' % exploration_id)
def setUp(self): """Populate the database of explorations and their summaries. The sequence of events is: - (1) Albert creates EXP_ID_1. - (2) Albert creates EXP_ID_2. - (3) Albert publishes EXP_ID_1. - (4) Albert publishes EXP_ID_2. - (5) Admin user is set up. """ super(FeaturedExplorationDisplayableSummariesTest, self).setUp() self.admin_id = self.get_user_id_from_email(self.ADMIN_EMAIL) self.albert_id = self.get_user_id_from_email(self.ALBERT_EMAIL) self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME) self.signup(self.ALBERT_EMAIL, self.ALBERT_NAME) self.save_new_valid_exploration( self.EXP_ID_1, self.albert_id, language_code=self.LANGUAGE_CODE_ES) self.save_new_valid_exploration(self.EXP_ID_2, self.albert_id) rights_manager.publish_exploration(self.albert_id, self.EXP_ID_1) rights_manager.publish_exploration(self.albert_id, self.EXP_ID_2) self.set_admins([self.ADMIN_USERNAME])
def test_deletion_rights_for_published_exploration(self): """Test rights management for deletion of published explorations.""" PUBLISHED_EXP_ID = 'published_eid' exploration = exp_domain.Exploration.create_default_exploration( PUBLISHED_EXP_ID, 'A title', 'A category') exp_services.save_new_exploration(self.owner_id, exploration) rights_manager.assign_role( self.owner_id, PUBLISHED_EXP_ID, self.editor_id, rights_manager.ROLE_EDITOR) rights_manager.publish_exploration(self.owner_id, PUBLISHED_EXP_ID) self.login(self.editor_email) response = self.testapp.delete( '/createhandler/data/%s' % PUBLISHED_EXP_ID, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.viewer_email) response = self.testapp.delete( '/createhandler/data/%s' % PUBLISHED_EXP_ID, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.owner_email) response = self.testapp.delete( '/createhandler/data/%s' % PUBLISHED_EXP_ID, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.admin_email) response = self.testapp.delete( '/createhandler/data/%s' % PUBLISHED_EXP_ID) self.assertEqual(response.status_int, 200) self.logout()
def test_collaborators_can_see_explorations_on_dashboard(self): self.save_new_default_exploration( self.EXP_ID, self.OWNER_ID, title=self.EXP_TITLE) rights_manager.assign_role( self.OWNER_ID, self.EXP_ID, self.COLLABORATOR_ID, rights_manager.ROLE_EDITOR) self.set_admins([self.OWNER_EMAIL]) self.login(self.COLLABORATOR_EMAIL) response = self.get_json('/dashboardhandler/data') self.assertEqual(len(response['explorations']), 1) self.assertIn(self.EXP_ID, response['explorations']) self.assertEqual( response['explorations'][self.EXP_ID]['rights']['status'], rights_manager.EXPLORATION_STATUS_PRIVATE) rights_manager.publish_exploration(self.OWNER_ID, self.EXP_ID) response = self.get_json('/dashboardhandler/data') self.assertEqual(len(response['explorations']), 1) self.assertIn(self.EXP_ID, response['explorations']) self.assertEqual( response['explorations'][self.EXP_ID]['rights']['status'], rights_manager.EXPLORATION_STATUS_PUBLIC) rights_manager.publicize_exploration(self.OWNER_ID, self.EXP_ID) response = self.get_json('/dashboardhandler/data') self.assertEqual(len(response['explorations']), 1) self.assertIn(self.EXP_ID, response['explorations']) self.assertEqual( response['explorations'][self.EXP_ID]['rights']['status'], rights_manager.EXPLORATION_STATUS_PUBLICIZED) self.logout()
def test_changing_viewability_of_exploration(self): exp = exp_domain.Exploration.create_default_exploration( self.EXP_ID, title='A title', category='A category') exp_services.save_new_exploration(self.user_id_a, exp) self.assertFalse( rights_manager.Actor(self.user_id_b).can_view( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertTrue(rights_manager.Actor( self.user_id_a).can_change_private_viewability( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertFalse(rights_manager.Actor( self.user_id_b).can_change_private_viewability( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertTrue(rights_manager.Actor( self.user_id_admin).can_change_private_viewability( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) with self.assertRaisesRegexp(Exception, 'already the current value'): rights_manager.set_private_viewability_of_exploration( self.user_id_a, self.EXP_ID, False) with self.assertRaisesRegexp(Exception, 'cannot be changed'): rights_manager.set_private_viewability_of_exploration( self.user_id_b, self.EXP_ID, True) rights_manager.set_private_viewability_of_exploration( self.user_id_a, self.EXP_ID, True) self.assertTrue( rights_manager.Actor(self.user_id_a).can_view( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertTrue( rights_manager.Actor(self.user_id_b).can_view( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) rights_manager.set_private_viewability_of_exploration( self.user_id_a, self.EXP_ID, False) self.assertTrue( rights_manager.Actor(self.user_id_a).can_view( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertFalse( rights_manager.Actor(self.user_id_b).can_view( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) rights_manager.publish_exploration(self.user_id_a, self.EXP_ID) self.assertFalse(rights_manager.Actor( self.user_id_a).can_change_private_viewability( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) rights_manager.unpublish_exploration(self.user_id_admin, self.EXP_ID) self.assertTrue(rights_manager.Actor( self.user_id_a).can_change_private_viewability( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertFalse(rights_manager.Actor( self.user_id_b).can_change_private_viewability( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertTrue(rights_manager.Actor( self.user_id_admin).can_change_private_viewability( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID))
def test_cannot_delete_published_exploration(self): exp = exp_domain.Exploration.create_default_exploration( self.EXP_ID, 'A title', 'A category') exp_services.save_new_exploration(self.user_id_a, exp) rights_manager.publish_exploration(self.user_id_a, self.EXP_ID) self.assertFalse( rights_manager.Actor(self.user_id_a).can_delete(self.EXP_ID))
def reduce(exp_id, list_of_exps): for stringified_exp in list_of_exps: exploration = exp_domain.Exploration.from_untitled_yaml( exp_id, 'Copy', 'Copies', stringified_exp) exp_services.save_new_exploration( feconf.SYSTEM_COMMITTER_ID, exploration) rights_manager.publish_exploration( feconf.SYSTEM_COMMITTER_ID, exp_id)
def test_published_explorations_are_visible_to_anyone(self): rights_manager.publish_exploration(self.first_editor_id, self.EXP_ID) response = self.testapp.get( '%s/%s' % (feconf.EXPLORATION_URL_PREFIX, self.EXP_ID), expect_errors=True) self.assertEqual(response.status_int, 200) self.assertNotIn('This is a preview', response.body)
def reduce(exp_id, list_of_exps): from core.domain import exp_services from core.domain import rights_manager for stringified_exp in list_of_exps: exploration = exp_domain.Exploration.from_yaml(exp_id, "Copy", "Copies", stringified_exp) exp_services.save_new_exploration(feconf.SYSTEM_COMMITTER_ID, exploration) rights_manager.publish_exploration(feconf.SYSTEM_COMMITTER_ID, exp_id)
def setUp(self): super(FeaturedActivitiesHandlerTest, self).setUp() self.signup(self.MODERATOR_EMAIL, self.MODERATOR_USERNAME) self.set_moderators([self.MODERATOR_USERNAME]) self.save_new_valid_exploration(self.EXP_ID_1, self.ALBERT_ID) rights_manager.publish_exploration(self.ALBERT_ID, self.EXP_ID_1) self.save_new_valid_exploration(self.EXP_ID_2, self.ALBERT_ID)
def test_demand_commit_message(self): """Check published explorations demand commit messages""" rights_manager.publish_exploration(self.OWNER_ID, self.EXP_ID) with self.assertRaisesRegexp( ValueError, 'Exploration is public so expected a commit ' 'message but received none.'): exp_services.update_exploration( self.OWNER_ID, self.EXP_ID, _get_change_list( self.init_state_name, 'widget_sticky', False), '')
def test_updating_with_duplicate_refs_raises_exception(self): rights_manager.publish_exploration(self.owner_id, self.EXP_ID_0) rights_manager.publish_collection(self.owner_id, self.COL_ID_2) self._compare_lists( activity_services.get_featured_activity_references(), []) with self.assertRaisesRegexp(Exception, 'should not have duplicates'): activity_services.update_featured_activity_references([ self._create_exploration_reference(self.EXP_ID_0), self._create_exploration_reference(self.EXP_ID_0)])
def test_update_featured_refs_clears_existing_featured_activities(self): rights_manager.publish_exploration(self.owner_id, self.EXP_ID_0) activity_services.update_featured_activity_references([ self._create_exploration_reference(self.EXP_ID_0)]) self._compare_lists( activity_services.get_featured_activity_references(), [ self._create_exploration_reference(self.EXP_ID_0)]) activity_services.update_featured_activity_references([]) self._compare_lists( activity_services.get_featured_activity_references(), [])
def test_record_commit_message(self): """Check published explorations record commit messages.""" rights_manager.publish_exploration(self.OWNER_ID, self.EXP_ID) exp_services.update_exploration( self.OWNER_ID, self.EXP_ID, _get_change_list( self.init_state_name, 'widget_sticky', False), 'A message') self.assertEqual( exp_services.get_exploration_snapshots_metadata( self.EXP_ID, 1)[0]['commit_message'], 'A message')
def test_first_published_time_of_exploration_that_is_unpublished(self): """This tests that, if an exploration is published, unpublished, and then published again, the job uses the first publication time as the value for first_published_msec. """ self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME) admin_id = self.get_user_id_from_email(self.ADMIN_EMAIL) self.set_admins([self.ADMIN_USERNAME]) self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME) owner_id = self.get_user_id_from_email(self.OWNER_EMAIL) owner = user_services.UserActionsInfo(owner_id) admin = user_services.UserActionsInfo(admin_id) self.save_new_valid_exploration( self.EXP_ID, owner_id, end_state_name='End') rights_manager.publish_exploration(owner, self.EXP_ID) job_class = exp_jobs_one_off.ExplorationFirstPublishedOneOffJob job_id = job_class.create_new() exp_jobs_one_off.ExplorationFirstPublishedOneOffJob.enqueue(job_id) self.process_and_flush_pending_tasks() exploration_rights = rights_manager.get_exploration_rights(self.EXP_ID) # Test to see whether first_published_msec was correctly updated. exp_first_published = exploration_rights.first_published_msec exp_rights_model = exp_models.ExplorationRightsModel.get(self.EXP_ID) last_updated_time_msec = utils.get_time_in_millisecs( exp_rights_model.last_updated) self.assertLess( exp_first_published, last_updated_time_msec) rights_manager.unpublish_exploration(admin, self.EXP_ID) rights_manager.publish_exploration(owner, self.EXP_ID) job_id = job_class.create_new() exp_jobs_one_off.ExplorationFirstPublishedOneOffJob.enqueue(job_id) self.process_and_flush_pending_tasks() # Test to see whether first_published_msec remains the same despite the # republication. exploration_rights = rights_manager.get_exploration_rights(self.EXP_ID) self.assertEqual( exp_first_published, exploration_rights.first_published_msec)
def setUp(self) -> None: super(ActivityRightsTests, self).setUp() self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME) self.owner_id = self.get_user_id_from_email( self.OWNER_EMAIL) # type: ignore[no-untyped-call] self.owner = user_services.get_user_actions_info( self.owner_id) # type: ignore[no-untyped-call] self.signup(self.VIEWER_EMAIL, self.VIEWER_USERNAME) self.viewer_id = self.get_user_id_from_email( self.VIEWER_EMAIL) # type: ignore[no-untyped-call] self.viewer = user_services.get_user_actions_info( self.viewer_id) # type: ignore[no-untyped-call] self.exp_id = 'exp_id' self.save_new_valid_exploration( self.exp_id, self.owner_id) # type: ignore[no-untyped-call] rights_manager.publish_exploration( self.owner, self.exp_id) # type: ignore[no-untyped-call] self.activity_rights = rights_manager.get_exploration_rights( # type: ignore[no-untyped-call] self.exp_id)
def test_can_only_delete_unpublished_explorations(self): exp = exp_domain.Exploration.create_default_exploration( self.EXP_ID, 'A title', 'A category') exp_services.save_new_exploration(self.user_id_a, exp) self.assertTrue( rights_manager.Actor(self.user_id_a).can_delete( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) rights_manager.publish_exploration(self.user_id_a, self.EXP_ID) self.assertFalse( rights_manager.Actor(self.user_id_a).can_delete( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) rights_manager.unpublish_exploration(self.user_id_admin, self.EXP_ID) self.assertTrue( rights_manager.Actor(self.user_id_a).can_delete( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID))
def setUp(self): super(EditExplorationTest, self).setUp() self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME) self.signup(self.MODERATOR_EMAIL, self.MODERATOR_USERNAME) self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME) self.signup(self.user_email, self.username) self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL) self.set_moderators([self.MODERATOR_USERNAME]) self.set_admins([self.ADMIN_USERNAME]) self.set_banned_users([self.username]) self.owner = user_services.UserActionsInfo(self.owner_id) self.testapp = webtest.TestApp(webapp2.WSGIApplication( [webapp2.Route('/mock/<exploration_id>', self.MockHandler)], debug=feconf.DEBUG, )) self.save_new_valid_exploration( self.published_exp_id, self.owner_id) self.save_new_valid_exploration( self.private_exp_id, self.owner_id) rights_manager.publish_exploration(self.owner, self.published_exp_id)
def test_created(self): # Check that the profile page for a user who has created # a single exploration shows 1 created and 1 edited exploration. self.signup(self.EMAIL_A, self.USERNAME_A) user_a_id = self.get_user_id_from_email(self.EMAIL_A) user_a = user_services.UserActionsInfo(user_a_id) self.save_new_valid_exploration(self.EXP_ID_1, user_a_id, end_state_name='End') rights_manager.publish_exploration(user_a, self.EXP_ID_1) response_dict = self.get_json('/profilehandler/data/%s' % self.USERNAME_A) self.assertEqual(len(response_dict['created_exp_summary_dicts']), 1) self.assertEqual(len(response_dict['edited_exp_summary_dicts']), 1) self.assertEqual(response_dict['created_exp_summary_dicts'][0]['id'], self.EXP_ID_1) self.assertEqual(response_dict['edited_exp_summary_dicts'][0]['id'], self.EXP_ID_1)
def test_viewer_cannot_see_explorations_on_dashboard(self): self.save_new_default_exploration(self.EXP_ID, self.OWNER_ID, title=self.EXP_TITLE) rights_manager.assign_role(self.OWNER_ID, self.EXP_ID, self.VIEWER_ID, rights_manager.ROLE_VIEWER) self.login(self.VIEWER_EMAIL) response = self.get_json('/dashboardhandler/data') self.assertEqual(response['explorations'], {}) rights_manager.publish_exploration(self.OWNER_ID, self.EXP_ID) response = self.get_json('/dashboardhandler/data') self.assertEqual(response['explorations'], {}) self.set_admins([self.OWNER_EMAIL]) rights_manager.publicize_exploration(self.OWNER_ID, self.EXP_ID) response = self.get_json('/dashboardhandler/data') self.assertEqual(response['explorations'], {}) self.logout()
def test_can_only_delete_unpublished_explorations(self): exp = exp_domain.Exploration.create_default_exploration( self.EXP_ID, title='A title', category='A category') exp_services.save_new_exploration(self.user_id_a, exp) exp_rights = rights_manager.get_exploration_rights(self.EXP_ID) self.assertTrue(rights_manager.check_can_delete_activity( self.user_a, exp_rights)) rights_manager.publish_exploration(self.user_a, self.EXP_ID) exp_rights = rights_manager.get_exploration_rights(self.EXP_ID) self.assertFalse(rights_manager.check_can_delete_activity( self.user_a, exp_rights)) rights_manager.unpublish_exploration(self.user_admin, self.EXP_ID) exp_rights = rights_manager.get_exploration_rights(self.EXP_ID) self.assertTrue(rights_manager.check_can_delete_activity( self.user_a, exp_rights))
def setUp(self): """Before each individual test, set up dummy explorations and users.""" super(RecommendationsServicesUnitTests, self).setUp() for name, user in self.USER_DATA.items(): self.signup(user['email'], name) user['id'] = self.get_user_id_from_email(user['email']) self.USER_DATA[name]['id'] = user['id'] self.EXP_DATA['exp_id_1']['owner_id'] = self.USER_DATA['alice']['id'] self.EXP_DATA['exp_id_2']['owner_id'] = self.USER_DATA['alice']['id'] self.EXP_DATA['exp_id_3']['owner_id'] = self.USER_DATA['bob']['id'] self.EXP_DATA['exp_id_4']['owner_id'] = self.USER_DATA['charlie']['id'] for exp_id, exp in self.EXP_DATA.items(): self.save_new_valid_exploration(exp_id, exp['owner_id'], category=exp['category']) owner = user_services.get_user_actions_info(exp['owner_id']) rights_manager.publish_exploration(owner, exp_id)
def test_viewer_cannot_see_explorations(self): self.save_new_default_exploration( self.EXP_ID, self.owner_id, title=self.EXP_TITLE) rights_manager.assign_role_for_exploration( self.owner_id, self.EXP_ID, self.viewer_id, rights_manager.ROLE_VIEWER) self.set_admins([self.OWNER_USERNAME]) self.login(self.VIEWER_EMAIL) response = self.get_json(feconf.DASHBOARD_DATA_URL) self.assertEqual(response['explorations_list'], []) rights_manager.publish_exploration(self.owner_id, self.EXP_ID) response = self.get_json(feconf.DASHBOARD_DATA_URL) self.assertEqual(response['explorations_list'], []) rights_manager.publicize_exploration(self.owner_id, self.EXP_ID) response = self.get_json(feconf.DASHBOARD_DATA_URL) self.assertEqual(response['explorations_list'], []) self.logout()
def test_managers_can_see_explorations(self): self.save_new_default_exploration( self.EXP_ID, self.owner_id, title=self.EXP_TITLE) self.set_admins([self.OWNER_USERNAME]) self.login(self.OWNER_EMAIL) response = self.get_json(feconf.CREATOR_DASHBOARD_DATA_URL) self.assertEqual(len(response['explorations_list']), 1) self.assertEqual( response['explorations_list'][0]['status'], rights_domain.ACTIVITY_STATUS_PRIVATE) rights_manager.publish_exploration(self.owner, self.EXP_ID) response = self.get_json(feconf.CREATOR_DASHBOARD_DATA_URL) self.assertEqual(len(response['explorations_list']), 1) self.assertEqual( response['explorations_list'][0]['status'], rights_domain.ACTIVITY_STATUS_PUBLIC) self.logout()
def test_deleted_activity_is_removed_from_featured_list_multiple( self) -> None: rights_manager.publish_exploration( self.owner, self.EXP_ID_0) # type: ignore[no-untyped-call] rights_manager.publish_exploration( self.owner, self.EXP_ID_1) # type: ignore[no-untyped-call] exploration_references = [ self._create_exploration_reference(self.EXP_ID_0), self._create_exploration_reference(self.EXP_ID_1) ] activity_services.update_featured_activity_references( exploration_references) self._compare_lists( activity_services.get_featured_activity_references(), exploration_references) exp_services.delete_explorations( # type: ignore[no-untyped-call] self.owner_id, [self.EXP_ID_0, self.EXP_ID_1]) self._compare_lists( activity_services.get_featured_activity_references(), [])
def setUp(self): super(FeedbackThreadTests, self).setUp() self.signup(self.OWNER_EMAIL_1, self.OWNER_USERNAME_1) self.signup(self.OWNER_EMAIL_2, self.OWNER_USERNAME_2) self.signup(self.USER_EMAIL, self.USER_USERNAME) self.owner_id_1 = self.get_user_id_from_email(self.OWNER_EMAIL_1) self.owner_id_2 = self.get_user_id_from_email(self.OWNER_EMAIL_2) self.user_id = self.get_user_id_from_email(self.USER_EMAIL) self.owner_2 = user_services.UserActionsInfo(self.owner_id_2) # Create an exploration. self.save_new_valid_exploration(self.EXP_ID, self.owner_id_1, title=self.EXP_TITLE, category='Architecture', language_code='en') rights_manager.create_new_exploration_rights(self.EXP_ID, self.owner_id_2) rights_manager.publish_exploration(self.owner_2, self.EXP_ID)
def setUp(self): """Completes the sign-up process for self.VOICE_ARTIST_EMAIL.""" super(VoiceArtistManagementTests, self).setUp() self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME) self.signup(self.VOICE_ARTIST_EMAIL, self.VOICE_ARTIST_USERNAME) self.signup(self.VOICEOVER_ADMIN_EMAIL, self.VOICEOVER_ADMIN_USERNAME) self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL) self.voice_artist_id = self.get_user_id_from_email( self.VOICE_ARTIST_EMAIL) self.voiceover_admin_id = self.get_user_id_from_email( self.VOICEOVER_ADMIN_EMAIL) self.owner = user_services.get_user_actions_info(self.owner_id) self.save_new_valid_exploration(self.published_exp_id_1, self.owner_id) self.save_new_valid_exploration(self.published_exp_id_2, self.owner_id) self.save_new_valid_exploration(self.private_exp_id_1, self.owner_id) self.save_new_valid_exploration(self.private_exp_id_2, self.owner_id) rights_manager.publish_exploration(self.owner, self.published_exp_id_1) rights_manager.publish_exploration(self.owner, self.published_exp_id_2) user_services.update_user_role(self.voiceover_admin_id, feconf.ROLE_ID_VOICEOVER_ADMIN)
def setUp(self): """Populate the database of explorations and their summaries. The sequence of events is: - (1) Albert creates EXP_ID_1. - (2) Bob edits the title of EXP_ID_1. - (3) Albert creates EXP_ID_2. - (4) Albert edits the title of EXP_ID_1. - (5) Albert edits the title of EXP_ID_2. - (6) Bob reverts Albert's last edit to EXP_ID_1. - Bob tries to publish EXP_ID_2, and is denied access. - (7) Albert publishes EXP_ID_2. - (8) Albert creates EXP_ID_3 - (9) Albert publishes EXP_ID_3 - (10) Albert deletes EXP_ID_3 """ super(ExplorationDisplayableSummaries, self).setUp() self.albert_id = self.get_user_id_from_email(self.ALBERT_EMAIL) self.bob_id = self.get_user_id_from_email(self.BOB_EMAIL) self.signup(self.ALBERT_EMAIL, self.ALBERT_NAME) self.signup(self.BOB_EMAIL, self.BOB_NAME) self.save_new_valid_exploration(self.EXP_ID_1, self.albert_id) exp_services.update_exploration( self.bob_id, self.EXP_ID_1, [{ 'cmd': 'edit_exploration_property', 'property_name': 'title', 'new_value': 'Exploration 1 title' }], 'Changed title.') self.save_new_valid_exploration(self.EXP_ID_2, self.albert_id) exp_services.update_exploration( self.albert_id, self.EXP_ID_1, [{ 'cmd': 'edit_exploration_property', 'property_name': 'title', 'new_value': 'Exploration 1 Albert title' }], 'Changed title to Albert1 title.') exp_services.update_exploration( self.albert_id, self.EXP_ID_2, [{ 'cmd': 'edit_exploration_property', 'property_name': 'title', 'new_value': 'Exploration 2 Albert title' }], 'Changed title to Albert2 title.') exp_services.revert_exploration(self.bob_id, self.EXP_ID_1, 3, 2) with self.assertRaisesRegexp( Exception, 'This exploration cannot be published' ): rights_manager.publish_exploration(self.bob_id, self.EXP_ID_2) rights_manager.publish_exploration(self.albert_id, self.EXP_ID_2) self.save_new_valid_exploration(self.EXP_ID_3, self.albert_id) rights_manager.publish_exploration(self.albert_id, self.EXP_ID_3) exp_services.delete_exploration(self.albert_id, self.EXP_ID_3)
def test_unpublished_activity_is_removed_from_featured_list(self) -> None: rights_manager.publish_exploration( self.owner, self.EXP_ID_0) # type: ignore[no-untyped-call] rights_manager.publish_exploration( self.owner, self.EXP_ID_1) # type: ignore[no-untyped-call] rights_manager.publish_collection( self.owner, self.COL_ID_2) # type: ignore[no-untyped-call] activity_services.update_featured_activity_references([ self._create_exploration_reference(self.EXP_ID_0), self._create_collection_reference(self.COL_ID_2) ]) self._compare_lists( activity_services.get_featured_activity_references(), [ self._create_exploration_reference(self.EXP_ID_0), self._create_collection_reference(self.COL_ID_2) ]) # Unpublishing an unfeatured activity does not affect the featured # list. rights_manager.unpublish_exploration( self.moderator, self.EXP_ID_1) # type: ignore[no-untyped-call] self._compare_lists( activity_services.get_featured_activity_references(), [ self._create_exploration_reference(self.EXP_ID_0), self._create_collection_reference(self.COL_ID_2) ]) # Unpublishing a featured activity removes it from the featured list. rights_manager.unpublish_collection( self.moderator, self.COL_ID_2) # type: ignore[no-untyped-call] self._compare_lists( activity_services.get_featured_activity_references(), [self._create_exploration_reference(self.EXP_ID_0)]) rights_manager.unpublish_exploration( self.moderator, self.EXP_ID_0) # type: ignore[no-untyped-call] self._compare_lists( activity_services.get_featured_activity_references(), [])
def test_get_learner_dict_when_referencing_inaccessible_explorations(self): self.save_new_default_collection(self.COLLECTION_ID, self.owner_id) self.save_new_valid_exploration(self.EXP_ID, self.editor_id) collection_services.update_collection( self.owner_id, self.COLLECTION_ID, [{ 'cmd': collection_domain.CMD_ADD_COLLECTION_NODE, 'exploration_id': self.EXP_ID }], 'Added another creator\'s private exploration') # A collection cannot access someone else's private exploration. rights_manager.publish_collection(self.owner, self.COLLECTION_ID) with self.assertRaisesRegex( utils.ValidationError, 'Expected collection to only reference valid explorations, but ' 'found an exploration with ID: exploration_id'): summary_services.get_learner_collection_dict_by_id( self.COLLECTION_ID, self.owner) # After the exploration is published, the dict can now be created. rights_manager.publish_exploration(self.editor, self.EXP_ID) summary_services.get_learner_collection_dict_by_id( self.COLLECTION_ID, self.owner)
def test_deletion_rights_for_published_exploration(self): """Test rights management for deletion of published explorations.""" PUBLISHED_EXP_ID = 'published_eid' exploration = exp_domain.Exploration.create_default_exploration( PUBLISHED_EXP_ID, 'A title', 'A category') exp_services.save_new_exploration(self.owner_id, exploration) rights_manager.assign_role_for_exploration(self.owner_id, PUBLISHED_EXP_ID, self.editor_id, rights_manager.ROLE_EDITOR) rights_manager.publish_exploration(self.owner_id, PUBLISHED_EXP_ID) self.login(self.EDITOR_EMAIL) response = self.testapp.delete('/createhandler/data/%s' % PUBLISHED_EXP_ID, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.VIEWER_EMAIL) response = self.testapp.delete('/createhandler/data/%s' % PUBLISHED_EXP_ID, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.OWNER_EMAIL) response = self.testapp.delete('/createhandler/data/%s' % PUBLISHED_EXP_ID, expect_errors=True) self.assertEqual(response.status_int, 401) self.logout() self.login(self.ADMIN_EMAIL) response = self.testapp.delete('/createhandler/data/%s' % PUBLISHED_EXP_ID) self.assertEqual(response.status_int, 200) self.logout()
def _generate_dummy_explorations( self, num_dummy_exps_to_generate, num_dummy_exps_to_publish): """Generates and publishes the given number of dummy explorations. Args: num_dummy_exps_to_generate: int. Count of dummy explorations to be generated. num_dummy_exps_to_publish: int. Count of explorations to be published. Raises: Exception. Environment is not DEVMODE. """ if constants.DEV_MODE: logging.info( '[ADMIN] %s generated %s number of dummy explorations' % (self.user_id, num_dummy_exps_to_generate)) possible_titles = ['Hulk Neuroscience', 'Quantum Starks', 'Wonder Anatomy', 'Elvish, language of "Lord of the Rings', 'The Science of Superheroes'] exploration_ids_to_publish = [] for i in python_utils.RANGE(num_dummy_exps_to_generate): title = random.choice(possible_titles) category = random.choice(constants.SEARCH_DROPDOWN_CATEGORIES) new_exploration_id = exp_fetchers.get_new_exploration_id() exploration = exp_domain.Exploration.create_default_exploration( new_exploration_id, title=title, category=category, objective='Dummy Objective') exp_services.save_new_exploration(self.user_id, exploration) if i <= num_dummy_exps_to_publish - 1: exploration_ids_to_publish.append(new_exploration_id) rights_manager.publish_exploration( self.user, new_exploration_id) exp_services.index_explorations_given_ids( exploration_ids_to_publish) else: raise Exception('Cannot generate dummy explorations in production.')
def test_can_not_publish_collection_with_invalid_payload_version(self): self.set_collection_editors([self.OWNER_USERNAME]) # Login as owner and try to publish a collection with a public # exploration. self.login(self.OWNER_EMAIL) collection_id = collection_services.get_new_collection_id() exploration_id = exp_services.get_new_exploration_id() self.save_new_valid_exploration(exploration_id, self.owner_id) self.save_new_valid_collection(collection_id, self.owner_id, exploration_id=exploration_id) rights_manager.publish_exploration(self.owner, exploration_id) response = self.get_html_response( '%s/%s' % (feconf.COLLECTION_URL_PREFIX, self.COLLECTION_ID)) csrf_token = self.get_csrf_token_from_response(response) # Raises error as version is None. response_dict = self.put_json('/collection_editor_handler/publish/%s' % collection_id, {'version': None}, csrf_token=csrf_token, expected_status_int=400) self.assertEqual(response_dict['error'], 'Invalid POST request: a version must be specified.') # Raises error as version from payload does not match the collection # version. response_dict = self.put_json('/collection_editor_handler/publish/%s' % collection_id, {'version': 2}, csrf_token=csrf_token, expected_status_int=400) self.assertEqual( response_dict['error'], 'Trying to update version 1 of collection from version 2, ' 'which is too old. Please reload the page and try again.') self.logout()
def setUp(self): super(SuggestionMigrationOneOffJobTest, self).setUp() self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME) self.signup(self.EDITOR_EMAIL, self.EDITOR_USERNAME) self.signup(self.AUTHOR_EMAIL, 'author') 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.author_id = self.get_user_id_from_email(self.AUTHOR_EMAIL) self.editor = user_services.UserActionsInfo(self.editor_id) # Login and create exploration and suggestions. self.login(self.EDITOR_EMAIL) # Create exploration. self.save_new_valid_exploration(self.EXP_ID, self.editor_id, title='Exploration for suggestions', category='Algebra', objective='Test a suggestion.') exploration = exp_services.get_exploration_by_id(self.EXP_ID) init_state = exploration.states[exploration.init_state_name] init_interaction = init_state.interaction init_interaction.default_outcome.dest = exploration.init_state_name exploration.add_states(['State 1']) self.old_content = exp_domain.SubtitledHtml('content', 'old content').to_dict() # Create content in State A with a single audio subtitle. exploration.states['State 1'].update_content(self.old_content) exp_services._save_exploration(self.editor_id, exploration, '', []) # pylint: disable=protected-access rights_manager.publish_exploration(self.editor, self.EXP_ID) rights_manager.assign_role_for_exploration(self.editor, self.EXP_ID, self.owner_id, rights_manager.ROLE_EDITOR)
def test_publishing_and_unpublishing_exploration(self): exp = exp_domain.Exploration.create_default_exploration( self.EXP_ID, title='A title', category='A category') exp_services.save_new_exploration(self.user_id_a, exp) self.assertFalse( rights_manager.Actor(self.user_id_b).can_play( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertFalse( rights_manager.Actor(self.user_id_b).can_view( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) rights_manager.publish_exploration(self.user_id_a, self.EXP_ID) self.assertTrue( rights_manager.Actor(self.user_id_b).can_play( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertTrue( rights_manager.Actor(self.user_id_b).can_view( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertFalse( rights_manager.Actor(self.user_id_a).can_unpublish( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) rights_manager.unpublish_exploration(self.user_id_admin, self.EXP_ID) self.assertTrue( rights_manager.Actor(self.user_id_a).can_play( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertTrue( rights_manager.Actor(self.user_id_a).can_view( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertFalse( rights_manager.Actor(self.user_id_b).can_play( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID)) self.assertFalse( rights_manager.Actor(self.user_id_b).can_view( rights_manager.ACTIVITY_TYPE_EXPLORATION, self.EXP_ID))
def test_get_learner_dict_with_private_exp_fails_validation(self): self.save_new_valid_collection( self.COLLECTION_ID, self.owner_id, exploration_id=self.EXP_ID) # Since both the collection and exploration are private, the learner # dict can be created. summary_services.get_learner_collection_dict_by_id( self.COLLECTION_ID, self.owner) # A public collection referencing a private exploration is bad, however. rights_manager.publish_collection(self.owner, self.COLLECTION_ID) with self.assertRaisesRegex( utils.ValidationError, 'Cannot reference a private exploration within a public ' 'collection, exploration ID: exploration_id'): summary_services.get_learner_collection_dict_by_id( self.COLLECTION_ID, self.owner) # After the exploration is published, the learner dict can be crated # again. rights_manager.publish_exploration(self.owner, self.EXP_ID) summary_services.get_learner_collection_dict_by_id( self.COLLECTION_ID, self.owner)
def setUp(self): super(CheckCanUnpublishActivityTest, self).setUp() self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME) self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME) self.signup(self.MODERATOR_EMAIL, self.MODERATOR_USERNAME) self.admin_id = self.get_user_id_from_email(self.ADMIN_EMAIL) self.moderator_id = self.get_user_id_from_email(self.MODERATOR_EMAIL) self.set_admins([self.ADMIN_USERNAME]) self.set_moderators([self.MODERATOR_USERNAME]) self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL) self.admin = user_services.UserActionsInfo(self.admin_id) self.owner = user_services.UserActionsInfo(self.owner_id) self.moderator = user_services.UserActionsInfo(self.moderator_id) self.save_new_valid_exploration(self.published_exp_id, self.owner_id) self.save_new_valid_exploration(self.private_exp_id, self.owner_id) self.save_new_valid_collection(self.published_col_id, self.owner_id, exploration_id=self.published_col_id) self.save_new_valid_collection(self.private_col_id, self.owner_id, exploration_id=self.private_col_id) rights_manager.publish_exploration(self.owner, self.published_exp_id) rights_manager.publish_collection(self.owner, self.published_col_id)
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_managers_can_see_explorations(self): self.save_new_default_exploration(self.EXP_ID, self.owner_id, title=self.EXP_TITLE) self.set_admins([self.OWNER_EMAIL]) self.login(self.OWNER_EMAIL) response = self.get_json(self.MY_EXPLORATIONS_DATA_URL) self.assertEqual(len(response['explorations_list']), 1) self.assertEqual(response['explorations_list'][0]['status'], rights_manager.EXPLORATION_STATUS_PRIVATE) rights_manager.publish_exploration(self.owner_id, self.EXP_ID) response = self.get_json(self.MY_EXPLORATIONS_DATA_URL) self.assertEqual(len(response['explorations_list']), 1) self.assertEqual(response['explorations_list'][0]['status'], rights_manager.EXPLORATION_STATUS_PUBLIC) rights_manager.publicize_exploration(self.owner_id, self.EXP_ID) response = self.get_json(self.MY_EXPLORATIONS_DATA_URL) self.assertEqual(len(response['explorations_list']), 1) self.assertEqual(response['explorations_list'][0]['status'], rights_manager.EXPLORATION_STATUS_PUBLICIZED) self.logout()
def setUp(self): super(CollectionNodeMetadataDictsTest, self).setUp() self.signup(self.ALBERT_EMAIL, self.ALBERT_NAME) self.signup(self.BOB_EMAIL, self.BOB_NAME) self.albert_id = self.get_user_id_from_email(self.ALBERT_EMAIL) self.bob_id = self.get_user_id_from_email(self.BOB_EMAIL) self.albert = user_services.get_user_actions_info(self.albert_id) self.bob = user_services.get_user_actions_info(self.bob_id) self.save_new_valid_exploration( self.EXP_ID1, self.albert_id, title='Exploration 1 Albert title', objective='An objective 1') self.save_new_valid_exploration( self.EXP_ID2, self.albert_id, title='Exploration 2 Albert title', objective='An objective 2') self.save_new_valid_exploration( self.EXP_ID3, self.albert_id, title='Exploration 3 Albert title', objective='An objective 3') self.save_new_valid_exploration( self.EXP_ID4, self.bob_id, title='Exploration 4 Bob title', objective='An objective 4') self.save_new_valid_exploration( self.EXP_ID5, self.albert_id, title='Exploration 5 Albert title', objective='An objective 5') rights_manager.publish_exploration(self.albert, self.EXP_ID1) rights_manager.publish_exploration(self.albert, self.EXP_ID2) rights_manager.publish_exploration(self.albert, self.EXP_ID3) rights_manager.publish_exploration(self.bob, self.EXP_ID4) exp_services.index_explorations_given_ids([ self.EXP_ID1, self.EXP_ID2, self.EXP_ID3, self.EXP_ID4])
def setUp(self): """Populate the database of explorations and their summaries. The sequence of events is: - (1) Albert creates EXP_ID_1. - (2) Albert creates EXP_ID_2. - (3) Albert creates EXP_ID_3. - (4) Albert publishes EXP_ID_1. - (5) Albert publishes EXP_ID_2. - (6) Albert publishes EXP_ID_3. - (7) Admin user is set up. """ super(RecentlyPublishedExplorationDisplayableSummariesTest, self).setUp() self.signup(self.CURRICULUM_ADMIN_EMAIL, self.CURRICULUM_ADMIN_USERNAME) self.signup(self.ALBERT_EMAIL, self.ALBERT_NAME) self.admin_id = self.get_user_id_from_email( self.CURRICULUM_ADMIN_EMAIL) self.albert_id = self.get_user_id_from_email(self.ALBERT_EMAIL) self.albert = user_services.get_user_actions_info(self.albert_id) self.save_new_valid_exploration(self.EXP_ID_1, self.albert_id, end_state_name='End') self.save_new_valid_exploration(self.EXP_ID_2, self.albert_id, end_state_name='End') self.save_new_valid_exploration(self.EXP_ID_3, self.albert_id, end_state_name='End') rights_manager.publish_exploration(self.albert, self.EXP_ID_2) rights_manager.publish_exploration(self.albert, self.EXP_ID_1) rights_manager.publish_exploration(self.albert, self.EXP_ID_3) self.set_curriculum_admins([self.CURRICULUM_ADMIN_USERNAME])
def setUp(self): """Populate the database of explorations and their summaries. The sequence of events is: - (1) Albert creates EXP_ID_1. - (2) Bob edits the title of EXP_ID_1. - (3) Albert creates EXP_ID_2. - (4) Albert edits the title of EXP_ID_1. - (5) Albert edits the title of EXP_ID_2. - (6) Bob reverts Albert's last edit to EXP_ID_1. - Bob tries to publish EXP_ID_2, and is denied access. - (7) Albert publishes EXP_ID_2. - (8) Albert creates EXP_ID_3 - (9) Albert publishes EXP_ID_3 - (10) Albert deletes EXP_ID_3 - (1) User_3 (has a profile_picture) creates EXP_ID_4. - (2) User_4 edits the title of EXP_ID_4. - (3) User_4 edits the title of EXP_ID_4. """ super(ExplorationDisplayableSummariesTest, self).setUp() self.signup(self.ALBERT_EMAIL, self.ALBERT_NAME) self.signup(self.BOB_EMAIL, self.BOB_NAME) self.albert_id = self.get_user_id_from_email(self.ALBERT_EMAIL) self.bob_id = self.get_user_id_from_email(self.BOB_EMAIL) self.albert = user_services.get_user_actions_info(self.albert_id) self.bob = user_services.get_user_actions_info(self.bob_id) self.save_new_valid_exploration(self.EXP_ID_1, self.albert_id) exp_services.update_exploration( self.bob_id, self.EXP_ID_1, [exp_domain.ExplorationChange({ 'cmd': 'edit_exploration_property', 'property_name': 'title', 'new_value': 'Exploration 1 title' })], 'Changed title.') self.save_new_valid_exploration(self.EXP_ID_2, self.albert_id) exp_services.update_exploration( self.albert_id, self.EXP_ID_1, [exp_domain.ExplorationChange({ 'cmd': 'edit_exploration_property', 'property_name': 'title', 'new_value': 'Exploration 1 Albert title' })], 'Changed title to Albert1 title.') exp_services.update_exploration( self.albert_id, self.EXP_ID_2, [exp_domain.ExplorationChange({ 'cmd': 'edit_exploration_property', 'property_name': 'title', 'new_value': 'Exploration 2 Albert title' })], 'Changed title to Albert2 title.') exp_services.revert_exploration(self.bob_id, self.EXP_ID_1, 3, 2) with self.assertRaisesRegex( Exception, 'This exploration cannot be published' ): rights_manager.publish_exploration(self.bob, self.EXP_ID_2) rights_manager.publish_exploration(self.albert, self.EXP_ID_2) self.save_new_valid_exploration(self.EXP_ID_3, self.albert_id) rights_manager.publish_exploration(self.albert, self.EXP_ID_3) exp_services.delete_exploration(self.albert_id, self.EXP_ID_3) self.signup(self.USER_C_EMAIL, self.USER_C_NAME) self.signup(self.USER_D_EMAIL, self.USER_D_NAME) self.user_c_id = self.get_user_id_from_email(self.USER_C_EMAIL) self.user_d_id = self.get_user_id_from_email(self.USER_D_EMAIL) user_services.update_profile_picture_data_url( self.user_c_id, self.USER_C_PROFILE_PICTURE) self.save_new_valid_exploration(self.EXP_ID_4, self.user_c_id) exp_services.update_exploration( self.user_d_id, self.EXP_ID_4, [exp_domain.ExplorationChange({ 'cmd': 'edit_exploration_property', 'property_name': 'title', 'new_value': 'Exploration updated title' })], 'Changed title once.') exp_services.update_exploration( self.user_d_id, self.EXP_ID_4, [exp_domain.ExplorationChange({ 'cmd': 'edit_exploration_property', 'property_name': 'title', 'new_value': 'Exploration updated title again' })], 'Changed title twice.') self.save_new_valid_exploration(self.EXP_ID_5, self.bob_id)
def test_library_handler_for_created_explorations(self): """Test the library data handler for manually created explorations.""" self.set_admins([self.ADMIN_USERNAME]) self.login(self.ADMIN_EMAIL) response_dict = self.get_json(feconf.LIBRARY_SEARCH_DATA_URL) self.assertDictContainsSubset( { 'is_admin': True, 'is_moderator': True, 'is_super_admin': False, 'activity_list': [], 'user_email': self.ADMIN_EMAIL, 'username': self.ADMIN_USERNAME, 'search_cursor': None, }, response_dict) # Create exploration A. exploration = self.save_new_valid_exploration('A', self.admin_id, title='Title A', category='Category A', objective='Objective A') exp_services._save_exploration( # pylint: disable=protected-access self.admin_id, exploration, 'Exploration A', []) # Test that the private exploration isn't displayed. response_dict = self.get_json(feconf.LIBRARY_SEARCH_DATA_URL) self.assertEqual(response_dict['activity_list'], []) # Create exploration B. exploration = self.save_new_valid_exploration('B', self.admin_id, title='Title B', category='Category B', objective='Objective B') exp_services._save_exploration( # pylint: disable=protected-access self.admin_id, exploration, 'Exploration B', []) rights_manager.publish_exploration(self.admin, 'B') # Publish exploration A. rights_manager.publish_exploration(self.admin, 'A') exp_services.index_explorations_given_ids(['A', 'B']) # Load the search results with an empty query. response_dict = self.get_json(feconf.LIBRARY_SEARCH_DATA_URL) self.assertEqual(len(response_dict['activity_list']), 2) self.assertDictContainsSubset( { 'id': 'B', 'category': 'Category B', 'title': 'Title B', 'language_code': 'en', 'objective': 'Objective B', 'status': rights_manager.ACTIVITY_STATUS_PUBLIC, }, response_dict['activity_list'][1]) self.assertDictContainsSubset( { 'id': 'A', 'category': 'Category A', 'title': 'Title A', 'language_code': 'en', 'objective': 'Objective A', 'status': rights_manager.ACTIVITY_STATUS_PUBLIC, }, response_dict['activity_list'][0]) # Delete exploration A. exp_services.delete_exploration(self.admin_id, 'A') # Load the search results with an empty query. response_dict = self.get_json(feconf.LIBRARY_SEARCH_DATA_URL) self.assertEqual(len(response_dict['activity_list']), 1) self.assertDictContainsSubset( { 'id': 'B', 'category': 'Category B', 'title': 'Title B', 'language_code': 'en', 'objective': 'Objective B', 'status': rights_manager.ACTIVITY_STATUS_PUBLIC, }, response_dict['activity_list'][0])
def _run_batch_job_once_and_verify_output( self, exp_specs, default_title='A title', default_category='A category', default_status=rights_manager.ACTIVITY_STATUS_PUBLIC): """Run batch job for creating exploration summaries once and verify its output. exp_specs is a list of dicts with exploration specifications. Allowed keys are category, status, title. If a key is not specified, the default value is used. """ with self.swap(jobs_registry, 'ONE_OFF_JOB_MANAGERS', self.ONE_OFF_JOB_MANAGERS_FOR_TESTS): default_spec = { 'title': default_title, 'category': default_category, 'status': default_status } self.signup(self.ADMIN_EMAIL, self.ADMIN_USERNAME) self.login(self.ADMIN_EMAIL) admin_id = self.get_user_id_from_email(self.ADMIN_EMAIL) self.set_admins([self.ADMIN_USERNAME]) admin = user_services.UserActionsInfo(admin_id) # Create and delete an exploration (to make sure job handles # deleted explorations correctly). exp_id = '100' self.save_new_valid_exploration(exp_id, admin_id, title=default_spec['title'], category=default_spec['category']) exploration = exp_services.get_exploration_by_id(exp_id) exp_services.delete_exploration(admin_id, exp_id) # Get dummy explorations. num_exps = len(exp_specs) expected_job_output = {} for ind in range(num_exps): exp_id = str(ind) spec = default_spec spec.update(exp_specs[ind]) self.save_new_valid_exploration(exp_id, admin_id, title=spec['title'], category=spec['category']) exploration = exp_services.get_exploration_by_id(exp_id) # Publish exploration. if spec['status'] == rights_manager.ACTIVITY_STATUS_PUBLIC: rights_manager.publish_exploration(admin, exp_id) # Do not include user_id here, so all explorations are not # editable for now (will be updated depending on user_id # in galleries). exp_rights_model = exp_models.ExplorationRightsModel.get( exp_id) exploration = exp_services.get_exploration_by_id(exp_id) exploration_model_last_updated = exploration.last_updated exploration_model_created_on = exploration.created_on first_published_msec = (exp_rights_model.first_published_msec) # Manually create the expected summary specifying title, # category, etc. expected_job_output[exp_id] = exp_domain.ExplorationSummary( exp_id, spec['title'], spec['category'], exploration.objective, exploration.language_code, exploration.tags, feconf.get_empty_ratings(), feconf.EMPTY_SCALED_AVERAGE_RATING, spec['status'], exp_rights_model.community_owned, exp_rights_model.owner_ids, exp_rights_model.editor_ids, exp_rights_model.translator_ids, exp_rights_model.viewer_ids, [admin_id], {admin_id: 1}, exploration.version, exploration_model_created_on, exploration_model_last_updated, first_published_msec) # Note: Calling constructor for fields that are not required # and have no default value does not work, because # unspecified fields will be empty list in # expected_job_output but will be unspecified in # actual_job_output. if exploration.tags: expected_job_output[exp_id].tags = exploration.tags if exp_rights_model.owner_ids: expected_job_output[exp_id].owner_ids = ( exp_rights_model.owner_ids) if exp_rights_model.editor_ids: expected_job_output[exp_id].editor_ids = ( exp_rights_model.editor_ids) if exp_rights_model.translator_ids: expected_job_output[exp_id].translator_ids = ( exp_rights_model.translator_ids) if exp_rights_model.viewer_ids: expected_job_output[exp_id].viewer_ids = ( exp_rights_model.viewer_ids) if exploration.version: expected_job_output[exp_id].version = (exploration.version) # Run batch job. job_id = ( exp_jobs_one_off.ExpSummariesCreationOneOffJob.create_new()) exp_jobs_one_off.ExpSummariesCreationOneOffJob.enqueue(job_id) self.process_and_flush_pending_tasks() # Get and check job output. actual_job_output = exp_services.get_all_exploration_summaries() self.assertEqual(actual_job_output.keys(), expected_job_output.keys()) # Note: 'exploration_model_last_updated' is not expected to be the # same, because it is now read from the version model representing # the exploration's history snapshot, and not the ExplorationModel. simple_props = [ 'id', 'title', 'category', 'objective', 'language_code', 'tags', 'ratings', 'status', 'community_owned', 'owner_ids', 'editor_ids', 'translator_ids', 'viewer_ids', 'contributor_ids', 'contributors_summary', 'version', 'exploration_model_created_on' ] for exp_id in actual_job_output: for prop in simple_props: self.assertEqual( getattr(actual_job_output[exp_id], prop), getattr(expected_job_output[exp_id], prop))