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 setUp(self):
"""See unittest.setUp for specification."""
sponsor = program_utils.seedSponsor()
self.program = program_utils.seedProgram(sponsor_key=sponsor.key())
self.kwargs = {
'sponsor': sponsor.key().name(),
'program': self.program.program_id,
}
def setUp(self):
"""See unittest.setUp for specification."""
sponsor = program_utils.seedSponsor()
self.program = program_utils.seedProgram(sponsor_key=sponsor.key())
self.kwargs = {
'sponsor': sponsor.key().name(),
'program': self.program.program_id,
}
def setUp(self):
sponsor = program_utils.seedSponsor()
program = program_utils.seedGSoCProgram(sponsor_key=sponsor.key())
org_app = program_utils.seedApplicationSurvey(program.key())
timeline_test_helper = timeline_utils.GSoCTimelineHelper(
program.timeline, org_app)
timeline_test_helper.orgSignup()
self.timeline_helper = request_data.TimelineHelper(
program.timeline, org_app)
def setUp(self):
sponsor = program_utils.seedSponsor()
program = program_utils.seedGSoCProgram(sponsor_key=sponsor.key())
org_app = program_utils.seedApplicationSurvey(program.key())
timeline_test_helper = timeline_utils.GSoCTimelineHelper(
program.timeline, org_app)
timeline_test_helper.orgSignup()
self.timeline_helper = request_data.TimelineHelper(
program.timeline, org_app)
def init(self):
"""Performs test set-up by seeding data and setting attributes."""
super(GSoCTestCase, self).init()
self.sponsor = program_utils.seedSponsor()
self.program = self.gsoc = program_utils.seedGSoCProgram(sponsor_key=self.sponsor.key())
self.program_helper = program_utils.GSoCProgramHelper(sponsor=self.sponsor, program=self.program)
self.site = program_utils.seedSite(active_program=self.program)
self.org = self.program_helper.createOrg()
self.org_app = self.program_helper.createOrgApp()
self.timeline_helper = timeline_utils.GSoCTimelineHelper(self.gsoc.timeline, self.org_app)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
sponsor = program_utils.seedSponsor()
self.program = program_utils.seedProgram(sponsor_key=sponsor.key())
kwargs = {
'sponsor': sponsor.key().name(),
'program': self.program.program_id,
}
self.data = request_data.RequestData(None, None, kwargs)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
sponsor = program_utils.seedSponsor()
self.program = program_utils.seedProgram(sponsor_key=sponsor.key())
kwargs = {
'sponsor': sponsor.key().name(),
'program': self.program.program_id
}
self.data = request_data.RequestData(None, None, kwargs)
def createGCIProgram(self):
"""Create GCI Program."""
self.program_helper = program_utils.GCIProgramHelper()
self.gci = self.program = self.program_helper.createProgram(override={'name':'Google Code In',
'short_name':'gci'})
self.program = self.gci.key().name()
self.org = self.program_helper.createOrg()
self.org_app = self.program_helper.createOrgApp()
self.user = profile_utils.seedNDBProfile(self.gci.key())
self.sponsor = program_utils.seedSponsor(sponsor_id='google')
self.site = program_utils.seedSite(latest_gci=self.sponsor.key().name() + '/' + self.program, active_program=self.gci)
def init(self):
"""Performs test set-up by seeding data and setting attributes."""
super(GSoCTestCase, self).init()
self.sponsor = program_utils.seedSponsor()
self.program = self.gsoc = program_utils.seedGSoCProgram(
sponsor_key=self.sponsor.key())
self.program_helper = program_utils.GSoCProgramHelper(
sponsor=self.sponsor, program=self.program)
self.site = program_utils.seedSite(active_program=self.program)
self.org = self.program_helper.createOrg()
self.org_app = self.program_helper.createOrgApp()
self.timeline_helper = timeline_utils.GSoCTimelineHelper(
self.gsoc.timeline, self.org_app)
def testProfileExists(self):
"""Tests that profile is returned correctly if exists."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
profile = profile_utils.seedNDBProfile(program.key())
kwargs = {
'sponsor': sponsor.link_id,
'program': program.program_id,
'user': profile.profile_id,
}
data = request_data.RequestData(None, None, kwargs)
url_profile = data.url_ndb_profile
self.assertEqual(profile.key, url_profile.key)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.sponsor = program_utils.seedSponsor()
self.program = program_utils.seedProgram(sponsor_key=self.sponsor.key())
# seed a user who will be tested for access
self.user = profile_utils.seedNDBUser()
profile_utils.loginNDB(self.user)
kwargs = {
'sponsor': self.sponsor.key().name(),
'program': self.program.program_id,
}
self.data = request_data.RequestData(None, None, kwargs)
def testForNonHostUser(self):
"""Tests that False is returned for a user who is not a host."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
kwargs = {
'sponsor': sponsor.link_id,
'program': program.program_id,
}
data = request_data.RequestData(None, None, kwargs)
is_host = data.is_host
self.assertFalse(is_host)
def testProfileExists(self):
"""Tests that profile is returned correctly if exists."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
profile = profile_utils.seedNDBProfile(program.key())
kwargs = {
'sponsor': sponsor.link_id,
'program': program.program_id,
'user': profile.profile_id,
}
data = request_data.RequestData(None, None, kwargs)
url_profile = data.url_ndb_profile
self.assertEqual(profile.key, url_profile.key)
def testForNonHostUser(self):
"""Tests that False is returned for a user who is not a host."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
kwargs = {
'sponsor': sponsor.link_id,
'program': program.program_id,
}
data = request_data.RequestData(None, None, kwargs)
is_host = data.is_host
self.assertFalse(is_host)
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())
self.program = program_utils.seedGSoCProgram(
program_id=TEST_PROGRAM_ID, sponsor_key=sponsor.key(),
timeline_key=self.timeline.key(), app_tasks_limit=3)
self.student = profile_utils.seedNDBStudent(self.program)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.sponsor = program_utils.seedSponsor()
self.program = program_utils.seedProgram(
sponsor_key=self.sponsor.key())
# seed a user who will be tested for access
self.user = profile_utils.seedNDBUser()
profile_utils.loginNDB(self.user)
kwargs = {
'sponsor': self.sponsor.key().name(),
'program': self.program.program_id,
}
self.data = request_data.RequestData(None, None, kwargs)
def createGSoCProgram(self):
"""Create GSoC Program."""
self.program_helper = program_utils.GSoCProgramHelper()
self.gsoc = self.program_helper.createProgram(override={
'name': 'Google Summer of Code',
'short_name': 'gsoc'
})
self.program = self.gsoc.key().name()
self.org = self.program_helper.createOrg()
self.org_app = self.program_helper.createOrgApp()
self.user = profile_utils.seedNDBProfile(self.gsoc.key())
self.sponsor = program_utils.seedSponsor(sponsor_id='google')
self.site = program_utils.seedSite(
latest_gsoc=self.sponsor.key().name() + '/' + self.program,
active_program=self.gsoc)
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 setUp(self):
"""See unittest.TestCase.setUp for specification."""
# seed two programs for the same sponsor
sponsor = program_utils.seedSponsor()
self.program_one = program_utils.seedProgram(sponsor_key=sponsor.key())
program_two = program_utils.seedProgram(sponsor_key=sponsor.key())
org_one = org_utils.seedOrganization(self.program_one.key())
org_two = org_utils.seedOrganization(program_two.key())
self.mentor_keys = set()
# seed a few mentors for both programs
for _ in range(_NUMBER_OF_MENTORS):
self.mentor_keys.add(profile_utils.seedNDBProfile(
self.program_one.key(), mentor_for=[org_one.key]).key)
profile_utils.seedNDBProfile(program_two.key(), mentor_for=[org_two.key])
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 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 setUp(self):
"""Setup required to test the functions.
Two different program entities are created with their own set of students
assigned to them. Some of the students in each program have duplicate
proposals and some not.
"""
sponsor = program_utils.seedSponsor()
self.program1 = program_utils.seedGSoCProgram(sponsor_key=sponsor.key())
#Create GSoCStudents in program1
self.gsoc_students = []
for _ in xrange(5):
student = profile_utils.seedNDBStudent(self.program1)
self.gsoc_students.append(student)
#Create a GSoCProposalDuplicate entity for all the students
#in self.gsoc_students for program1.
self.proposal_duplicates = []
for student in self.gsoc_students:
proposal_duplicate = self.createGSoCProposalDuplicate(
student, self.program1)
self.proposal_duplicates.append(proposal_duplicate)
#Create other program entity.
self.program2 = program_utils.seedGSoCProgram(sponsor_key=sponsor.key())
#Create students in program2.
self.other_gsoc_students = []
for _ in xrange(5):
student = profile_utils.seedNDBStudent(self.program2)
self.other_gsoc_students.append(student)
#Create a GSoCProposalDuplicate entity for all the students
#in self.other_gsoc_students for program2.
self.other_proposal_duplicates = []
for student in self.other_gsoc_students:
proposal_duplicate = self.createGSoCProposalDuplicate(student,
self.program2)
self.other_proposal_duplicates.append(proposal_duplicate)
#Create a GSocProposalDuplicateStatusEntity for other_program
properties = {'program': self.program2}
self.gpds = seeder_logic.seed(GSoCProposalDuplicatesStatus, properties)
def testConnectionExists(self):
"""Tests that connection is returned correctly if exists."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
org = org_utils.seedOrganization(program.key())
profile = profile_utils.seedNDBProfile(program.key())
connection = connection_utils.seed_new_connection(profile.key, org.key)
kwargs = {
'sponsor': sponsor.link_id,
'program': program.program_id,
'user': profile.profile_id,
'id': str(connection.key.id())
}
data = request_data.RequestData(None, None, kwargs)
url_connection = data.url_connection
self.assertEqual(connection.key, url_connection.key)
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())
self.program = program_utils.seedGSoCProgram(
program_id=TEST_PROGRAM_ID,
sponsor_key=sponsor.key(),
timeline_key=self.timeline.key(),
app_tasks_limit=3)
self.student = profile_utils.seedNDBStudent(self.program)
def testConnectionExists(self):
"""Tests that connection is returned correctly if exists."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
org = org_utils.seedOrganization(program.key())
profile = profile_utils.seedNDBProfile(program.key())
connection = connection_utils.seed_new_connection(profile.key, org.key)
kwargs = {
'sponsor': sponsor.link_id,
'program': program.program_id,
'user': profile.profile_id,
'id': str(connection.key.id())
}
data = request_data.RequestData(None, None, kwargs)
url_connection = data.url_connection
self.assertEqual(connection.key, url_connection.key)
def testOrgExists(self):
"""Tests that organization is returned correctly if exists."""
sponsor = program_utils.seedSponsor()
program = seeder_logic.seed(program_model.Program)
org_properties = {
'key_name': '%s/%s/test_org' % (sponsor.link_id, program.program_id),
'link_id': 'test_org',
}
org = seeder_logic.seed(org_model.Organization, org_properties)
kwargs = {
'sponsor': sponsor.link_id,
'program': program.program_id,
'organization': org.link_id
}
data = request_data.RequestData(None, None, kwargs)
url_org = data.url_org
self.assertEqual(org.key(), url_org.key())
def testOrgExists(self):
"""Tests that organization is returned correctly if exists."""
sponsor = program_utils.seedSponsor()
program = seeder_logic.seed(program_model.Program)
org_properties = {
'key_name':
'%s/%s/test_org' % (sponsor.link_id, program.program_id),
'link_id': 'test_org',
}
org = seeder_logic.seed(org_model.Organization, org_properties)
kwargs = {
'sponsor': sponsor.link_id,
'program': program.program_id,
'organization': org.link_id
}
data = request_data.RequestData(None, None, kwargs)
url_org = data.url_org
self.assertEqual(org.key(), url_org.key())
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 setUp(self):
"""See unittest.TestCase.setUp for specification."""
sponsor = program_utils.seedSponsor()
program_properties = {
'sponsor': sponsor,
'scope': sponsor,
}
program = seeder_logic.seed(
program_model.Program, properties=program_properties)
org_properties = {
'program': program,
'scope': program,
}
self.organization = seeder_logic.seed(
org_model.Organization, properties=org_properties)
kwargs = {
'sponsor': sponsor.key().name(),
'program': program.link_id,
'organization': self.organization.link_id,
}
self.data = request_data.RequestData(None, None, kwargs)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
sponsor = program_utils.seedSponsor()
program_properties = {
'sponsor': sponsor,
'scope': sponsor,
}
program = seeder_logic.seed(program_model.Program,
properties=program_properties)
org_properties = {
'program': program,
'scope': program,
}
self.organization = seeder_logic.seed(org_model.Organization,
properties=org_properties)
kwargs = {
'sponsor': sponsor.key().name(),
'program': program.link_id,
'organization': self.organization.link_id,
}
self.data = request_data.RequestData(None, None, kwargs)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
self.survey = program_utils.seedApplicationSurvey(program.key())
# seed some organizations with survey responses
self.app_responses = set()
for _ in range(TEST_ORGS_NUMBER):
org = org_utils.seedOrganization(program.key())
self.app_responses.add(
org_utils.seedApplication(org.key, self.survey.key()).key)
# seed some organizations without survey responses
for _ in range(TEST_ORGS_NUMBER):
org_utils.seedOrganization(program.key())
other_program = program_utils.seedProgram(sponsor_key=sponsor.key())
other_survey = program_utils.seedApplicationSurvey(other_program.key())
# seed some organizations with survey responses for other survey
for _ in range(TEST_ORGS_NUMBER):
org = org_utils.seedOrganization(other_program.key())
org_utils.seedApplication(org.key, other_survey.key())
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
self.survey = program_utils.seedApplicationSurvey(program.key())
# seed some organizations with survey responses
self.app_responses = set()
for _ in range(TEST_ORGS_NUMBER):
org = org_utils.seedOrganization(program.key())
self.app_responses.add(
org_utils.seedApplication(org.key, self.survey.key()).key)
# seed some organizations without survey responses
for _ in range(TEST_ORGS_NUMBER):
org_utils.seedOrganization(program.key())
other_program = program_utils.seedProgram(sponsor_key=sponsor.key())
other_survey = program_utils.seedApplicationSurvey(other_program.key())
# seed some organizations with survey responses for other survey
for _ in range(TEST_ORGS_NUMBER):
org = org_utils.seedOrganization(other_program.key())
org_utils.seedApplication(org.key, other_survey.key())
def testSponsor(self):
"""Tests sponsor function."""
sponsor = program_utils.seedSponsor()
self.assertEqual(
'/gci/program/create/%s' % sponsor.key().name(),
self.linker.sponsor(sponsor, 'gci_program_create'))
