def testHasMentorProposalAssigned(self): """Unit test for proposal_logic.hasMentorProposalAssigned function.""" # seed a new mentor mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.foo_organization.key]) # mentor has no proposals has_proposal = proposal_logic.hasMentorProposalAssigned(mentor) self.assertFalse(has_proposal) # seed a new proposal and assign the mentor student = profile_utils.seedNDBStudent(self.program) proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.foo_organization.key, mentor_key=mentor.key) # mentor has a proposal now has_proposal = proposal_logic.hasMentorProposalAssigned(mentor) self.assertTrue(has_proposal) # mentor has also proposal for foo organization has_proposal = proposal_logic.hasMentorProposalAssigned( mentor, org_key=self.foo_organization.key) self.assertTrue(has_proposal) # mentor does not have proposal for bar organization has_proposal = proposal_logic.hasMentorProposalAssigned( mentor, org_key=self.bar_organization.key) self.assertFalse(has_proposal)
def testHasMentorProposalAssigned(self): """Unit test for proposal_logic.hasMentorProposalAssigned function.""" # seed a new mentor mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.foo_organization.key]) # mentor has no proposals has_proposal = proposal_logic.hasMentorProposalAssigned(mentor) self.assertFalse(has_proposal) # seed a new proposal and assign the mentor student = profile_utils.seedNDBStudent(self.program) proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.foo_organization.key, mentor_key=mentor.key) # mentor has a proposal now has_proposal = proposal_logic.hasMentorProposalAssigned(mentor) self.assertTrue(has_proposal) # mentor has also proposal for foo organization has_proposal = proposal_logic.hasMentorProposalAssigned( mentor, org_key=self.foo_organization.key) self.assertTrue(has_proposal) # mentor does not have proposal for bar organization has_proposal = proposal_logic.hasMentorProposalAssigned( mentor, org_key=self.bar_organization.key) self.assertFalse(has_proposal)
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 testAcceptTwoProposals(self): """Tests that two proposals can be accepted in the same request.""" user = profile_utils.seedNDBUser(host_for=[self.program]) profile_utils.loginNDB(user) mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) student_one = profile_utils.seedNDBStudent(self.program) proposal_one = proposal_utils.seedProposal( student_one.key, self.program.key(), org_key=self.org.key, mentor_key=mentor.key) student_two = profile_utils.seedNDBStudent(self.program) proposal_two = proposal_utils.seedProposal( student_two.key, self.program.key(), org_key=self.org.key, mentor_key=mentor.key) list_data = [ {accept_withdraw_projects._PROPOSAL_KEY: str(proposal_one.key())}, {accept_withdraw_projects._PROPOSAL_KEY: str(proposal_two.key())} ] post_data = { 'button_id': 'accept', 'data': json.dumps(list_data), 'idx': 0, } self.post(self.url, post_data) # check if both proposals are accepted correctly proposal1 = proposal_model.GSoCProposal.get(proposal_one.key()) self.assertEqual(proposal1.status, proposal_model.STATUS_ACCEPTED) proposal2 = proposal_model.GSoCProposal.get(proposal_two.key()) self.assertEqual(proposal2.status, proposal_model.STATUS_ACCEPTED)
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 _createStudent(self, email, n_proposals): """Creates a student with proposals.""" student = profile_utils.seedNDBStudent(self.program) for _ in range(n_proposals): proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.org.key, mentor_key=self.mentor.key) # TODO(daniel): bring back notifications # student.notificationSettings() return student
def _createStudent(self, email, n_proposals): """Creates a student with proposals.""" student = profile_utils.seedNDBStudent(self.program) for _ in range(n_proposals): proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.org.key, mentor_key=self.mentor.key) # TODO(daniel): bring back notifications # student.notificationSettings() return student
def testWithdrawProposalForStudentWithFewProposals(self): # create a few other proposals for _ in range(3): proposal_utils.seedProposal(self.student.key, self.program.key()) # withdraw the main proposal result = proposal_logic.withdrawProposal(self.proposal, self.student) # the proposal should be withdrawn self.assertTrue(result) self.assertEqual(proposal_model.STATUS_WITHDRAWN, self.proposal.status) self.assertEqual(3, self.student.student_data.number_of_proposals)
def testDashboardAsStudentWithProposal(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile = profile_utils.seedNDBStudent(self.program, user=user) proposal_utils.seedProposal(profile.key, self.program.key()) url = '/gsoc/dashboard/' + self.gsoc.key().name() response = self.get(url) self.assertResponseOK(response) self.assertDashboardComponentTemplatesUsed(response) response = self.getListResponse(url, 1) self.assertIsJsonResponse(response)
def setUp(self): super(ProposalDuplicatesTest, self).setUp() self.init() self.timeline_helper.studentSignup() # set the organization as accepted and allocate some slots self.org.status = org_model.Status.ACCEPTED self.org.slot_allocation = 10 self.org.put() # the first student has a two duplicates and one non-accepted proposal self.student1 = profile_utils.seedNDBStudent(self.program) for _ in range(_FIRST_STUDENT_NUMBER_OF_DUPLICATES): proposal_utils.seedProposal(self.student1.key, self.program.key(), org_key=self.org.key, accept_as_project=True) proposal_utils.seedProposal(self.student1.key, self.program.key(), org_key=self.org.key, accept_as_project=False) # the other student has two proposals; one of them is to be accepted. self.student2 = profile_utils.seedNDBStudent(self.program) proposal_utils.seedProposal(self.student2.key, self.program.key(), org_key=self.org.key, accept_as_project=True) proposal_utils.seedProposal(self.student2.key, self.program.key(), org_key=self.org.key, accept_as_project=False)
def setUp(self): super(ProposalDuplicatesTest, self).setUp() self.init() self.timeline_helper.studentSignup() # set the organization as accepted and allocate some slots self.org.status = org_model.Status.ACCEPTED self.org.slot_allocation = 10 self.org.put() # the first student has a two duplicates and one non-accepted proposal self.student1 = profile_utils.seedNDBStudent(self.program) for _ in range(_FIRST_STUDENT_NUMBER_OF_DUPLICATES): proposal_utils.seedProposal( self.student1.key, self.program.key(), org_key=self.org.key, accept_as_project=True) proposal_utils.seedProposal( self.student1.key, self.program.key(), org_key=self.org.key, accept_as_project=False) # the other student has two proposals; one of them is to be accepted. self.student2 = profile_utils.seedNDBStudent(self.program) proposal_utils.seedProposal( self.student2.key, self.program.key(), org_key=self.org.key, accept_as_project=True) proposal_utils.seedProposal( self.student2.key, self.program.key(), org_key=self.org.key, accept_as_project=False)
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 setUp(self): sponsor = program_utils.seedSponsor() # seed a timeline and set student app period for now self.timeline = program_utils.seedTimeline( models=types.SOC_MODELS, timeline_id=TEST_PROGRAM_ID, sponsor_key=sponsor.key(), student_signup_start=timeline_utils.past(), student_signup_end=timeline_utils.future(delta=50), accepted_students_announced_deadline=timeline_utils.future( delta=75)) self.program = program_utils.seedGSoCProgram( program_id=TEST_PROGRAM_ID, sponsor_key=sponsor.key(), timeline_key=self.timeline.key(), app_tasks_limit=3) # seed a new student info self.student = profile_utils.seedNDBStudent(self.program) # seed a new proposal self.proposal = proposal_utils.seedProposal( self.student.key, self.program.key(), status=proposal_model.STATUS_WITHDRAWN)
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 testAcceptProposal(self): """Tests that a proposal is correctly accepted.""" user = profile_utils.seedNDBUser(host_for=[self.program]) profile_utils.loginNDB(user) mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.org.key]) student = profile_utils.seedNDBStudent(self.program) proposal = proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.org.key, mentor_key=mentor.key) list_data = [{accept_withdraw_projects._PROPOSAL_KEY: str(proposal.key())}] post_data = { 'button_id': 'accept', 'data': json.dumps(list_data), 'idx': 0, } self.post(self.url, post_data) # check if proposal is accepted correctly proposal = proposal_model.GSoCProposal.get(proposal.key()) self.assertEqual(proposal.status, proposal_model.STATUS_ACCEPTED) # check if a project is created project = project_model.GSoCProject.all().ancestor( student.key.to_old_key()).get() self.assertEqual(project.status, project_model.STATUS_ACCEPTED) self.assertEqual(project.proposal.key(), proposal.key()) # check if number of projects is updated student = student.key.get() self.assertEqual(student.student_data.number_of_projects, 1)
def testCanWithdrawPendingProposal(self): proposal = proposal_utils.seedProposal(self.student.key, self.program.key()) can_withdraw = proposal_logic.canProposalBeWithdrawn(proposal) # it should be possible to withdraw a pending proposal self.assertTrue(can_withdraw)
def testCannotWithdrawWithdrawnProposals(self): proposal = proposal_utils.seedProposal( self.student.key, self.program.key(), status=proposal_model.STATUS_WITHDRAWN) can_withdraw = proposal_logic.canProposalBeWithdrawn(proposal) # it is not possible to withdraw already withdrawn proposal self.assertFalse(can_withdraw)
def testCannotWithdrawIgnoredProposal(self): proposal = proposal_utils.seedProposal( self.student.key, self.program.key(), status=proposal_model.STATUS_IGNORED) can_withdraw = proposal_logic.canProposalBeWithdrawn(proposal) # it is not possible to withdraw ignored proposals self.assertFalse(can_withdraw)
def setUp(self): # seed a new program self.program = program_utils.seedGSoCProgram() # seed a new profile and make it a student self.student = profile_utils.seedNDBStudent(self.program) self.proposal = proposal_utils.seedProposal(self.student.key, self.program.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): # seed a new program self.program = program_utils.seedGSoCProgram() # seed a new profile and make it a student self.student = profile_utils.seedNDBStudent(self.program) self.proposal = proposal_utils.seedProposal( self.student.key, self.program.key())
def testMentorWithProposal(self): # seed a new proposal and assign our mentor student = profile_utils.seedSOCStudent(self.program) proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.organization_one.key, mentor_key=self.mentor.key) # mentor is involved in organization one because of a proposal can_resign = profile_logic.canResignAsMentorForOrg( self.mentor, self.organization_one.key) self.assertFalse(can_resign) # add mentor role for organization two self.mentor.mentor_for.append(self.organization_two.key) # mentor is not involved in organization two can_resign = profile_logic.canResignAsMentorForOrg( self.mentor, self.organization_two.key) self.assertTrue(can_resign)
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) # view used as a callback for handler self.view = proposal_review_view.ProposalStatusSetter()
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 setUp(self): # seed a new program self.program = program_utils.seedGSoCProgram() # seed a new organization self.org = org_utils.seedSOCOrganization(self.program.key()) # create a new profile and make it a student self.student = profile_utils.seedNDBStudent(self.program) # seed a new proposal and assign self.proposal = proposal_utils.seedProposal( self.student.key, self.program.key(), org_key=self.org.key)
def setUp(self): self.program = program_utils.seedGSoCProgram() # An organization which has all its slots allocated. self.foo_organization = org_utils.seedSOCOrganization( self.program.key(), slot_allocation=2) self.foo_proposals = [] for _ in range(2): student = profile_utils.seedNDBStudent(self.program) self.foo_proposals.append( proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.foo_organization.key, status=proposal_model.STATUS_ACCEPTED)) # Create an organization which has slots to be allocated. We create both # rejected and accepted proposals for this organization entity. self.bar_organization = org_utils.seedSOCOrganization( self.program.key(), slot_allocation=5) # Create some already accepted proposals for bar_organization. self.bar_accepted_proposals = [] for _ in range(2): student = profile_utils.seedNDBStudent(self.program) self.bar_accepted_proposals.append( proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.bar_organization.key, status=proposal_model.STATUS_ACCEPTED)) # proposals which are yet to be accepted. self.bar_to_be_accepted_proposals = [] for _ in range(3): student = profile_utils.seedNDBStudent(self.program) self.bar_to_be_accepted_proposals.append( proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.bar_organization.key, accept_as_project=True, status=proposal_model.STATUS_PENDING)) # proposals which were rejected. self.bar_rejected_proposals = [] for _ in range(3): student = profile_utils.seedNDBStudent(self.program) self.bar_rejected_proposals.append( proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.bar_organization.key, accept_as_project=False, status=proposal_model.STATUS_PENDING)) # Create an organization for which the accepted proposals are more than # the available slots. self.happy_organization = org_utils.seedSOCOrganization( self.program.key(), slot_allocation=1) self.happy_accepted_proposals = [] self.happy_accepted_proposals.append( proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.happy_organization.key, score=2, status=proposal_model.STATUS_PENDING, accept_as_project=True)) self.happy_accepted_proposals.append( proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.happy_organization.key, score=5, status=proposal_model.STATUS_PENDING, accept_as_project=True))
def setUp(self): # seed a new program self.program = program_utils.seedGSoCProgram() # seed a new organization self.org = org_utils.seedSOCOrganization(self.program.key()) # create a new profile and make it a student self.student = profile_utils.seedNDBStudent(self.program) # seed a new proposal and assign self.proposal = proposal_utils.seedProposal(self.student.key, self.program.key(), org_key=self.org.key)
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 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 testAcceptTwoProposalsForStudent(self): # seed another proposal proposal_two = proposal_utils.seedProposal( self.student.key, self.program.key(), org_key=self.organization.key, mentor_key=self.mentor.key, accept_as_project=True, abstract='test abstract') # accept both proposals proposal_logic.acceptProposal(self.proposal) proposal_logic.acceptProposal(proposal_two) # student info should reflect that student = self.student.key.get() self.assertEqual(student.student_data.number_of_projects, 2) self.assertListEqual( student.student_data.project_for_orgs, [self.organization.key])
def testCannotWithdrawAcceptedOrRejectedProposal(self): proposal = proposal_utils.seedProposal( self.student.key, self.program.key(), status=proposal_model.STATUS_ACCEPTED) can_withdraw = proposal_logic.canProposalBeWithdrawn(proposal) # it is not possible to withdraw already accepted proposals self.assertFalse(can_withdraw) proposal.status = proposal_model.STATUS_REJECTED proposal.put() can_withdraw = proposal_logic.canProposalBeWithdrawn(proposal) # it is not possible to withdraw already rejected proposals self.assertFalse(can_withdraw)
def seedProject(student, program_key, proposal_key=None, org_key=None, mentor_key=None, **kwargs): """Seeds a new project entity. Args: student: Profile entity of the student who is an author of the project. program_key: Key of the program to which the project applies. proposal_key: Key of the proposal corresponding to the project. org_key: Key of the organization to which the project is submitted. mentor_key: Key of the mentor assigned to the project. Returns: The newly seeded project entity. """ org_key = org_key or org_utils.seedSOCOrganization(program_key).key mentor_key = mentor_key or profile_utils.seedNDBProfile( program_key, mentor_for=[org_key]).key proposal_key = proposal_key or proposal_utils.seedProposal( student.key, program_key, org_key=org_key, mentor_key=mentor_key).key() properties = { 'program': program_key, 'org': org_key.to_old_key(), 'status': project_model.STATUS_ACCEPTED, 'parent': student.key.to_old_key(), 'mentors': [mentor_key.to_old_key()], 'proposal': proposal_key, 'title': TEST_TITLE, 'abstract': TEST_ABSTRACT, } properties.update(**kwargs) project = project_model.GSoCProject(**properties) project.put() student.student_data.number_of_projects += 1 student.student_data.project_for_orgs.append(org_key) student.student_data.project_for_orgs = list( set(student.student_data.project_for_orgs)) student.put() return project
def testProposalExists(self): """Tests that proposal is returned correctly if exists.""" sponsor = program_utils.seedSponsor() program = program_utils.seedProgram(sponsor_key=sponsor.key()) profile = profile_utils.seedSOCStudent(program) proposal = proposal_utils.seedProposal(profile.key, program.key()) kwargs = { 'sponsor': sponsor.link_id, 'program': program.program_id, 'user': profile.profile_id, 'id': str(proposal.key().id()) } data = request_data.RequestData(None, None, kwargs) url_proposal = data.url_proposal self.assertEqual(proposal.key(), url_proposal.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 setUp(self): # seed a new program self.program = program_utils.seedGSoCProgram() # seed a new organizations self.organization = org_utils.seedSOCOrganization(self.program.key()) # seed a new profile and make it a student self.student = profile_utils.seedNDBStudent(self.program) # seed another profile and make it a mentor self.mentor = profile_utils.seedNDBProfile( self.program.key(), mentor_for=[self.organization.key]) # seed a new proposal and assign the mentor self.proposal = proposal_utils.seedProposal( self.student.key, self.program.key(), org_key=self.organization.key, mentor_key=self.mentor.key, accept_as_project=True, abstract='test abstract')
def testAcceptTwoProposalsForStudent(self): # seed another proposal proposal_two = proposal_utils.seedProposal( self.student.key, self.program.key(), org_key=self.organization.key, mentor_key=self.mentor.key, accept_as_project=True, abstract='test abstract') # accept both proposals proposal_logic.acceptProposal(self.proposal) proposal_logic.acceptProposal(proposal_two) # student info should reflect that student = self.student.key.get() self.assertEqual(student.student_data.number_of_projects, 2) self.assertListEqual(student.student_data.project_for_orgs, [self.organization.key])
def seedProject( student, program_key, proposal_key=None, org_key=None, mentor_key=None, **kwargs): """Seeds a new project entity. Args: student: Profile entity of the student who is an author of the project. program_key: Key of the program to which the project applies. proposal_key: Key of the proposal corresponding to the project. org_key: Key of the organization to which the project is submitted. mentor_key: Key of the mentor assigned to the project. Returns: The newly seeded project entity. """ org_key = org_key or org_utils.seedSOCOrganization(program_key).key mentor_key = mentor_key or profile_utils.seedNDBProfile( program_key, mentor_for=[org_key]).key proposal_key = proposal_key or proposal_utils.seedProposal( student.key, program_key, org_key=org_key, mentor_key=mentor_key).key() properties = { 'program': program_key, 'org': org_key.to_old_key(), 'status': project_model.STATUS_ACCEPTED, 'parent': student.key.to_old_key(), 'mentors': [mentor_key.to_old_key()], 'proposal': proposal_key, 'title': TEST_TITLE, 'abstract': TEST_ABSTRACT, } properties.update(**kwargs) project = project_model.GSoCProject(**properties) project.put() student.student_data.number_of_projects += 1 student.student_data.project_for_orgs.append(org_key) student.student_data.project_for_orgs = list( set(student.student_data.project_for_orgs)) student.put() return project
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 testPubliclyVisibleButton(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) student = profile_utils.seedSOCStudent(self.program, user=user) proposal = proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.org.key) suffix = "%s/%s/%d" % (self.gsoc.key().name(), user.key.id(), proposal.key().id()) url = '/gsoc/proposal/publicly_visible/' + suffix postdata = {'value': 'unchecked'} response = self.post(url, postdata) self.assertResponseOK(response) proposal = GSoCProposal.get(proposal.key()) self.assertTrue(proposal.is_publicly_visible)
def setUp(self): sponsor = program_utils.seedSponsor() # seed a timeline and set student app period for now self.timeline = program_utils.seedTimeline( models=types.SOC_MODELS, timeline_id=TEST_PROGRAM_ID, sponsor_key=sponsor.key(), student_signup_start=timeline_utils.past(), student_signup_end=timeline_utils.future(delta=50), accepted_students_announced_deadline=timeline_utils.future(delta=75)) self.program = program_utils.seedGSoCProgram( program_id=TEST_PROGRAM_ID, sponsor_key=sponsor.key(), timeline_key=self.timeline.key(), app_tasks_limit=3) # seed a new student info self.student = profile_utils.seedNDBStudent(self.program) # seed a new proposal self.proposal = proposal_utils.seedProposal( self.student.key, self.program.key(), status=proposal_model.STATUS_WITHDRAWN)
def testPubliclyVisibleButton(self): user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) student = profile_utils.seedSOCStudent(self.program, user=user) proposal = proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.org.key) suffix = "%s/%s/%d" % ( self.gsoc.key().name(), user.key.id(), proposal.key().id()) url = '/gsoc/proposal/publicly_visible/' + suffix postdata = {'value': 'unchecked'} response = self.post(url, postdata) self.assertResponseOK(response) proposal = GSoCProposal.get(proposal.key()) self.assertTrue(proposal.is_publicly_visible)
def testAcceptProposalButton(self): student = profile_utils.seedSOCStudent(self.program) proposal = proposal_utils.seedProposal(student.key, self.program.key(), org_key=self.org.key) suffix = "%s/%s/%d" % (self.gsoc.key().name(), student.key.parent().id(), proposal.key().id()) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user, mentor_for=[self.org.key]) url = '/gsoc/proposal/accept/' + suffix postdata = {'value': 'unchecked'} response = self.post(url, postdata) # fail if mentor tries to accept the proposal self.assertResponseForbidden(response) proposal = GSoCProposal.get(proposal.key()) self.assertFalse(proposal.accept_as_project) # accept the proposal as project when the org admin tries to accept # the proposal user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user, admin_for=[self.org.key]) response = self.post(url, postdata) self.assertResponseOK(response) proposal = GSoCProposal.get(proposal.key()) self.assertTrue(proposal.accept_as_project)
def testIgnoreProposalButton(self): student = profile_utils.seedSOCStudent(self.program) proposal = proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.org.key) suffix = "%s/%s/%d" % ( self.gsoc.key().name(), student.profile_id, proposal.key().id()) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[self.org.key]) url = '/gsoc/proposal/ignore/' + suffix postdata = {'value': 'unchecked'} response = self.post(url, postdata) self.assertResponseForbidden(response) proposal = GSoCProposal.all().get() self.assertNotEqual(proposal.status, 'ignored')
def testProposalModificationButton(self): student = profile_utils.seedSOCStudent(self.program) proposal = proposal_utils.seedProposal( student.key, self.program.key(), org_key=self.org.key) suffix = "%s/%s/%d" % ( self.gsoc.key().name(), student.key.parent().id(), proposal.key().id()) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, mentor_for=[self.org.key]) url = '/gsoc/proposal/modification/' + suffix postdata = {'value': 'unchecked'} response = self.post(url, postdata) self.assertResponseOK(response) proposal = GSoCProposal.get(proposal.key()) self.assertTrue(proposal.is_editable_post_deadline)