def setUp(self):
self.program = program_utils.seedGSoCProgram()
self.organization = org_utils.seedSOCOrganization(self.program.key())
slot_transfer_properties = {
'program': self.program,
'status': 'accepted'
}
self.org_entities = [
org_utils.seedSOCOrganization(self.program.key())
for _ in range(NUMBER_OF_ORGS)
]
#Assign one slot transfer entity to each of the organization in
#self.org_entities
self.slot_transfer_entities = []
properties = slot_transfer_properties.copy()
for i in range(10):
properties['parent'] = self.org_entities[i].key.to_old_key()
entity = seeder_logic.seed(GSoCSlotTransfer, properties)
self.slot_transfer_entities.append(entity)
#Assign multiple slot transfer entities to self.organization
properties = slot_transfer_properties.copy()
properties.update({'parent': self.organization.key.to_old_key()})
self.gsoc_organization_slot_transfer_entities = seeder_logic.seedn(
GSoCSlotTransfer, 5, properties)
def setUp(self):
self.program = program_utils.seedGSoCProgram()
self.organization = org_utils.seedSOCOrganization(self.program.key())
slot_transfer_properties = {'program': self.program,
'status': 'accepted'}
self.org_entities = [
org_utils.seedSOCOrganization(self.program.key())
for _ in range(NUMBER_OF_ORGS)]
#Assign one slot transfer entity to each of the organization in
#self.org_entities
self.slot_transfer_entities = []
properties = slot_transfer_properties.copy()
for i in range(10):
properties['parent'] = self.org_entities[i].key.to_old_key()
entity = seeder_logic.seed(GSoCSlotTransfer, properties)
self.slot_transfer_entities.append(entity)
#Assign multiple slot transfer entities to self.organization
properties = slot_transfer_properties.copy()
properties.update({'parent': self.organization.key.to_old_key()})
self.gsoc_organization_slot_transfer_entities = seeder_logic.seedn(
GSoCSlotTransfer, 5, properties)
def setUp(self):
self.user = profile_utils.seedNDBUser()
self.program = program_utils.seedProgram()
self.gsoc_program = program_utils.seedGSoCProgram()
self.gci_program = program_utils.seedGCIProgram()
self.site = seeder_logic.seed(Site, {'key_name': 'site'})
self.organization = seeder_logic.seed(Organization)
self.gsoc_organization = org_utils.seedSOCOrganization(
self.gsoc_program.key())
self.gci_organization = seeder_logic.seed(GCIOrganization)
self.program_key_name = self.program.key().name()
self.gsoc_program_key_name = self.gsoc_program.key().name()
self.gci_program_key_name = self.gci_program.key().name()
self.site_key_name = self.site.key().name()
self.org_key_name = self.organization.key().name()
self.gsoc_org_key_name = self.gsoc_organization.key.id()
self.gci_org_key_name = self.gci_organization.key().name()
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):
# 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())
def setUp(self):
self.user = profile_utils.seedNDBUser()
self.program = program_utils.seedProgram()
self.gsoc_program = program_utils.seedGSoCProgram()
self.gci_program = program_utils.seedGCIProgram()
self.site = seeder_logic.seed(Site, {'key_name': 'site'})
self.organization = seeder_logic.seed(Organization)
self.gsoc_organization = org_utils.seedSOCOrganization(
self.gsoc_program.key())
self.gci_organization = seeder_logic.seed(GCIOrganization)
self.program_key_name = self.program.key().name()
self.gsoc_program_key_name = self.gsoc_program.key().name()
self.gci_program_key_name = self.gci_program.key().name()
self.site_key_name = self.site.key().name()
self.org_key_name = self.organization.key().name()
self.gsoc_org_key_name = self.gsoc_organization.key.id()
self.gci_org_key_name = self.gci_organization.key().name()
def setUp(self):
self.program = program_utils.seedGSoCProgram()
self.foo_organization = org_utils.seedSOCOrganization(self.program.key())
# create mentors for foo_organization.
self.foo_mentors = []
for _ in range(5):
mentor = profile_utils.seedNDBProfile(
self.program.key(), mentor_for=[self.foo_organization.key])
self.foo_mentors.append(mentor)
# create organization admins for foo_organization.
self.foo_org_admins = []
for _ in range(5):
org_admin = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.foo_organization.key])
self.foo_org_admins.append(org_admin)
# create another organization bar_organization for our program.
self.bar_organization = org_utils.seedSOCOrganization(self.program.key())
# assign mentors for bar_organization.
self.bar_mentors = []
for _ in range(5):
mentor = profile_utils.seedNDBProfile(
self.program.key(), mentor_for=[self.bar_organization.key])
self.bar_mentors.append(mentor)
# assign an organization admin for bar_organization
self.bar_org_admin = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.bar_organization.key])
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 setUp(self):
self.program = program_utils.seedGSoCProgram()
# An organization which has all its slots allocated.
self.foo_organization = org_utils.seedSOCOrganization(
self.program.key(), slot_allocation=2)
self.foo_proposals = []
for _ in range(2):
student = profile_utils.seedNDBStudent(self.program)
self.foo_proposals.append(
proposal_utils.seedProposal(student.key, self.program.key(),
org_key=self.foo_organization.key,
status=proposal_model.STATUS_ACCEPTED))
# Create an organization which has slots to be allocated. We create both
# rejected and accepted proposals for this organization entity.
self.bar_organization = org_utils.seedSOCOrganization(
self.program.key(), slot_allocation=5)
# Create some already accepted proposals for bar_organization.
self.bar_accepted_proposals = []
for _ in range(2):
student = profile_utils.seedNDBStudent(self.program)
self.bar_accepted_proposals.append(
proposal_utils.seedProposal(student.key, self.program.key(),
org_key=self.bar_organization.key,
status=proposal_model.STATUS_ACCEPTED))
# proposals which are yet to be accepted.
self.bar_to_be_accepted_proposals = []
for _ in range(3):
student = profile_utils.seedNDBStudent(self.program)
self.bar_to_be_accepted_proposals.append(
proposal_utils.seedProposal(student.key, self.program.key(),
org_key=self.bar_organization.key, accept_as_project=True,
status=proposal_model.STATUS_PENDING))
# proposals which were rejected.
self.bar_rejected_proposals = []
for _ in range(3):
student = profile_utils.seedNDBStudent(self.program)
self.bar_rejected_proposals.append(
proposal_utils.seedProposal(student.key, self.program.key(),
org_key=self.bar_organization.key, accept_as_project=False,
status=proposal_model.STATUS_PENDING))
# Create an organization for which the accepted proposals are more than
# the available slots.
self.happy_organization = org_utils.seedSOCOrganization(
self.program.key(), slot_allocation=1)
self.happy_accepted_proposals = []
self.happy_accepted_proposals.append(
proposal_utils.seedProposal(student.key, self.program.key(),
org_key=self.happy_organization.key, score=2,
status=proposal_model.STATUS_PENDING, accept_as_project=True))
self.happy_accepted_proposals.append(
proposal_utils.seedProposal(student.key, self.program.key(),
org_key=self.happy_organization.key, score=5,
status=proposal_model.STATUS_PENDING, accept_as_project=True))
def setUp(self):
"""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 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 setUp(self):
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed a new profile and make it a student
self.student = profile_utils.seedNDBStudent(self.program)
self.proposal = proposal_utils.seedProposal(self.student.key,
self.program.key())
def testGetFinalEvaluationKey(self):
"""Tests that correct final evaluation key is returned."""
program = program_utils.seedGSoCProgram()
actual_key = project_survey_logic.constructEvaluationKey(
program.key(), project_survey_model.FINAL_EVAL)
expected_key = db.Key.from_path(
project_survey_model.ProjectSurvey.kind(), 'gsoc_program/%s/%s' % (
program.key().name(), project_survey_model.FINAL_EVAL))
self.assertEqual(actual_key, expected_key)
def setUp(self):
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed a new profile and make it a student
self.student = profile_utils.seedNDBStudent(self.program)
self.proposal = proposal_utils.seedProposal(
self.student.key, self.program.key())
def setUp(self):
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed an organization
self.organization = org_utils.seedSOCOrganization(self.program.key())
# seed a new profile
self.profile = profile_utils.seedNDBProfile(self.program.key())
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):
# 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 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 setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.user = profile_utils.seedNDBUser()
profile_utils.loginNDB(self.user)
site_properties = {'key_name': 'site', 'maintenance_mode': False}
self.site = seeder_logic.seed(site_model.Site,
properties=site_properties)
self.gsoc_program = program_utils.seedGSoCProgram()
self.gci_program = program_utils.seedGCIProgram()
def testSummerOfCodeProfileAccessDenied(self):
"""Tests that Summer Of Code profile (no role) cannot access the page."""
# seed Summer Of Code program
soc_program = program_utils.seedGSoCProgram()
# seed Summer Of Code student
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(soc_program.key(), user=user)
response = self.get(self.take_url)
self.assertResponseForbidden(response)
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):
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed a new organization
self.org = org_utils.seedSOCOrganization(self.program.key())
# create a new profile and make it a student
self.student = profile_utils.seedNDBStudent(self.program)
# seed a new proposal and assign
self.proposal = proposal_utils.seedProposal(
self.student.key, self.program.key(), org_key=self.org.key)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.user = profile_utils.seedNDBUser()
profile_utils.loginNDB(self.user)
site_properties = {
'key_name': 'site',
'maintenance_mode': False
}
self.site = seeder_logic.seed(site_model.Site, properties=site_properties)
self.gsoc_program = program_utils.seedGSoCProgram()
self.gci_program = program_utils.seedGCIProgram()
def setUp(self):
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed a new organization
self.org = org_utils.seedSOCOrganization(self.program.key())
# create a new profile and make it a student
self.student = profile_utils.seedNDBStudent(self.program)
# seed a new proposal and assign
self.proposal = proposal_utils.seedProposal(self.student.key,
self.program.key(),
org_key=self.org.key)
def testSummerOfCodeOrgAdminAccessGranted(self):
"""Tests that Summer Of Code org admins need a new profile first."""
# seed Summer Of Code program and organization
soc_program = program_utils.seedGSoCProgram()
soc_org = org_utils.seedSOCOrganization(soc_program.key())
# seed Summer Of Code org admin
user = profile_utils.seedNDBUser()
profile_utils.loginNDB(user)
profile_utils.seedNDBProfile(
soc_program.key(), user=user, admin_for=[soc_org.key])
response = self.get(self.take_url)
self.assertResponseRedirect(response)
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."""
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):
super(ConvertProposalsTest, self).setUp()
self.init()
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed a few organizations
self.org_keys = [
org_utils.seedSOCOrganization(self.program.key(),
status=org_model.Status.ACCEPTED).key
for _ in range(TEST_NUMBER_OF_ORGS)
]
# create post data that will be sent to tasks
self.post_data = {'program_key': self.program.key().name()}
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.init()
# TODO(daniel): it should not seed GSoC Program here
self.program = program_utils.seedGSoCProgram()
properties = {'parent': self.program}
seeder_logic.seed(program_model.ProgramMessages, properties=properties)
self.site = program_utils.seedSite()
self.org = org_utils.seedOrganization(self.program.key())
self.profile = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.org.key])
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.init()
# TODO(daniel): it should not seed GSoC Program here
self.program = program_utils.seedGSoCProgram()
properties = {'parent': self.program}
seeder_logic.seed(program_model.ProgramMessages, properties=properties)
self.site = program_utils.seedSite()
self.org = org_utils.seedOrganization(self.program.key())
self.profile = profile_utils.seedNDBProfile(self.program.key(),
admin_for=[self.org.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 testSurvey(self):
"""Tests survey function."""
# seed a program
program = program_utils.seedGSoCProgram()
# seed a survey
survey_properties = {
"program": program,
"link_id": TEST_SURVEY_ID,
"key_name": "%s/%s" % (program.key().name(), TEST_SURVEY_ID),
}
survey = seeder_logic.seed(project_survey_model.ProjectSurvey, properties=survey_properties)
self.assertEqual(
"/gsoc/eval/mentor/edit/%s/%s" % (survey.program.key().name(), survey.survey_type),
self.linker.survey(survey.key(), "gsoc_edit_mentor_evaluation"),
)
def setUp(self):
super(ConvertProposalsTest, self).setUp()
self.init()
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed a few organizations
self.org_keys = [
org_utils.seedSOCOrganization(
self.program.key(), status=org_model.Status.ACCEPTED).key
for _ in range(TEST_NUMBER_OF_ORGS)]
# create post data that will be sent to tasks
self.post_data = {
'program_key': self.program.key().name()
}
def testSurvey(self):
"""Tests survey function."""
# seed a program
program = program_utils.seedGSoCProgram()
# seed a survey
survey_properties = {
'program': program,
'link_id': TEST_SURVEY_ID,
'key_name': '%s/%s' % (program.key().name(), TEST_SURVEY_ID)
}
survey = seeder_logic.seed(
project_survey_model.ProjectSurvey, properties=survey_properties)
self.assertEqual(
'/gsoc/eval/mentor/edit/%s/%s' % (
survey.program.key().name(), survey.survey_type),
self.linker.survey(survey.key(), 'gsoc_edit_mentor_evaluation'))
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):
# 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 project for the organization one
student = profile_utils.seedNDBStudent(self.program)
self.project_one = project_utils.seedProject(
student, self.program.key(), org_key=self.organization_one.key)
self.project_one.mentors = []
self.project_one.put()
# seed a new mentor for organization one, but without projects
self.mentor = profile_utils.seedNDBProfile(
self.program.key(), mentor_for=[self.organization_one.key])
def setUp(self):
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed a new organizations
self.organization = org_utils.seedSOCOrganization(self.program.key())
# seed a new profile and make it a student
self.student = profile_utils.seedNDBStudent(self.program)
# seed another profile and make it a mentor
self.mentor = profile_utils.seedNDBProfile(
self.program.key(), mentor_for=[self.organization.key])
# seed a new proposal and assign the mentor
self.proposal = proposal_utils.seedProposal(
self.student.key, self.program.key(), org_key=self.organization.key,
mentor_key=self.mentor.key, accept_as_project=True,
abstract='test abstract')
def 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 project for the organization one
student = profile_utils.seedNDBStudent(self.program)
self.project_one = project_utils.seedProject(
student, self.program.key(), org_key=self.organization_one.key)
self.project_one.mentors = []
self.project_one.put()
# seed a new mentor for organization one, but without projects
self.mentor = profile_utils.seedNDBProfile(
self.program.key(), mentor_for=[self.organization_one.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):
# seed a new program
self.program = program_utils.seedGSoCProgram()
# seed a new organizations
self.organization = org_utils.seedSOCOrganization(self.program.key())
# seed a new profile and make it a student
self.student = profile_utils.seedNDBStudent(self.program)
# seed another profile and make it a mentor
self.mentor = profile_utils.seedNDBProfile(
self.program.key(), mentor_for=[self.organization.key])
# seed a new proposal and assign the mentor
self.proposal = proposal_utils.seedProposal(
self.student.key,
self.program.key(),
org_key=self.organization.key,
mentor_key=self.mentor.key,
accept_as_project=True,
abstract='test abstract')
def setUp(self):
# seed a program
self.program = program_utils.seedGSoCProgram()
survey_helper = survey_utils.SurveyHelper(self.program, False)
# seed evaluations
self.student_evaluation = survey_helper.createStudentEvaluation()
self.mentor_evaluation = survey_helper.createMentorEvaluation()
# seed grading survey group
properties = {
'program': self.program,
'grading_survey': self.mentor_evaluation,
'student_survey': self.student_evaluation,
}
self.survey_group = seeder_logic.seed(
grading_survey_group_model.GSoCGradingSurveyGroup,
properties=properties)
# seed project
self.project = seeder_logic.seed(project_model.GSoCProject)
def setUp(self):
self.program = program_utils.seedGSoCProgram()
self.evaluation_keys = set()
evaluation_properties = {
'program': self.program,
'link_id': project_survey_model.MIDTERM_EVAL,
'key_name': 'gsoc_program/%s/%s' % (
self.program.key().name(), project_survey_model.MIDTERM_EVAL)
}
self.evaluation_keys.add(seeder_logic.seed(
project_survey_model.ProjectSurvey,
properties=evaluation_properties).key())
evaluation_properties = {
'program': self.program,
'link_id': project_survey_model.FINAL_EVAL,
'key_name': 'gsoc_program/%s/%s' % (
self.program.key().name(), project_survey_model.FINAL_EVAL)
}
self.evaluation_keys.add(seeder_logic.seed(
project_survey_model.ProjectSurvey,
properties=evaluation_properties).key())
def setUp(self):
# seed a program
self.program = program_utils.seedGSoCProgram()
# seed an organization application
self.survey = seeder_logic.seed(survey_model.Survey)
def testForEligibleBirthDate(self, mock_func): """Tests that an eligible birth date is cleaned properly.""" program = program_utils.seedGSoCProgram() result = profile_view.cleanBirthDate(TEST_BIRTH_DATE, program) self.assertEqual(result, TEST_BIRTH_DATE)
def testForIneligibleBirthDate(self, mock_func):
"""Tests that an error is raised for an ineligible birth date."""
program = program_utils.seedGSoCProgram()
with self.assertRaises(django_forms.ValidationError):
profile_view.cleanBirthDate(TEST_BIRTH_DATE, program)
def testForIneligibleBirthDate(self, mock_func):
"""Tests that an error is raised for an ineligible birth date."""
program = program_utils.seedGSoCProgram()
with self.assertRaises(django_forms.ValidationError):
profile_view.cleanBirthDate(TEST_BIRTH_DATE, program)
def setUp(self): """See unittest.TestCase.setUp for specification.""" self.program = program_utils.seedGSoCProgram() self.student = profile_utils.seedNDBStudent(self.program)
def testUnknownSurveyType(self):
"""Tests that error is raised when survey type is not supported."""
program = program_utils.seedGSoCProgram()
with self.assertRaises(ValueError):
project_survey_logic.constructEvaluationKey(program.key(), 'unknown')
def testNoEvaluationsForProgram(self):
"""Tests that no evaluations are returned for program with no surveys."""
other_program = program_utils.seedGSoCProgram()
evaluations = project_survey_logic.getStudentEvaluations(
other_program.key())
self.assertSetEqual(evaluations, set())
