def testUserWithStudentProfileAccessDenied(self): """Tests that access is denied if current user has student profile.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedSOCStudent(self.program, user=user) access_checker = access.NON_STUDENT_PROFILE_ACCESS_CHECKER with self.assertRaises(exception.UserError) as context: access_checker.checkAccess(self.data, None) self.assertEqual(context.exception.status, httplib.FORBIDDEN)
def testStudentAccessOtherProjectForbidden(self): self.timeline_helper.studentsAnnounced() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedSOCStudent(self.program, user=user) project = _createProjectForStudent(self.gsoc, self.org, self.dev_test) url = self._getProjectUpdateUrl(project) response = self.get(url) self.assertErrorTemplatesUsed(response) self.assertResponseForbidden(response)
def testSubmitProposal(self): self.timeline_helper.studentSignup() mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) # TODO(daniel): take care of notifications # notify_new_proposals=True, notify_public_comments=True, # notify_private_comments=True) profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedSOCStudent(self.program, user) # TODO(daniel): take care of notifications # self.profile_helper.notificationSettings() url = '/gsoc/proposal/submit/' + self.org.key.id() response = self.get(url) self.assertResponseOK(response) self.assertProposalTemplatesUsed(response) # test proposal POST override = { 'program': self.gsoc, 'score': 0, 'nr_scores': 0, 'mentor': None, 'org': self.org.key.to_old_key(), 'is_publicly_visible': False, 'status': 'pending', 'accept_as_project': False, 'is_editable_post_deadline': False, 'extra': None, 'has_mentor': False, } response, _ = self.modelPost( url, proposal_model.GSoCProposal, override) self.assertResponseRedirect(response) # TODO(daniel): take care of notifications # self.assertEmailSent(to=mentor.contact.email) # TODO(daniel): add assertEmailNotSent to DjangoTestCase #self.assertEmailNotSent(to=other_mentor.profile.email) proposal = proposal_model.GSoCProposal.all().get() # check org manually, as proposal.org will fail # TODO(daniel): it will not be needed when proposal model is updated org_key = proposal_model.GSoCProposal.org.get_value_for_datastore(proposal) self.assertEqual(org_key, self.org.key.to_old_key()) self.assertFalse(proposal.is_publicly_visible) self.assertIsNone(proposal.extra) self.assertFalse(proposal.accept_as_project) self.assertFalse(proposal.is_editable_post_deadline)
def testListProjects(self): self.timeline_helper.studentsAnnounced() url = '/gsoc/projects/list/' + self.gsoc.key().name() response = self.get(url) self.assertResponseOK(response) self.assertProjectTemplatesUsed(response) response = self.getListResponse(url, 0) self.assertIsJsonResponse(response) data = response.context['data'][''] self.assertEqual(0, len(data)) student = profile_utils.seedSOCStudent(self.program) project_utils.seedProject(student, self.program.key(), org_key=self.org.key) response = self.getListResponse(url, 0) self.assertIsJsonResponse(response) data = response.context['data'][''] self.assertEqual(1, len(data)) columns = response.context['data'][''][0]['columns'] self.assertIn('key', columns) self.assertIn('title', columns) self.assertIn('mentors', columns) self.assertIn('student', columns) self.assertIn('org', columns)
def testListProposals(self): user = profile_utils.seedNDBUser(host_for=[self.program]) profile_utils.loginNDB(user) self.timeline_helper.studentSignup() url = '/gsoc/admin/proposals/' + self.org.key.id() response = self.get(url) self.assertResponseOK(response) self.assertProposalsPage(response) response = self.getListResponse(url, 0) self.assertIsJsonResponse(response) data = response.context['data'][''] self.assertEqual(0, len(data)) # test list with student's proposal student = profile_utils.seedSOCStudent(self.program) proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.org.key) response = self.getListResponse(url, 0) self.assertIsJsonResponse(response) data = response.context['data'][''] self.assertEqual(1, len(data))
def testSubmitAnotherForm(self): """Tests that another form may be resubmitted by a student.""" self.timeline_helper.formSubmission() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) student = profile_utils.seedSOCStudent(self.program, user=user) project_utils.seedProject( student, self.program.key(), org_key=self.org.key) # set initial tax form blob_key = self.createBlob('initial_tax_form.pdf') student.student_data.tax_form = blob_key student.put() # submit a new tax form with tempfile.NamedTemporaryFile() as test_file: # check for the enrollment form url = self._getTaxFormUrl() postdata = {'tax_form': test_file} response = self.post(url, postdata) self.assertResponseRedirect( response, self._getTaxFormUrl(validated=True)) # check if the form has been submitted student = student.key.get() self.assertIsNotNone(student.student_data.tax_form) self.assertEqual(os.path.basename(test_file.name), student.student_data.tax_form)
def testTakeEvalForStudentProjectWithAnotherMentor(self): """Test that a student with a project in the same org but with a different mentor than the current mentor will be redirected. """ url, evaluation, _ = self.getStudentEvalRecordProperties() mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) student = profile_utils.seedSOCStudent(self.program) project_utils.seedProject( student, self.program.key(), mentor_key=mentor.key) response = self.get(url) self.assertResponseForbidden(response) project = project_model.GSoCProject.all().get() suffix = "%s/%s/%s/%s" % ( self.gsoc.key().name(), evaluation.link_id, self.student.profile_id, project.key().id()) base_url = '/gsoc/eval/student' self.ffPastEval(evaluation) response = self.get(url) show_url = '%s/show/%s' % (base_url, suffix) self.assertResponseRedirect(response, show_url)
def testTakeEvalForStudentProjectWithAnotherOrg(self): """Test that if a student with a project for an org attempts to take an evaluation for a different org, they will be redirected. """ url, evaluation, _ = self.getStudentEvalRecordProperties() other_org = self.createOrg() project = project_model.GSoCProject.all().get() mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[other_org.key]) other_student = profile_utils.seedSOCStudent(self.program) other_project = project_utils.seedProject(other_student, self.program.key(), org_key=other_org.key, mentor_key=mentor.key) response = self.get(url) self.assertResponseForbidden(response) suffix = "%s/%s/%s/%s" % ( self.gsoc.key().name(), evaluation.link_id, self.student.profile_id, project.key().id()) self.ffPastEval(evaluation) response = self.get(url) show_url = '/gsoc/eval/student/show/%s' % suffix self.assertResponseRedirect(response, show_url)
def testListProposals(self): user = profile_utils.seedNDBUser(host_for=[self.program]) profile_utils.loginNDB(user) self.timeline_helper.studentSignup() url = '/gsoc/admin/proposals/' + self.org.key.id() response = self.get(url) self.assertResponseOK(response) self.assertProposalsPage(response) response = self.getListResponse(url, 0) self.assertIsJsonResponse(response) data = response.context['data'][''] self.assertEqual(0, len(data)) # test list with student's proposal student = profile_utils.seedSOCStudent(self.program) proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.org.key) response = self.getListResponse(url, 0) self.assertIsJsonResponse(response) data = response.context['data'][''] self.assertEqual(1, len(data))
def testAssignMentor(self): student = profile_utils.seedSOCStudent(self.program) proposal = proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.org.key, mentor=None) suffix = "%s/%s/%d" % (self.gsoc.key().name(), student.profile_id, proposal.key().id()) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) mentor = profile_utils.seedNDBProfile(self.program.key(), user=user, mentor_for=[self.org.key]) url = '/gsoc/proposal/assign_mentor/' + suffix postdata = {'assign_mentor': mentor.key} response = self.post(url, postdata) self.assertResponseForbidden(response) proposal = GSoCProposal.all().get() mentor_key = GSoCProposal.mentor.get_value_for_datastore(proposal) self.assertIsNone(mentor_key)
def testResubmitProposal(self): self.timeline_helper.studentSignup() mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) # TODO(daniel): take care of notifications: notify_proposal_updates=True user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) student = profile_utils.seedSOCStudent(self.program, user) proposal = proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.org.key, mentor_key=mentor.key, status=proposal_model.STATUS_WITHDRAWN) # TODO(daniel): take care of notifications # self.profile_helper.notificationSettings() url = '/gsoc/proposal/update/%s/%s/%s' % ( self.gsoc.key().name(), student.profile_id, proposal.key().id()) # resubmit proposal postdata = {'action': 'Resubmit'} self.post(url, postdata) # check if the proposal is resubmitted proposal = proposal_model.GSoCProposal.get(proposal.key()) self.assertEqual(proposal_model.STATUS_PENDING, proposal.status) student = student.key.get() # check if number of proposals is increased self.assertEqual(student.student_data.number_of_proposals, 1)
def testForStudentProfile(self): # make the profile invalid profile = profile_utils.seedSOCStudent(self.program) # student profiles cannot become mentors can_become = profile_logic.canBecomeMentor(profile) self.assertFalse(can_become)
def testAssignMentor(self): student = profile_utils.seedSOCStudent(self.program) proposal = proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.org.key, mentor=None) suffix = "%s/%s/%d" % ( self.gsoc.key().name(), student.profile_id, proposal.key().id()) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) mentor = profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[self.org.key]) url = '/gsoc/proposal/assign_mentor/' + suffix postdata = {'assign_mentor': mentor.key} response = self.post(url, postdata) self.assertResponseForbidden(response) proposal = GSoCProposal.all().get() mentor_key = GSoCProposal.mentor.get_value_for_datastore(proposal) self.assertIsNone(mentor_key)
def testForOtherStudent(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedSOCStudent(self.program, user=user) project = _createProjectForStudent(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 setUp(self): self.program = program_utils.seedGSoCProgram() self.organization = org_utils.seedSOCOrganization(self.program.key()) self.student = profile_utils.seedSOCStudent(self.program) # seed a project for above organization, program and student self.project = project_utils.seedProject( self.student, self.program.key(), org_key=self.organization.key)
def createProject(self): mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) student = profile_utils.seedSOCStudent(self.program) return project_utils.seedProject( student, self.program.key(), org_key=self.org.key, mentor_key=mentor.key)
def testForOtherStudent(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedSOCStudent(self.program, user=user) project = _createProjectForStudent(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 createProject(self): mentor = profile_utils.seedNDBProfile(self.program.key(), mentor_for=[self.org.key]) student = profile_utils.seedSOCStudent(self.program) return project_utils.seedProject(student, self.program.key(), org_key=self.org.key, mentor_key=mentor.key)
def setUp(self): """See unittest.TestCase.setUp for specification.""" self.init() user = profile_utils.seedNDBUser() self.profile = profile_utils.seedSOCStudent(self.program, user=user) profile_utils.loginNDB(user) self.proposal = proposal_utils.seedProposal( self.profile.key, self.program.key(), org_key=self.org.key)
def setUp(self): """See unittest.TestCase.setUp for specification.""" self.init() user = profile_utils.seedNDBUser() self.profile = profile_utils.seedSOCStudent(self.program, user=user) profile_utils.loginNDB(user) self.proposal = proposal_utils.seedProposal(self.profile.key, self.program.key(), org_key=self.org.key)
def testProjectList(self): """Tests that project list shows projects for the organization.""" self.timeline_helper.studentsAnnounced() # seed a few projects for the organization for _ in range(NUMBER_OF_PROJECTS): student = profile_utils.seedSOCStudent(self.program) project_utils.seedProject( student, self.program.key(), org_key=self.org.key) # seed a project for another organization other_org = org_utils.seedSOCOrganization(self.program.key()) student = profile_utils.seedSOCStudent(self.program) project_utils.seedProject( student, self.program.key(), org_key=other_org.key) # check that only orgs for the first organization are listed data = self.getListData(_getOrgHomeUrl(self.org), 0) self.assertEqual(NUMBER_OF_PROJECTS, len(data))
def testProfileNotAllowedToBecomeOrgAdmin(self): profile = profile_utils.seedSOCStudent(self.program) profile_logic.becomeOrgAdminForOrg(profile, self.organization_one.key) # the profile should not become org admin for ogranization one self._assertNoRole(profile, self.organization_one) # the profile should still be a student self.assertTrue(profile.is_student)
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 testUpdateNonExistingProposal(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) student = profile_utils.seedSOCStudent(self.program, user=user) mock_id = 1 url = '/gsoc/proposal/update/%s/%s/%s' % ( self.gsoc.key().name(), student.profile_id, mock_id) response = self.get(url) self.assertResponseNotFound(response)
def testProfileNotAllowedToBecomeMentor(self): profile = profile_utils.seedSOCStudent(self.program) profile_logic.becomeMentorForOrg(profile, self.organization_one.key) # the profile should not become a mentor self.assertFalse(profile.is_mentor) self.assertNotIn(self.organization_one.key, profile.mentor_for) # the profile should still be a student self.assertTrue(profile.is_student)
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 setUp(self): """See unittest.TestCase.setUp for specification.""" self.init() user = profile_utils.seedNDBUser() self.profile = profile_utils.seedSOCStudent(self.program, user=user) profile_utils.loginNDB(user) self.proposal = proposal_utils.seedProposal( self.profile.key, self.program.key(), org_key=self.org.key) # view used as a callback for handler self.view = proposal_review_view.ProposalStatusSetter()
def testForMentorWithProject(self): # seed a project for organization one and set a mentor student = profile_utils.seedSOCStudent(self.program) project_utils.seedProject( student, self.program.key(), org_key=self.organization.key, mentor_key=self.mentor.key) profile_logic.resignAsMentorForOrg(self.mentor, self.organization.key) # the profile should still be a mentor because of the project self.assertTrue(self.mentor.is_mentor) self.assertIn(self.organization.key, self.mentor.mentor_for)
def testUpdateProposal(self): """Test update proposals.""" self.timeline_helper.studentSignup() mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) # TODO(daniel): take care of notifications: notify_proposal_updates=True user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) student = profile_utils.seedSOCStudent(self.program, user) proposal = proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.org.key, mentor_key=mentor.key) # TODO(daniel): take care of notifications # self.profile_helper.notificationSettings() url = '/gsoc/proposal/update/%s/%s/%s' % ( self.gsoc.key().name(), student.profile_id, proposal.key().id()) response = self.get(url) self.assertResponseOK(response) self.assertProposalTemplatesUsed(response) override = { 'program': self.gsoc, 'score': 0, 'nr_scores': 0, 'has_mentor': True, 'mentor': mentor, 'org': self.org, 'status': 'pending', 'action': 'Update', 'is_publicly_visible': False, 'extra': None, 'accept_as_project': False, 'is_editable_post_deadline': False } response, properties = self.modelPost( url, proposal_model.GSoCProposal, override) self.assertResponseRedirect(response) properties.pop('action') proposal = proposal_model.GSoCProposal.all().get() # check org manually, as proposal.org will fail # TODO(daniel): it will not be needed when proposal model is updated org_key = proposal_model.GSoCProposal.org.get_value_for_datastore(proposal) self.assertEqual(org_key, self.org.key.to_old_key()) self.assertFalse(proposal.is_publicly_visible) self.assertIsNone(proposal.extra) self.assertFalse(proposal.accept_as_project) self.assertFalse(proposal.is_editable_post_deadline) # after update last_modified_on should be updated which is not equal # to created_on self.assertNotEqual(proposal.created_on, proposal.last_modified_on) self.assertEmailSent(to=mentor.contact.email)
def setUp(self): """See unittest.TestCase.setUp for specification.""" self.init() user = profile_utils.seedNDBUser() self.profile = profile_utils.seedSOCStudent(self.program, user=user) profile_utils.loginNDB(user) self.proposal = proposal_utils.seedProposal(self.profile.key, self.program.key(), org_key=self.org.key) # view used as a callback for handler self.view = proposal_review_view.ProposalStatusSetter()
def testStudentAccessForbidden(self): # access should be forbidden because at this point students are not # permitted to upload their forms self.timeline_helper.studentsAnnounced() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) student = profile_utils.seedSOCStudent(self.program, user=user) project_utils.seedProject( student, self.program.key(), org_key=self.org.key) self._assertAccessForbiddenForUrl(self._getEnrollmentFormUrl()) self._assertAccessForbiddenForUrl(self._getTaxFormUrl())
def testStudentAccessTheirProjectGranted(self): self.timeline_helper.studentsAnnounced() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) student = profile_utils.seedSOCStudent(self.program, user=user) project = _createProjectForStudent( self.gsoc, self.org, self.dev_test, student=student) url = self._getProjectUpdateUrl(project) response = self.get(url) self.assertResponseOK(response)
def testProposalsSubmissionLimit(self): self.timeline_helper.studentSignup() self.gsoc.apps_tasks_limit = 5 self.gsoc.put() profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) # TODO(daniel): take care of notifications # notify_new_proposals=True, notify_public_comments=True, # notify_private_comments=True) profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedSOCStudent(self.program, user) # TODO(daniel): take care of notifications # self.profile_helper.notificationSettings() override = { 'program': self.gsoc, 'score': 0, 'nr_scores': 0, 'mentor': None, 'org': self.org, 'status': 'pending', 'accept_as_project': False, 'is_editable_post_deadline': False, 'extra': None, 'has_mentor': False, } url = '/gsoc/proposal/submit/' + self.org.key.id() # Try to submit proposals four times. for _ in range(5): response, _ = self.modelPost( url, proposal_model.GSoCProposal, override) self.assertResponseRedirect(response) response, _ = self.modelPost( url, proposal_model.GSoCProposal, override) self.assertResponseForbidden(response)
def setUp(self): """Creates a published task for self.org. """ super(TestStudentTasksForOrganizationPage, self).setUp() self.init() self.timeline_helper.tasksPubliclyVisible() # Create a task, status published mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[ndb.Key.from_old_key(self.org.key())]) self.task = task_utils.seedTask( self.program, self.org, mentors=[mentor.key.to_old_key()]) self.student = profile_utils.seedSOCStudent(self.program)
def testReviewProposalPublicView(self): student = profile_utils.seedSOCStudent(self.program) proposal = proposal_utils.seedProposal(student.key, self.program.key(), is_publicly_visible=True) suffix = "%s/%s/%d" % (self.gsoc.key().name(), student.key.parent().id(), proposal.key().id()) # test review GET url = '/gsoc/proposal/review/' + suffix response = self.get(url) self.assertResponseOK(response) self.assertGSoCTemplatesUsed(response) self.assertTemplateUsed(response, 'modules/gsoc/proposal/review.html')
def testStudentAccessTheirProjectGranted(self): self.timeline_helper.studentsAnnounced() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) student = profile_utils.seedSOCStudent(self.program, user=user) project = _createProjectForStudent(self.gsoc, self.org, self.dev_test, student=student) url = self._getProjectUpdateUrl(project) response = self.get(url) self.assertResponseOK(response)
def setUp(self): """Creates a published task for self.org. """ super(TestStudentTasksForOrganizationPage, self).setUp() self.init() self.timeline_helper.tasksPubliclyVisible() # Create a task, status published mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[ndb.Key.from_old_key(self.org.key())]) self.task = task_utils.seedTask(self.program, self.org, mentors=[mentor.key.to_old_key()]) self.student = profile_utils.seedSOCStudent(self.program)
def testReviewProposalPublicView(self): student = profile_utils.seedSOCStudent(self.program) proposal = proposal_utils.seedProposal( student.key, self.program.key(), is_publicly_visible=True) suffix = "%s/%s/%d" % ( self.gsoc.key().name(), student.key.parent().id(), proposal.key().id()) # test review GET url = '/gsoc/proposal/review/' + suffix response = self.get(url) self.assertResponseOK(response) self.assertGSoCTemplatesUsed(response) self.assertTemplateUsed(response, 'modules/gsoc/proposal/review.html')
def _createProjectForStudent(program, org, dev_test, student=None): """Returns a newly created GSoCProject for the specified student. If a new student instance is not provided, a new profile is created. Args: program: GSoCProgram instance for which the project is to be created org: Organization entity. dev_test: whether it is dev test environment student: the specified GSoCProfile student instance to mentor the project Returns: the newly created GSoCProject instance """ if not student: student = profile_utils.seedSOCStudent(program) return project_utils.seedProject(student, program.key(), org_key=org.key)
def testProjectExists(self): """Tests that project is returned correctly if exists.""" sponsor = program_utils.seedSponsor() program = program_utils.seedProgram(sponsor_key=sponsor.key()) profile = profile_utils.seedSOCStudent(program) project = project_utils.seedProject(profile, program.key()) kwargs = { 'sponsor': sponsor.link_id, 'program': program.program_id, 'user': profile.profile_id, 'id': str(project.key().id()) } data = request_data.RequestData(None, None, kwargs) url_project = data.url_project self.assertEqual(project.key(), url_project.key())
def testUpdateProposalAfterDeadline(self): """Tests attempting to update a proposal after the deadline has passed.""" self.timeline_helper.studentsAnnounced() mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) student = profile_utils.seedSOCStudent(self.program, user) proposal = proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.org.key, mentor_key=mentor.key) url = '/gsoc/proposal/update/%s/%s/%s' % ( self.gsoc.key().name(), student.profile_id, proposal.key().id()) response = self.get(url) 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 testPageLoads(self): """Tests that the page loads properly.""" evaluation = self.evaluation_helper.createMentorEvaluation() 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) project = project_utils.seedProject( student, self.program.key(), org_key=self.org.key, mentor_key=mentor.key) # test mentor evaluation show GET for a mentor of the project response = self.get( _getMentorEvaluationTakePageUrl(self.program, evaluation, project)) self.assertResponseOK(response) self.assertEvaluationTakeTemplateUsed(response)
def testDashboardAsMentorWithProject(self): self.timeline_helper.studentsAnnounced() user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile = profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[self.org.key]) student = profile_utils.seedSOCStudent(self.program) project_utils.seedProject( student, self.program.key(), org_key=self.org.key, mentor_key=profile.key) url = '/gsoc/dashboard/' + self.gsoc.key().name() response = self.get(url) self.assertResponseOK(response) self.assertDashboardComponentTemplatesUsed(response) response = self.getListResponse(url, 4) self.assertIsJsonResponse(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)