def testOrgAppCreateOrEditByMentor(self): """Tests that a mentor cannot create an organization application. """ # Make sure we do not have an org app for this test. self.org_app.delete() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[self.org.key]) url = '/gsoc/org/application/edit/' + self.gsoc.key().name() response = self.get(url) self.assertResponseForbidden(response) org_app_key_name = 'gsoc_program/%s/orgapp' % (self.gsoc.key().name(),) org_app = org_app_survey.OrgAppSurvey.get_by_key_name(org_app_key_name) self.assertIsNone(org_app) response = self.post(url, self.getOrgAppCreatePostData()) self.assertResponseForbidden(response) org_app = org_app_survey.OrgAppSurvey.get_by_key_name(org_app_key_name) self.assertIsNone(org_app)
def testEmailIsSent(self): """Tests that acceptance and rejection emails are sent.""" # seed a couple of organization administrators for both organizations addresses_for_accept_email = [] addresses_for_reject_email = [] for _ in range(_NUMBER_OF_ORG_ADMINS): profile = profile_utils.seedNDBProfile( self.program.key(), admin_for=[self.pre_accepted_org.key]) addresses_for_accept_email.append(profile.contact.email) profile = profile_utils.seedNDBProfile( self.program.key(), admin_for=[self.pre_rejected_org.key]) addresses_for_reject_email.append(profile.contact.email) # finalize decision and execute all MapReduce jobs kwargs = { 'sponsor': self.sponsor.key().name(), 'program': self.program.program_id, } request = http.HttpRequest() data = request_data.RequestData(request, None, kwargs) handler = org_app_view.ApplyOrgAdmissionDecisionHandler(_MockView()) handler.handle(data, None, None) self.executeMapReduceJobs() # check that emails have been sent for email_address in addresses_for_accept_email: self.assertEmailSent(bcc=email_address) for email_address in addresses_for_reject_email: self.assertEmailSent(bcc=email_address)
def testPostButtonExtendDeadline(self): """Tests the extend deadline button.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[ndb.Key.from_old_key(self.org.key())]) student = profile_utils.seedNDBStudent(self.program) # set it in the future so that the auto state transfer doesn't trigger deadline = datetime.datetime.utcnow() + datetime.timedelta(hours=24) self.task.status = 'Claimed' self.task.student = student.key.to_old_key() self.task.deadline = deadline self.task.put() url = _taskPageURL(self.task) response = self.buttonPost( url, 'button_extend_deadline', {'hours': 1}) task = task_model.GCITask.get(self.task.key()) self.assertResponseRedirect(response) delta = task.deadline - deadline self.assertTrue(delta.seconds == 3600) # check if a comment has been created comments = self.task.comments() self.assertEqual(len(comments), 1) self.assertMailSentToSubscribers(comments[0]) self.assertBasicTaskView()
def testPostButtonNeedsWork(self): """Tests the needs more work for task button.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[ndb.Key.from_old_key(self.org.key())]) student = profile_utils.seedNDBStudent(self.program) self.task.status = 'NeedsReview' self.task.student = student.key.to_old_key() self.task.put() url = _taskPageURL(self.task) response = self.buttonPost(url, 'button_needs_work') # check if the task is properly closed task = task_model.GCITask.get(self.task.key()) self.assertResponseRedirect(response) self.assertEqual(task.status, 'NeedsWork') self.assertEqual( task_model.GCITask.student.get_value_for_datastore(task), student.key.to_old_key()) self.assertIsNone(task.deadline) # check if a comment has been created comments = self.task.comments() self.assertEqual(len(comments), 1) self.assertMailSentToSubscribers(comments[0]) self.assertBasicTaskView()
def testPostButtonUnassign(self): """Tests the unassign button.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[ndb.Key.from_old_key(self.org.key())]) student = profile_utils.seedNDBStudent(self.program) self.task.status = 'Claimed' self.task.student = student.key.to_old_key() self.task.put() url = _taskPageURL(self.task) response = self.buttonPost(url, 'button_unassign') # check if the task is properly unassigned task = task_model.GCITask.get(self.task.key()) self.assertResponseRedirect(response) self.assertEqual(task.status, task_model.REOPENED) self.assertIsNone(task.student) self.assertIsNone(task.deadline) # check if a comment has been created comments = self.task.comments() self.assertEqual(len(comments), 1) self.assertMailSentToSubscribers(comments[0]) self.assertBasicTaskView()
def testAccessToTheList(self): """Tests only the host can access the list.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBStudent(self.program, user=user) response = self.get(self.url) self.assertResponseForbidden(response) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[ndb.Key.from_old_key(self.org.key())]) response = self.get(self.url) self.assertResponseForbidden(response) # check for an organization administrator user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())]) response = self.get(self.url) self.assertResponseForbidden(response) user = profile_utils.seedNDBUser(host_for=[self.program]) profile_utils.loginNDB(user) response = self.get(self.url) self.assertResponseOK(response)
def testPostButtonAssign(self): """Tests the assign button.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[ndb.Key.from_old_key(self.org.key())]) student = profile_utils.seedNDBStudent(self.program) self.task.status = 'ClaimRequested' self.task.student = student.key.to_old_key() self.task.put() url = _taskPageURL(self.task) response = self.buttonPost(url, 'button_assign') # check if the task is properly assigned and a deadline has been set task = task_model.GCITask.get(self.task.key()) self.assertResponseRedirect(response) self.assertEqual(task.status, 'Claimed') self.assertEqual( task_model.GCITask.student.get_value_for_datastore(task), student.key.to_old_key()) self.assertTrue(task.deadline) # check if a comment has been created comments = self.task.comments() self.assertEqual(len(comments), 1) self.assertMailSentToSubscribers(comments[0]) # check if the update task has been enqueued self.assertTasksInQueue(n=1, url=_taskUpdateURL(task)) self.assertBasicTaskView()
def testForNonStudentProfile(self): """Tests that True is returned if a non-student profile exists.""" # seed a non-student profile profile_utils.seedNDBProfile(self.program.key(), user=self.user) result = validate.hasNonStudentProfileForProgram( self.user.key, self.program.key()) self.assertTrue(result)
def testPageLoads(self): """Tests that the page loads properly.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user) response = self.get(_getPickOrganizationToConnectUrl(self.program)) self.assertResponseOK(response)
def testUserWithActiveProfileAccessGranted(self): """Tests that access is granted if the user has an active profile.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user) access_checker = access.HAS_PROFILE_ACCESS_CHECKER access_checker.checkAccess(self.data, None)
def testUserWithNonStudentProfileAccessGranted(self): """Tests that access is granted if current user has non-student profile.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user) access_checker = access.NON_STUDENT_PROFILE_ACCESS_CHECKER access_checker.checkAccess(self.data, None)
def testPageLoads(self): """Tests that page loads properly.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user) response = self.get(_getOrgProfileCreateUrl(self.program)) self.assertResponseOK(response)
def testPageLoads(self): """Tests that the page loads properly.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user) response = self.get(_getNotificationSettingsUrl(self.program.key())) self.assertResponseOK(response)
def testOrgAdminAccessForbidden(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[self.org.key]) self._assertAccessForbiddenForUrl(self._getEnrollmentFormUrl()) self._assertAccessForbiddenForUrl(self._getTaxFormUrl())
def setUp(self): """See unittest.TestCase.setUp for specification.""" program = program_utils.seedProgram() profile = profile_utils.seedNDBProfile(program.key()) org = org_utils.seedOrganization(program.key()) self.connection = connection_utils.seed_new_connection(profile.key, org.key) self.org_admin = profile_utils.seedNDBProfile( program.key(), admin_for=[org.key])
def testAccessForbidden(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[self.org.key]) url = '/gsoc/program/create/' + self.sponsor.key().name() response = self.get(url) self.assertErrorTemplatesUsed(response)
def testPageLoads(self): """Tests that page loads properly.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[self.org.key]) response = self.get(_getManageAsOrgUrl(self.connection)) self.assertResponseOK(response)
def testPageLoads(self): """Tests that page loads properly.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user) response = self.get(_getListForUserUrl(self.program)) self.assertResponseOK(response) self._assertPageTemplatesUsed(response)
def testGetMethodForbidden(self): """Tests that GET method is not permitted.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[self.org.key]) response = self.get(_getMarkAsSeenByOrgUrl(self.connection)) self.assertResponseForbidden(response)
def testMentorAccessForbidden(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[self.org.key]) response = self.get(self.url) self.assertResponseForbidden(response) self.assertErrorTemplatesUsed(response)
def testPostMethodNotAllowed(self): """Tests that POST method is not permitted.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[self.org.key]) response = self.post(_getOrgSurveyResponseShowUrl(self.org)) self.assertResponseMethodNotAllowed(response)
def testPageLoads(self): """Tests that the page loads properly.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())]) self.timeline_helper.allWorkReviewed() response = self.get(_getProposeWinnersPageUrl(self.org.key())) self.assertResponseOK(response)
def testPageLoads(self): """Tests that page loads properly.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[self.org.key]) response = self.get(_getOrgPreferencesEditUrl(self.org)) self.assertResponseOK(response)
def testOrgAdminAccessDenied(self): """Tests that org admins cannot access the page.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[self.org.key]) response = self.get(self._getUrl()) self.assertResponseForbidden(response)
def testForNonActiveProfile(self): """Tests that False is returned if a profile is not active.""" # seed a non-student, banned profile profile_utils.seedNDBProfile( self.program.key(), user=self.user, status=profile_model.Status.BANNED) result = validate.hasNonStudentProfileForProgram( self.user.key, self.program.key()) self.assertFalse(result)
def testDashboardAsLoneUser(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user) url = '/gsoc/dashboard/' + self.gsoc.key().name() response = self.get(url) self.assertResponseOK(response) self.assertDashboardTemplatesUsed(response)
def testProfileExists(self): """Tests that second profile is not created for same user and program.""" # seed a profile profile_utils.seedNDBProfile(self.program.key(), user=self.user) result = profile_logic.createProfile( self.user.key, self.program.key(), TEST_PROFILE_PROPERTIES) self.assertFalse(result) self.assertEqual(result.extra, profile_logic.PROFILE_EXISTS)
def testOrgAdminCannotAccess(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())]) response = self.get(self.url) self.assertErrorTemplatesUsed(response)
def testOrgAdminAccessForbidden(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[self.org.key]) url = self._getUrl() response = self.get(url) self.assertErrorTemplatesUsed(response)
def testCreateOrg(self): """Tests that only the assigned org admin for an organization can edit the org profile. """ self.timeline_helper.orgSignup() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user) # create backup admin for the application backup_admin = profile_utils.seedNDBProfile(self.program.key()) self.record.createOrgAppRecord( 'new_org', user.key, backup_admin.key.parent()) url = '/gci/profile/organization/' + self.gci.key().name() create_url = url + '?org_id=new_org' response = self.get(create_url) self.assertResponseOK(response) self.assertOrgProfilePageTemplatesUsed(response) postdata = { 'home': self.createDocument(user=user).key(), 'program': self.program, 'scope': self.program, 'irc_channel': TEST_IRC_CHANNEL, 'pub_mailing_list': TEST_MAILING_LIST, 'backup_winner': None, } response, _ = self.modelPost(create_url, org_model.GCIOrganization, postdata) self.assertResponseRedirect(response, url + '/new_org?validated') # check that a organization is created key_name = '%s/%s' % (self.program.key().name(), 'new_org') organization = org_model.GCIOrganization.get_by_key_name(key_name) self.assertIsNotNone(organization) self.assertEqual(organization.irc_channel, TEST_IRC_CHANNEL) self.assertEqual(organization.pub_mailing_list, TEST_MAILING_LIST) # check that the profile is organization administrator profile = db.get(self.profile_helper.profile.key()) self.assertEqual(1, len(profile.org_admin_for)) self.assertSameEntity(self.gci, profile.program) # check that a connection is created for the main admin connection = connection_model.Connection.all().ancestor( profile.key()).filter('organization', organization).get() self.assertIsNotNone(connection) self.assertEqual(connection.org_role, connection_model.ORG_ADMIN_ROLE) self.assertEqual(connection.user_role, connection_model.ROLE) # check that a connection is created for the backup admin connection = connection_model.Connection.all().ancestor( backup_admin.key()).filter('organization', organization).get() self.assertIsNotNone(connection) self.assertEqual(connection.org_role, connection_model.ORG_ADMIN_ROLE) self.assertEqual(connection.user_role, connection_model.ROLE)
def testBulkTaskCreateBeforeOrgsAnnouncedForStudent(self): """Tests the bulk task create view before the program is public for students. """ self.timeline_helper.orgSignup() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())]) url = '/gci/bulk/' + self.org.key().name() response = self.get(url) # Task creation has not started yet self.assertResponseForbidden(response)
def setUp(self): """See unittest.TestCase.setUp for specification.""" program = program_utils.seedProgram() # seed an organization self.org = org_utils.seedOrganization(program.key()) # seed a profile self.profile = profile_utils.seedNDBProfile(program.key())
def testFullEditTaskDuringProgramForMentor(self): """Tests the task full editing view during the program for mentor.""" self.timeline_helper.tasksPubliclyVisible() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[ndb.Key.from_old_key(self.org.key())]) task = self.createTask('Unpublished') url = '/gci/task/edit/%s/%s' % (self.gci.key().name(), task.key().id()) response = self.get(url) self.assertResponseOK(response) self.assertFullEditTemplatesUsed(response)
def testFullEditTaskDuringProgramForOrgAdmin(self): """Tests the task full editing view during the program for org admin.""" self.timeline_helper.tasksPubliclyVisible() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())]) task = self.createTask(status=task_model.REOPENED) url = '/gci/task/edit/%s/%s' % (self.gci.key().name(), task.key().id()) response = self.get(url) self.assertResponseOK(response) self.assertPostClaimEditTemplatesUsed(response)
def testBulkTaskCreateDuringProgramForOrgAdmin(self): """Tests the bulk task create view during the program for org admins. """ self.timeline_helper.tasksPubliclyVisible() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())]) url = '/gci/bulk/' + self.org.key().name() response = self.get(url) self.assertResponseOK(response) self.assertFullEditTemplatesUsed(response)
def testBulkTaskCreateAfterClaimEndForMentor(self): """Tests the bulk task create view after the task claim deadline for mentors. """ self.timeline_helper.taskClaimEnded() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[ndb.Key.from_old_key(self.org.key())]) url = '/gci/bulk/' + self.org.key().name() response = self.get(url) # Task creation is not open self.assertResponseForbidden(response)
def testWishToMentorButton(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) mentor = profile_utils.seedNDBProfile(self.program.key(), user=user, mentor_for=[self.org.key]) student = profile_utils.seedSOCStudent(self.program) proposal = proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.org.key) other_mentor = profile_utils.seedNDBProfile(self.program.key(), mentor_for=[self.org.key]) suffix = "%s/%s/%d" % (self.gsoc.key().name(), student.key.parent().id(), proposal.key().id()) url = '/gsoc/proposal/wish_to_mentor/' + suffix postdata = {'value': 'unchecked'} self.post(url, postdata) proposal = GSoCProposal.get(proposal.key()) self.assertIn(mentor.key.to_old_key(), proposal.possible_mentors) postdata = {'value': 'checked'} self.post(url, postdata) proposal = GSoCProposal.get(proposal.key()) self.assertNotIn(mentor.key.to_old_key(), proposal.possible_mentors) # TODO(daniel): this section (mentor retires) should go to another test other_mentor.mentor_for = [] other_mentor.put() proposal.possible_mentors.append(other_mentor.key.to_old_key()) proposal.put() url = '/gsoc/proposal/review/' + suffix self.get(url) proposal = GSoCProposal.get(proposal.key()) self.assertNotIn(other_mentor.key.to_old_key(), proposal.possible_mentors)
def testInvalidData(self): """Tests that organization is not created if data is not valid.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[self.org.key]) backup_admin = profile_utils.seedNDBProfile(self.program.key()) # valid set of data valid_postdata = { 'org_id': TEST_ORG_ID, 'name': TEST_ORG_NAME, 'blog': TEST_BLOG, 'description': TEST_DESCRIPTION, 'facebook': TEST_FACEBOOK, 'feed_url': TEST_FEED_URL, 'google_plus': TEST_GOOGLE_PLUS, 'license': TEST_LICENSE, 'logo_url': TEST_LOGO_URL, 'ideas_page': TEST_IDEAS_PAGE, 'irc_channel': TEST_IRC_CHANNEL, 'backup_admin': backup_admin.profile_id, 'mailing_list': TEST_MAILING_LIST, 'tags': TEST_TAGS, 'twitter': TEST_TWITTER, 'web_page': TEST_WEB_PAGE, 'eligible_country': True } # the organization is not from the eligible countries postdata = valid_postdata.copy() postdata['eligible_country'] = False response = self.post( _getOrgProfileCreateUrl(self.program), postdata=postdata) self.assertTrue(response.context['error']) # the organization with the same org_id already exists org_utils.seedSOCOrganization(self.program.key(), org_id='duplicate') postdata = valid_postdata.copy() postdata['org_id'] = 'duplicate' response = self.post( _getOrgProfileCreateUrl(self.program), postdata=postdata) self.assertResponseBadRequest(response)
def setUp(self): """See unittest.TestCase.setUp for specification.""" self.init() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile = profile_utils.seedNDBProfile(self.program.key(), user=user) self.connection = connection_utils.seed_new_connection( profile.key, self.org.key, seen_by_user=False)
def testForOrgAdminForAnotherOrg(self): # seed another organization organization_two = org_utils.seedSOCOrganization(self.program.key()) profile = profile_utils.seedNDBProfile( self.program.key(), admin_for=[organization_two.key]) # profile with an org admin role can still become an org admin can_become = profile_logic.canBecomeOrgAdmin(profile) self.assertTrue(can_become)
def testPostButtonPublishUnapprovedTask(self): """Tests the publish button.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())]) self.task.status = task_model.UNAPPROVED self.task.put() url = _taskPageURL(self.task) response = self.buttonPost(url, 'button_publish') task = task_model.GCITask.get(self.task.key()) self.assertResponseRedirect(response) self.assertEqual(task.status, task_model.OPEN) self.assertBasicTaskView()
def testExtraAttrs(self): # seed female mentor for organization one mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.organization_one.key], gender=profile_model.Gender.FEMALE) # seed male mentor for organization one profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.organization_one.key], gender=profile_model.Gender.MALE) # retrieve only mentors with extra attrs extra_attrs = {profile_model.Profile.gender: [profile_model.Gender.FEMALE]} mentors = profile_logic.getMentors( self.organization_one.key, extra_attrs=extra_attrs) # only the female mentor should be returned self.assertEqual(1, len(mentors)) self.assertEqual(mentors[0].key, mentor.key)
def setUp(self): # seed a new program self.program = program_utils.seedGSoCProgram() # seed a couple of organizations self.organization = org_utils.seedSOCOrganization(self.program.key()) # seed a new mentor for organization one self.mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.organization.key], gender=profile_model.Gender.FEMALE)
def testMentorAdded(self): profile = profile_utils.seedNDBProfile(self.program.key()) profile_logic.becomeMentorForOrg(profile, self.organization_one.key) # the profile should be a mentor for organization one self.assertTrue(profile.is_mentor) self.assertIn(self.organization_one.key, profile.mentor_for) # the profile is not a mentor for organization two self.assertNotIn(self.organization_two.key, profile.mentor_for)
def testForOrgAdminForTwoOrgs(self): # seed another org admin for organization profile_utils.seedNDBProfile( self.program.key(), admin_for=[self.organization.key]) # seed another organization organization_two = org_utils.seedSOCOrganization(self.program.key()) # make the profile an org admin for organization two self.org_admin.mentor_for.append(organization_two.key) self.org_admin.admin_for.append(organization_two.key) profile_logic.resignAsOrgAdminForOrg(self.org_admin, self.organization.key) # the profile is not an org admin for organization anymore self.assertNotIn(self.organization.key, self.org_admin.admin_for) # the profile should still be an org admin for organization two self.assertTrue(self.org_admin.is_admin) self.assertIn(organization_two.key, self.org_admin.admin_for)
def setUp(self): """See unittest.TestCase.setUp for specification.""" # seed a program self.program_key = seeder_logic.seed(program_model.Program).key() # seed a user self.user = profile_utils.seedNDBUser(user_id='test') # seed a profile self.profile = profile_utils.seedNDBProfile( self.program_key, user=self.user)
def testOrgAdminForAnotherOrgAdded(self): profile = profile_utils.seedNDBProfile( self.program.key(), admin_for=[self.organization_two.key]) profile_logic.becomeOrgAdminForOrg(profile, self.organization_one.key) # profile should become org admin for organization one self._assertOrgAdmin(profile, self.organization_one) # profile should still be an org admin for organization two self._assertOrgAdmin(profile, self.organization_two)
def testFullEditTaskBeforeOrgsAnnouncedForOrgAdmin(self): """Tests the task full editing view before the program is public for org admin. """ self.timeline_helper.orgSignup() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())]) task = self.createTask() url = '/gci/task/edit/%s/%s' % (self.gci.key().name(), task.key().id()) response = self.get(url) # Task full editing has not started yet self.assertResponseForbidden(response)
def testPostClaimEditTaskBeforeOrgsAnnouncedForMentor(self): """Tests the task post claim editing view before the program is public for mentor. """ self.timeline_helper.orgSignup() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[ndb.Key.from_old_key(self.org.key())]) task = self.createTask(status='ActionNeeded') url = '/gci/task/edit/%s/%s' % (self.gci.key().name(), task.key().id()) response = self.get(url) # Task post claim editing has not started yet self.assertResponseForbidden(response)
def testForOtherMentor(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user, mentor_for=[self.org.key]) project = _createProjectForMentor(self.gsoc, self.org, self.dev_test) sponsor_id, program_id, user_id = project.parent_key().name().split( '/') kwargs = { 'sponsor': sponsor_id, 'program': program_id, 'user': user_id, 'id': project.key().id(), } data = request_data.RequestData(None, None, kwargs) self.assertFalse(project_details._isUpdateLinkVisible(data))
def testPostClaimEditTaskAfterClaimEndForMentor(self): """Tests the task post claim editing view after the task claim deadline for mentor. """ self.timeline_helper.taskClaimEnded() task = self.createTask(status='Claimed') user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())]) url = '/gci/task/edit/%s/%s' % (self.gci.key().name(), task.key().id()) response = self.get(url) # Task post claim editing has not started yet self.assertResponseForbidden(response)
def setUp(self): # seed a new program self.program = program_utils.seedGSoCProgram() # seed a couple of organizations self.organization = org_utils.seedSOCOrganization(self.program.key()) org_utils.seedSOCOrganization(self.program.key()) # seed a new org admin for organization self.org_admin = profile_utils.seedNDBProfile( self.program.key(), admin_for=[self.organization.key])
def setUp(self): # seed a new program self.program = program_utils.seedGSoCProgram() # seed a couple of organizations self.organization_one = org_utils.seedSOCOrganization(self.program.key()) self.organization_two = org_utils.seedSOCOrganization(self.program.key()) # seed a new mentor for organization one self.mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.organization_one.key])
def _seedProjectData(self): # create a mentor self.mentor = profile_utils.seedNDBProfile(self.program.key(), mentor_for=[self.org.key]) # create a student with a project self.student = profile_utils.seedSOCStudent(self.program) self.project = project_utils.seedProject(self.student, self.program.key(), org_key=self.org.key, mentor_key=self.mentor.key)
def testPageLoads(self): """Tests that page loads properly.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile = profile_utils.seedNDBProfile(self.program.key(), user=user, admin_for=[self.org.key]) url = _getListConnectionsForOrgAdminUrl(profile) response = self.get(url) self.assertResponseOK(response)
def testPostComment(self): """Tests leaving a comment on a task.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[ndb.Key.from_old_key(self.org.key())]) no_comments = self.task.comments() self.assertEqual(len(no_comments), 0) comment_title = 'Test Comment Title' comment_content = 'Test Comment Content' comment_data = { 'title': comment_title, 'content': comment_content, } url = '%s?reply' % _taskPageURL(self.task) response = self.post(url, comment_data) self.assertResponseRedirect(response) one_comment = self.task.comments() self.assertEqual(len(one_comment), 1) comment = one_comment[0] self.assertEqual(comment_title, comment.title) self.assertEqual(comment_content, comment.content) self.assertEqual( user.key.to_old_key(), comment_model.GCIComment.created_by.get_value_for_datastore(comment)) self.assertEqual( user.key.to_old_key(), comment_model.GCIComment.modified_by.get_value_for_datastore(comment)) self.assertEqual(self.task.key(), comment.parent_key()) self.assertIsNone(comment.reply) self.assertMailSentToSubscribers(comment) self.assertBasicTaskView()
def setUp(self): super(SurveyRemindersTest, self).setUp() self.init() self.mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) self.student = profile_utils.seedNDBStudent(self.program) self.project = project_utils.seedProject( self.student, self.program.key(), org_key=self.org.key, mentor_key=self.mentor.key) self.createSurveys()
def testConnectionDoesNotExist(self): """Tests that False is returned if connection does not exist.""" # seed a connection between the org and another profile other_profile = profile_utils.seedNDBProfile(self.program.key()) connection_utils.seed_new_connection(other_profile.key, self.org.key) # seed a connection between the profile and another org other_org = org_utils.seedOrganization(self.program.key()) connection_utils.seed_new_connection(self.profile.key, other_org.key) self.assertFalse( connection_logic.connectionExists(self.profile.key, self.org.key))
def testPostButtonUnpublishReopenedTaskForbidden(self): """Tests the unpublish button on.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())]) url = _taskPageURL(self.task) # try to unpublish a reopened task task = task_model.GCITask.get(self.task.key()) task.status = task_model.REOPENED task.put() response = self.buttonPost(url, 'button_unpublish') task = task_model.GCITask.get(self.task.key()) self.assertResponseForbidden(response) self.assertEqual(task.status, task_model.REOPENED)
def testPostButtonUnpublish(self): """Tests the unpublish button.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())]) url = _taskPageURL(self.task) response = self.buttonPost(url, 'button_unpublish') task = task_model.GCITask.get(self.task.key()) self.assertResponseRedirect(response) self.assertEqual(task.status, 'Unpublished') # check if a comment has been created comments = self.task.comments() self.assertEqual(len(comments), 1) self.assertMailSentToSubscribers(comments[0]) self.assertBasicTaskView()