def testNoProjectData(self):
"""Tests that error is raised if there is no project data in kwargs."""
# no data at all
data = request_data.RequestData(None, None, {})
with self.assertRaises(exception.UserError) as context:
data.url_project
self.assertEqual(context.exception.status, httplib.BAD_REQUEST)
# program data and project id but no user identifier
kwargs = {'sponsor': 'sponsor_id', 'program': 'program_id', 'id': '1'}
data = request_data.RequestData(None, None, kwargs)
with self.assertRaises(exception.UserError) as context:
data.url_project
self.assertEqual(context.exception.status, httplib.BAD_REQUEST)
# user identifier and project id present but no program data
kwargs = {'user': '******', 'id': '1'}
data = request_data.RequestData(None, None, kwargs)
with self.assertRaises(exception.UserError) as context:
data.url_project
self.assertEqual(context.exception.status, httplib.BAD_REQUEST)
# no project id
kwargs = {
'sponsor': 'sponsor_id',
'program': 'program_id',
'user': '******'
}
data = request_data.RequestData(None, None, kwargs)
with self.assertRaises(exception.UserError) as context:
data.url_project
self.assertEqual(context.exception.status, httplib.BAD_REQUEST)
def testResubmitProposal(self):
"""Tests that a proposal is successfully resubmitted if possible."""
old_number_of_proposals = self.profile.student_data.number_of_proposals
self.kwargs = {
'sponsor': self.sponsor.link_id,
'program': self.program.program_id,
'user': self.profile.profile_id,
'id': self.proposal.key().id()
}
request = http.HttpRequest()
data = request_data.RequestData(request, None, self.kwargs)
handler = proposal_review_view.ResubmitProposalHandler(None)
with mock.patch.object(proposal_logic,
'canProposalBeResubmitted',
return_value=True):
response = handler.handle(data, None, None)
self.assertEqual(response.status_code, httplib.OK)
# check that the proposal is withdrawn
proposal = GSoCProposal.all().get()
self.assertEqual(proposal.status, proposal_model.STATUS_PENDING)
# check that number of proposals is updated
profile = self.profile.key.get()
self.assertEqual(old_number_of_proposals,
profile.student_data.number_of_proposals - 1)
def testEmailIsSent(self):
"""Tests that acceptance and rejection emails are sent."""
# seed a couple of organization administrators for both organizations
addresses_for_accept_email = []
addresses_for_reject_email = []
for _ in range(_NUMBER_OF_ORG_ADMINS):
profile = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.pre_accepted_org.key])
addresses_for_accept_email.append(profile.contact.email)
profile = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.pre_rejected_org.key])
addresses_for_reject_email.append(profile.contact.email)
# finalize decision and execute all MapReduce jobs
kwargs = {
'sponsor': self.sponsor.key().name(),
'program': self.program.program_id,
}
request = http.HttpRequest()
data = request_data.RequestData(request, None, kwargs)
handler = org_app_view.ApplyOrgAdmissionDecisionHandler(_MockView())
handler.handle(data, None, None)
self.executeMapReduceJobs()
# check that emails have been sent
for email_address in addresses_for_accept_email:
self.assertEmailSent(bcc=email_address)
for email_address in addresses_for_reject_email:
self.assertEmailSent(bcc=email_address)
def testOrganizationStatusIsUpdated(self):
"""Tests that organization admission decisions are applied correctly."""
kwargs = {
'sponsor': self.sponsor.key().name(),
'program': self.program.program_id,
}
request = http.HttpRequest()
data = request_data.RequestData(request, None, kwargs)
handler = org_app_view.ApplyOrgAdmissionDecisionHandler(_MockView())
handler.handle(data, None, None)
self.executeMapReduceJobs()
# check that status have been changed for pre_accepted and pre_rejected orgs
self.assertEqual(
self.pre_accepted_org.key.get().status, org_model.Status.ACCEPTED)
self.assertEqual(
self.pre_rejected_org.key.get().status, org_model.Status.REJECTED)
# check that status for other orgs have not changed
self.assertEqual(
self.accepted_org.key.get().status, org_model.Status.ACCEPTED)
self.assertEqual(
self.rejected_org.key.get().status, org_model.Status.REJECTED)
self.assertEqual(
self.applying_org.key.get().status, org_model.Status.APPLYING)
def testProjectDoesNotExists(self):
"""Tests that error is raised if requested project does not exist."""
kwargs = {
'sponsor': 'sponsor_id',
'program': 'program_id',
'user': '******',
'id': '1'
}
data = request_data.RequestData(None, None, kwargs)
with self.assertRaises(exception.UserError) as context:
data.url_project
self.assertEqual(context.exception.status, httplib.NOT_FOUND)
def testForLoneUser(self):
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
project = _createProjectForMentor(self.gsoc, self.org, self.dev_test)
kwargs = {
'sponsor': self.sponsor.link_id,
'program': self.program.program_id,
'user': user.user_id,
'id': project.key().id(),
}
data = request_data.RequestData(None, None, kwargs)
self.assertFalse(project_details._isUpdateLinkVisible(data))
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedGSoCProgram(sponsor_key=sponsor.key())
self.organization = org_utils.seedSOCOrganization(program.key())
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
self.profile = profile_utils.seedNDBProfile(program.key(), user=user)
kwargs = {
'sponsor': sponsor.key().name(),
'program': program.program_id,
'organization': self.organization.org_id,
}
self.data = request_data.RequestData(None, None, kwargs)
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 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 initialize(self, request, args, kwargs):
"""See initialize.Initializer.initialize for specification.
Args:
request: An http.HttpRequest object describing the current request.
args: Additional positional arguments passed with the request.
kwargs: Additional keyword arguments passed with the request.
Returns:
A trio of instances of GSoC-specific subclasses of RequestData,
AccessChecker, and Mutator.
"""
data = request_data.RequestData(request, args, kwargs)
mutator = access_checker.Mutator(data)
if data.is_developer:
check = access_checker.DeveloperAccessChecker(data)
else:
check = access_checker.AccessChecker(data)
return data, check, mutator
def testForProjectOrgAdmin(self):
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(self.program.key(),
user=user,
admin_for=[self.org.key])
project = _createProjectForMentor(self.program, 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.assertTrue(project_details._isUpdateLinkVisible(data))
def testCannotResubmitProposal(self):
"""Tests that an error occurs when proposal cannot be withdrawn."""
# proposal cannot be resubmitted, because it is rejected
self.proposal.status = proposal_model.STATUS_REJECTED
self.proposal.put()
self.kwargs = {
'sponsor': self.sponsor.link_id,
'program': self.program.program_id,
'user': self.profile.profile_id,
'id': self.proposal.key().id()
}
request = http.HttpRequest()
data = request_data.RequestData(request, None, self.kwargs)
handler = proposal_review_view.ResubmitProposalHandler(None)
with mock.patch.object(proposal_logic,
'canProposalBeResubmitted',
return_value=False):
with self.assertRaises(exception.UserError) as context:
handler.handle(data, None, None)
self.assertEqual(context.exception.status, httplib.FORBIDDEN)
def testForHost(self):
data = request_data.RequestData(None, None, None)
data._program = self.program
data._ndb_user = profile_utils.seedNDBUser(host_for=[self.program])
result = project_details._isUpdateLinkVisible(data)
self.assertTrue(result)