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 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 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 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):
"""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 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 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 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 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 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)
