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 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 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 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 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 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 _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 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)
