def testOrgAppCreateOrEditByMentor(self):
"""Tests that a mentor cannot create an organization application.
"""
# Make sure we do not have an org app for this test.
self.org_app.delete()
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user, mentor_for=[self.org.key])
url = '/gsoc/org/application/edit/' + self.gsoc.key().name()
response = self.get(url)
self.assertResponseForbidden(response)
org_app_key_name = 'gsoc_program/%s/orgapp' % (self.gsoc.key().name(),)
org_app = org_app_survey.OrgAppSurvey.get_by_key_name(org_app_key_name)
self.assertIsNone(org_app)
response = self.post(url, self.getOrgAppCreatePostData())
self.assertResponseForbidden(response)
org_app = org_app_survey.OrgAppSurvey.get_by_key_name(org_app_key_name)
self.assertIsNone(org_app)
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 testPostButtonExtendDeadline(self):
"""Tests the extend deadline button."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user,
mentor_for=[ndb.Key.from_old_key(self.org.key())])
student = profile_utils.seedNDBStudent(self.program)
# set it in the future so that the auto state transfer doesn't trigger
deadline = datetime.datetime.utcnow() + datetime.timedelta(hours=24)
self.task.status = 'Claimed'
self.task.student = student.key.to_old_key()
self.task.deadline = deadline
self.task.put()
url = _taskPageURL(self.task)
response = self.buttonPost(
url, 'button_extend_deadline', {'hours': 1})
task = task_model.GCITask.get(self.task.key())
self.assertResponseRedirect(response)
delta = task.deadline - deadline
self.assertTrue(delta.seconds == 3600)
# check if a comment has been created
comments = self.task.comments()
self.assertEqual(len(comments), 1)
self.assertMailSentToSubscribers(comments[0])
self.assertBasicTaskView()
def testPostButtonNeedsWork(self):
"""Tests the needs more work for task button."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user,
mentor_for=[ndb.Key.from_old_key(self.org.key())])
student = profile_utils.seedNDBStudent(self.program)
self.task.status = 'NeedsReview'
self.task.student = student.key.to_old_key()
self.task.put()
url = _taskPageURL(self.task)
response = self.buttonPost(url, 'button_needs_work')
# check if the task is properly closed
task = task_model.GCITask.get(self.task.key())
self.assertResponseRedirect(response)
self.assertEqual(task.status, 'NeedsWork')
self.assertEqual(
task_model.GCITask.student.get_value_for_datastore(task),
student.key.to_old_key())
self.assertIsNone(task.deadline)
# check if a comment has been created
comments = self.task.comments()
self.assertEqual(len(comments), 1)
self.assertMailSentToSubscribers(comments[0])
self.assertBasicTaskView()
def testPostButtonUnassign(self):
"""Tests the unassign button."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user,
mentor_for=[ndb.Key.from_old_key(self.org.key())])
student = profile_utils.seedNDBStudent(self.program)
self.task.status = 'Claimed'
self.task.student = student.key.to_old_key()
self.task.put()
url = _taskPageURL(self.task)
response = self.buttonPost(url, 'button_unassign')
# check if the task is properly unassigned
task = task_model.GCITask.get(self.task.key())
self.assertResponseRedirect(response)
self.assertEqual(task.status, task_model.REOPENED)
self.assertIsNone(task.student)
self.assertIsNone(task.deadline)
# check if a comment has been created
comments = self.task.comments()
self.assertEqual(len(comments), 1)
self.assertMailSentToSubscribers(comments[0])
self.assertBasicTaskView()
def testAccessToTheList(self):
"""Tests only the host can access the list."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBStudent(self.program, user=user)
response = self.get(self.url)
self.assertResponseForbidden(response)
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user,
mentor_for=[ndb.Key.from_old_key(self.org.key())])
response = self.get(self.url)
self.assertResponseForbidden(response)
# check for an organization administrator
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user,
admin_for=[ndb.Key.from_old_key(self.org.key())])
response = self.get(self.url)
self.assertResponseForbidden(response)
user = profile_utils.seedNDBUser(host_for=[self.program])
profile_utils.loginNDB(user)
response = self.get(self.url)
self.assertResponseOK(response)
def testPostButtonAssign(self):
"""Tests the assign button."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user,
mentor_for=[ndb.Key.from_old_key(self.org.key())])
student = profile_utils.seedNDBStudent(self.program)
self.task.status = 'ClaimRequested'
self.task.student = student.key.to_old_key()
self.task.put()
url = _taskPageURL(self.task)
response = self.buttonPost(url, 'button_assign')
# check if the task is properly assigned and a deadline has been set
task = task_model.GCITask.get(self.task.key())
self.assertResponseRedirect(response)
self.assertEqual(task.status, 'Claimed')
self.assertEqual(
task_model.GCITask.student.get_value_for_datastore(task),
student.key.to_old_key())
self.assertTrue(task.deadline)
# check if a comment has been created
comments = self.task.comments()
self.assertEqual(len(comments), 1)
self.assertMailSentToSubscribers(comments[0])
# check if the update task has been enqueued
self.assertTasksInQueue(n=1, url=_taskUpdateURL(task))
self.assertBasicTaskView()
def testForNonStudentProfile(self):
"""Tests that True is returned if a non-student profile exists."""
# seed a non-student profile
profile_utils.seedNDBProfile(self.program.key(), user=self.user)
result = validate.hasNonStudentProfileForProgram(
self.user.key, self.program.key())
self.assertTrue(result)
def testPageLoads(self):
"""Tests that the page loads properly."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(self.program.key(), user=user)
response = self.get(_getPickOrganizationToConnectUrl(self.program))
self.assertResponseOK(response)
def testUserWithActiveProfileAccessGranted(self):
"""Tests that access is granted if the user has an active profile."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(self.program.key(), user=user)
access_checker = access.HAS_PROFILE_ACCESS_CHECKER
access_checker.checkAccess(self.data, None)
def testUserWithNonStudentProfileAccessGranted(self):
"""Tests that access is granted if current user has non-student profile."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(self.program.key(), user=user)
access_checker = access.NON_STUDENT_PROFILE_ACCESS_CHECKER
access_checker.checkAccess(self.data, None)
def testPageLoads(self):
"""Tests that page loads properly."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(self.program.key(), user=user)
response = self.get(_getOrgProfileCreateUrl(self.program))
self.assertResponseOK(response)
def testPageLoads(self):
"""Tests that the page loads properly."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(self.program.key(), user=user)
response = self.get(_getNotificationSettingsUrl(self.program.key()))
self.assertResponseOK(response)
def testOrgAdminAccessForbidden(self):
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user, admin_for=[self.org.key])
self._assertAccessForbiddenForUrl(self._getEnrollmentFormUrl())
self._assertAccessForbiddenForUrl(self._getTaxFormUrl())
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
program = program_utils.seedProgram()
profile = profile_utils.seedNDBProfile(program.key())
org = org_utils.seedOrganization(program.key())
self.connection = connection_utils.seed_new_connection(profile.key, org.key)
self.org_admin = profile_utils.seedNDBProfile(
program.key(), admin_for=[org.key])
def testAccessForbidden(self):
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user, mentor_for=[self.org.key])
url = '/gsoc/program/create/' + self.sponsor.key().name()
response = self.get(url)
self.assertErrorTemplatesUsed(response)
def testPageLoads(self):
"""Tests that page loads properly."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user, admin_for=[self.org.key])
response = self.get(_getManageAsOrgUrl(self.connection))
self.assertResponseOK(response)
def testPageLoads(self):
"""Tests that page loads properly."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(self.program.key(), user=user)
response = self.get(_getListForUserUrl(self.program))
self.assertResponseOK(response)
self._assertPageTemplatesUsed(response)
def testGetMethodForbidden(self):
"""Tests that GET method is not permitted."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user, admin_for=[self.org.key])
response = self.get(_getMarkAsSeenByOrgUrl(self.connection))
self.assertResponseForbidden(response)
def testMentorAccessForbidden(self):
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user, mentor_for=[self.org.key])
response = self.get(self.url)
self.assertResponseForbidden(response)
self.assertErrorTemplatesUsed(response)
def testPostMethodNotAllowed(self):
"""Tests that POST method is not permitted."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user, admin_for=[self.org.key])
response = self.post(_getOrgSurveyResponseShowUrl(self.org))
self.assertResponseMethodNotAllowed(response)
def testPageLoads(self):
"""Tests that the page loads properly."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(self.program.key(), user=user, admin_for=[ndb.Key.from_old_key(self.org.key())])
self.timeline_helper.allWorkReviewed()
response = self.get(_getProposeWinnersPageUrl(self.org.key()))
self.assertResponseOK(response)
def testPageLoads(self):
"""Tests that page loads properly."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user, admin_for=[self.org.key])
response = self.get(_getOrgPreferencesEditUrl(self.org))
self.assertResponseOK(response)
def testOrgAdminAccessDenied(self):
"""Tests that org admins cannot access the page."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user, admin_for=[self.org.key])
response = self.get(self._getUrl())
self.assertResponseForbidden(response)
def testForNonActiveProfile(self):
"""Tests that False is returned if a profile is not active."""
# seed a non-student, banned profile
profile_utils.seedNDBProfile(
self.program.key(), user=self.user, status=profile_model.Status.BANNED)
result = validate.hasNonStudentProfileForProgram(
self.user.key, self.program.key())
self.assertFalse(result)
def testDashboardAsLoneUser(self):
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(self.program.key(), user=user)
url = '/gsoc/dashboard/' + self.gsoc.key().name()
response = self.get(url)
self.assertResponseOK(response)
self.assertDashboardTemplatesUsed(response)
def testProfileExists(self):
"""Tests that second profile is not created for same user and program."""
# seed a profile
profile_utils.seedNDBProfile(self.program.key(), user=self.user)
result = profile_logic.createProfile(
self.user.key, self.program.key(), TEST_PROFILE_PROPERTIES)
self.assertFalse(result)
self.assertEqual(result.extra, profile_logic.PROFILE_EXISTS)
def testOrgAdminCannotAccess(self):
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user,
admin_for=[ndb.Key.from_old_key(self.org.key())])
response = self.get(self.url)
self.assertErrorTemplatesUsed(response)
def testOrgAdminAccessForbidden(self):
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user, admin_for=[self.org.key])
url = self._getUrl()
response = self.get(url)
self.assertErrorTemplatesUsed(response)
def testCreateOrg(self):
"""Tests that only the assigned org admin for an organization can edit the
org profile.
"""
self.timeline_helper.orgSignup()
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(self.program.key(), user=user)
# create backup admin for the application
backup_admin = profile_utils.seedNDBProfile(self.program.key())
self.record.createOrgAppRecord(
'new_org', user.key, backup_admin.key.parent())
url = '/gci/profile/organization/' + self.gci.key().name()
create_url = url + '?org_id=new_org'
response = self.get(create_url)
self.assertResponseOK(response)
self.assertOrgProfilePageTemplatesUsed(response)
postdata = {
'home': self.createDocument(user=user).key(), 'program': self.program,
'scope': self.program, 'irc_channel': TEST_IRC_CHANNEL,
'pub_mailing_list': TEST_MAILING_LIST, 'backup_winner': None,
}
response, _ = self.modelPost(create_url, org_model.GCIOrganization,
postdata)
self.assertResponseRedirect(response, url + '/new_org?validated')
# check that a organization is created
key_name = '%s/%s' % (self.program.key().name(), 'new_org')
organization = org_model.GCIOrganization.get_by_key_name(key_name)
self.assertIsNotNone(organization)
self.assertEqual(organization.irc_channel, TEST_IRC_CHANNEL)
self.assertEqual(organization.pub_mailing_list, TEST_MAILING_LIST)
# check that the profile is organization administrator
profile = db.get(self.profile_helper.profile.key())
self.assertEqual(1, len(profile.org_admin_for))
self.assertSameEntity(self.gci, profile.program)
# check that a connection is created for the main admin
connection = connection_model.Connection.all().ancestor(
profile.key()).filter('organization', organization).get()
self.assertIsNotNone(connection)
self.assertEqual(connection.org_role, connection_model.ORG_ADMIN_ROLE)
self.assertEqual(connection.user_role, connection_model.ROLE)
# check that a connection is created for the backup admin
connection = connection_model.Connection.all().ancestor(
backup_admin.key()).filter('organization', organization).get()
self.assertIsNotNone(connection)
self.assertEqual(connection.org_role, connection_model.ORG_ADMIN_ROLE)
self.assertEqual(connection.user_role, connection_model.ROLE)
def testBulkTaskCreateBeforeOrgsAnnouncedForStudent(self):
"""Tests the bulk task create view before the program is
public for students.
"""
self.timeline_helper.orgSignup()
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(),
user=user,
admin_for=[ndb.Key.from_old_key(self.org.key())])
url = '/gci/bulk/' + self.org.key().name()
response = self.get(url)
# Task creation has not started yet
self.assertResponseForbidden(response)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
program = program_utils.seedProgram()
# seed an organization
self.org = org_utils.seedOrganization(program.key())
# seed a profile
self.profile = profile_utils.seedNDBProfile(program.key())
def testFullEditTaskDuringProgramForMentor(self):
"""Tests the task full editing view during the program for mentor."""
self.timeline_helper.tasksPubliclyVisible()
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(),
user=user,
mentor_for=[ndb.Key.from_old_key(self.org.key())])
task = self.createTask('Unpublished')
url = '/gci/task/edit/%s/%s' % (self.gci.key().name(), task.key().id())
response = self.get(url)
self.assertResponseOK(response)
self.assertFullEditTemplatesUsed(response)
def testFullEditTaskDuringProgramForOrgAdmin(self):
"""Tests the task full editing view during the program for org admin."""
self.timeline_helper.tasksPubliclyVisible()
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(),
user=user,
admin_for=[ndb.Key.from_old_key(self.org.key())])
task = self.createTask(status=task_model.REOPENED)
url = '/gci/task/edit/%s/%s' % (self.gci.key().name(), task.key().id())
response = self.get(url)
self.assertResponseOK(response)
self.assertPostClaimEditTemplatesUsed(response)
def testBulkTaskCreateDuringProgramForOrgAdmin(self):
"""Tests the bulk task create view during the program
for org admins.
"""
self.timeline_helper.tasksPubliclyVisible()
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(),
user=user,
admin_for=[ndb.Key.from_old_key(self.org.key())])
url = '/gci/bulk/' + self.org.key().name()
response = self.get(url)
self.assertResponseOK(response)
self.assertFullEditTemplatesUsed(response)
def testBulkTaskCreateAfterClaimEndForMentor(self):
"""Tests the bulk task create view after the task claim deadline
for mentors.
"""
self.timeline_helper.taskClaimEnded()
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(),
user=user,
mentor_for=[ndb.Key.from_old_key(self.org.key())])
url = '/gci/bulk/' + self.org.key().name()
response = self.get(url)
# Task creation is not open
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 testInvalidData(self):
"""Tests that organization is not created if data is not valid."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user, admin_for=[self.org.key])
backup_admin = profile_utils.seedNDBProfile(self.program.key())
# valid set of data
valid_postdata = {
'org_id': TEST_ORG_ID,
'name': TEST_ORG_NAME,
'blog': TEST_BLOG,
'description': TEST_DESCRIPTION,
'facebook': TEST_FACEBOOK,
'feed_url': TEST_FEED_URL,
'google_plus': TEST_GOOGLE_PLUS,
'license': TEST_LICENSE,
'logo_url': TEST_LOGO_URL,
'ideas_page': TEST_IDEAS_PAGE,
'irc_channel': TEST_IRC_CHANNEL,
'backup_admin': backup_admin.profile_id,
'mailing_list': TEST_MAILING_LIST,
'tags': TEST_TAGS,
'twitter': TEST_TWITTER,
'web_page': TEST_WEB_PAGE,
'eligible_country': True
}
# the organization is not from the eligible countries
postdata = valid_postdata.copy()
postdata['eligible_country'] = False
response = self.post(
_getOrgProfileCreateUrl(self.program), postdata=postdata)
self.assertTrue(response.context['error'])
# the organization with the same org_id already exists
org_utils.seedSOCOrganization(self.program.key(), org_id='duplicate')
postdata = valid_postdata.copy()
postdata['org_id'] = 'duplicate'
response = self.post(
_getOrgProfileCreateUrl(self.program), postdata=postdata)
self.assertResponseBadRequest(response)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.init()
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile = profile_utils.seedNDBProfile(self.program.key(), user=user)
self.connection = connection_utils.seed_new_connection(
profile.key, self.org.key, seen_by_user=False)
def testForOrgAdminForAnotherOrg(self):
# seed another organization
organization_two = org_utils.seedSOCOrganization(self.program.key())
profile = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[organization_two.key])
# profile with an org admin role can still become an org admin
can_become = profile_logic.canBecomeOrgAdmin(profile)
self.assertTrue(can_become)
def testPostButtonPublishUnapprovedTask(self):
"""Tests the publish button."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user,
admin_for=[ndb.Key.from_old_key(self.org.key())])
self.task.status = task_model.UNAPPROVED
self.task.put()
url = _taskPageURL(self.task)
response = self.buttonPost(url, 'button_publish')
task = task_model.GCITask.get(self.task.key())
self.assertResponseRedirect(response)
self.assertEqual(task.status, task_model.OPEN)
self.assertBasicTaskView()
def testExtraAttrs(self):
# seed female mentor for organization one
mentor = profile_utils.seedNDBProfile(
self.program.key(), mentor_for=[self.organization_one.key],
gender=profile_model.Gender.FEMALE)
# seed male mentor for organization one
profile_utils.seedNDBProfile(
self.program.key(), mentor_for=[self.organization_one.key],
gender=profile_model.Gender.MALE)
# retrieve only mentors with extra attrs
extra_attrs = {profile_model.Profile.gender: [profile_model.Gender.FEMALE]}
mentors = profile_logic.getMentors(
self.organization_one.key, extra_attrs=extra_attrs)
# only the female mentor should be returned
self.assertEqual(1, len(mentors))
self.assertEqual(mentors[0].key, mentor.key)
def setUp(self):
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed a couple of organizations
self.organization = org_utils.seedSOCOrganization(self.program.key())
# seed a new mentor for organization one
self.mentor = profile_utils.seedNDBProfile(
self.program.key(), mentor_for=[self.organization.key],
gender=profile_model.Gender.FEMALE)
def testMentorAdded(self):
profile = profile_utils.seedNDBProfile(self.program.key())
profile_logic.becomeMentorForOrg(profile, self.organization_one.key)
# the profile should be a mentor for organization one
self.assertTrue(profile.is_mentor)
self.assertIn(self.organization_one.key, profile.mentor_for)
# the profile is not a mentor for organization two
self.assertNotIn(self.organization_two.key, profile.mentor_for)
def testForOrgAdminForTwoOrgs(self):
# seed another org admin for organization
profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.organization.key])
# seed another organization
organization_two = org_utils.seedSOCOrganization(self.program.key())
# make the profile an org admin for organization two
self.org_admin.mentor_for.append(organization_two.key)
self.org_admin.admin_for.append(organization_two.key)
profile_logic.resignAsOrgAdminForOrg(self.org_admin, self.organization.key)
# the profile is not an org admin for organization anymore
self.assertNotIn(self.organization.key, self.org_admin.admin_for)
# the profile should still be an org admin for organization two
self.assertTrue(self.org_admin.is_admin)
self.assertIn(organization_two.key, self.org_admin.admin_for)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
# seed a program
self.program_key = seeder_logic.seed(program_model.Program).key()
# seed a user
self.user = profile_utils.seedNDBUser(user_id='test')
# seed a profile
self.profile = profile_utils.seedNDBProfile(
self.program_key, user=self.user)
def testOrgAdminForAnotherOrgAdded(self):
profile = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.organization_two.key])
profile_logic.becomeOrgAdminForOrg(profile, self.organization_one.key)
# profile should become org admin for organization one
self._assertOrgAdmin(profile, self.organization_one)
# profile should still be an org admin for organization two
self._assertOrgAdmin(profile, self.organization_two)
def testFullEditTaskBeforeOrgsAnnouncedForOrgAdmin(self):
"""Tests the task full editing view before the program is public
for org admin.
"""
self.timeline_helper.orgSignup()
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(),
user=user,
admin_for=[ndb.Key.from_old_key(self.org.key())])
task = self.createTask()
url = '/gci/task/edit/%s/%s' % (self.gci.key().name(), task.key().id())
response = self.get(url)
# Task full editing has not started yet
self.assertResponseForbidden(response)
def testPostClaimEditTaskBeforeOrgsAnnouncedForMentor(self):
"""Tests the task post claim editing view before the program is public
for mentor.
"""
self.timeline_helper.orgSignup()
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(),
user=user,
mentor_for=[ndb.Key.from_old_key(self.org.key())])
task = self.createTask(status='ActionNeeded')
url = '/gci/task/edit/%s/%s' % (self.gci.key().name(), task.key().id())
response = self.get(url)
# Task post claim editing has not started yet
self.assertResponseForbidden(response)
def testForOtherMentor(self):
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(self.program.key(),
user=user,
mentor_for=[self.org.key])
project = _createProjectForMentor(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 testPostClaimEditTaskAfterClaimEndForMentor(self):
"""Tests the task post claim editing view after the task claim deadline
for mentor.
"""
self.timeline_helper.taskClaimEnded()
task = self.createTask(status='Claimed')
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(),
user=user,
admin_for=[ndb.Key.from_old_key(self.org.key())])
url = '/gci/task/edit/%s/%s' % (self.gci.key().name(), task.key().id())
response = self.get(url)
# Task post claim editing has not started yet
self.assertResponseForbidden(response)
def setUp(self):
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed a couple of organizations
self.organization = org_utils.seedSOCOrganization(self.program.key())
org_utils.seedSOCOrganization(self.program.key())
# seed a new org admin for organization
self.org_admin = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.organization.key])
def setUp(self):
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed a couple of organizations
self.organization_one = org_utils.seedSOCOrganization(self.program.key())
self.organization_two = org_utils.seedSOCOrganization(self.program.key())
# seed a new mentor for organization one
self.mentor = profile_utils.seedNDBProfile(
self.program.key(), mentor_for=[self.organization_one.key])
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 testPageLoads(self):
"""Tests that page loads properly."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile = profile_utils.seedNDBProfile(self.program.key(),
user=user,
admin_for=[self.org.key])
url = _getListConnectionsForOrgAdminUrl(profile)
response = self.get(url)
self.assertResponseOK(response)
def testPostComment(self):
"""Tests leaving a comment on a task."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user,
mentor_for=[ndb.Key.from_old_key(self.org.key())])
no_comments = self.task.comments()
self.assertEqual(len(no_comments), 0)
comment_title = 'Test Comment Title'
comment_content = 'Test Comment Content'
comment_data = {
'title': comment_title,
'content': comment_content,
}
url = '%s?reply' % _taskPageURL(self.task)
response = self.post(url, comment_data)
self.assertResponseRedirect(response)
one_comment = self.task.comments()
self.assertEqual(len(one_comment), 1)
comment = one_comment[0]
self.assertEqual(comment_title, comment.title)
self.assertEqual(comment_content, comment.content)
self.assertEqual(
user.key.to_old_key(),
comment_model.GCIComment.created_by.get_value_for_datastore(comment))
self.assertEqual(
user.key.to_old_key(),
comment_model.GCIComment.modified_by.get_value_for_datastore(comment))
self.assertEqual(self.task.key(), comment.parent_key())
self.assertIsNone(comment.reply)
self.assertMailSentToSubscribers(comment)
self.assertBasicTaskView()
def setUp(self):
super(SurveyRemindersTest, self).setUp()
self.init()
self.mentor = profile_utils.seedNDBProfile(
self.program.key(), mentor_for=[self.org.key])
self.student = profile_utils.seedNDBStudent(self.program)
self.project = project_utils.seedProject(
self.student, self.program.key(), org_key=self.org.key,
mentor_key=self.mentor.key)
self.createSurveys()
def testConnectionDoesNotExist(self):
"""Tests that False is returned if connection does not exist."""
# seed a connection between the org and another profile
other_profile = profile_utils.seedNDBProfile(self.program.key())
connection_utils.seed_new_connection(other_profile.key, self.org.key)
# seed a connection between the profile and another org
other_org = org_utils.seedOrganization(self.program.key())
connection_utils.seed_new_connection(self.profile.key, other_org.key)
self.assertFalse(
connection_logic.connectionExists(self.profile.key, self.org.key))
def testPostButtonUnpublishReopenedTaskForbidden(self):
"""Tests the unpublish button on."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user,
admin_for=[ndb.Key.from_old_key(self.org.key())])
url = _taskPageURL(self.task)
# try to unpublish a reopened task
task = task_model.GCITask.get(self.task.key())
task.status = task_model.REOPENED
task.put()
response = self.buttonPost(url, 'button_unpublish')
task = task_model.GCITask.get(self.task.key())
self.assertResponseForbidden(response)
self.assertEqual(task.status, task_model.REOPENED)
def testPostButtonUnpublish(self):
"""Tests the unpublish button."""
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
self.program.key(), user=user,
admin_for=[ndb.Key.from_old_key(self.org.key())])
url = _taskPageURL(self.task)
response = self.buttonPost(url, 'button_unpublish')
task = task_model.GCITask.get(self.task.key())
self.assertResponseRedirect(response)
self.assertEqual(task.status, 'Unpublished')
# check if a comment has been created
comments = self.task.comments()
self.assertEqual(len(comments), 1)
self.assertMailSentToSubscribers(comments[0])
self.assertBasicTaskView()
