def setUp(self):
"""Set up required for the host logic tests.
"""
self.founder = seeder_logic.seed(User)
properties = {'founder': self.founder, 'home': None}
self.sponsor = seeder_logic.seed(Sponsor, properties)
def testMentorPassingRecord(self):
"""Tests when mentor record passes the project."""
# seed sudent record
properties = {
'project': self.project,
'survey': self.student_evaluation,
}
student_record = seeder_logic.seed(
project_survey_record_model.GSoCProjectSurveyRecord,
properties=properties)
# seed mentor record with a passing grade
properties = {
'project': self.project,
'grade': True,
'survey': self.mentor_evaluation
}
mentor_record = seeder_logic.seed(
grading_project_survey_record_model.GSoCGradingProjectSurveyRecord,
properties=properties)
fields = grading_record_logic.getFieldsForGradingRecord(
self.project, self.survey_group)
# check that both records are returned
self.assertEqual(fields['student_record'].key(), student_record.key())
self.assertEqual(fields['mentor_record'].key(), mentor_record.key())
# check that grade decision is 'fail'
self.assertEqual(fields['grade_decision'], grading_record_model.GRADE_PASS)
def testGetHostForUser(self):
"""Tests if a host entity for the user entity is returned.
"""
#create an entity group. The entity at index i in the list is the parent of
#the entity at index i+1.
user_entities = []
user_entities.append(seeder_logic.seed(User))
for i in range(4):
properties = {'parent': user_entities[i].key()}
entity = seeder_logic.seed(User, properties)
user_entities.append(entity)
#create a Host entity with parent as an entity in user_entities
properties = {'parent': user_entities[4]}
host = seeder_logic.seed(Host, properties)
#root entity
expected = host.key()
user_entity = user_entities[0]
self.assertEqual(
host_logic.getHostForUser(user_entity).key(), expected)
#all entities in the ancestral path
expected = host.key()
for entity in user_entities:
self.assertEqual(host_logic.getHostForUser(entity).key(), expected)
#an entity not in the same entity group
expected = None
entity = seeder_logic.seed(User)
self.assertEqual(host_logic.getHostForUser(entity), expected)
def testListData(self):
user = profile_utils.seedNDBUser(host_for=[self.program])
profile_utils.loginNDB(user)
properties = {
'program': self.gsoc,
'nr_slots': 3,
'remarks': 'Sample Remark',
'status': 'pending',
}
# seed slot transfer entity for self.org
properties['parent'] = self.org.key.to_old_key()
seeder_logic.seed(slot_transfer_model.GSoCSlotTransfer, properties)
other_org = org_utils.seedSOCOrganization(
self.program.key(), status=org_model.Status.ACCEPTED)
# seed slot transfer entity for other_org
properties['parent'] = other_org.key.to_old_key()
seeder_logic.seed(slot_transfer_model.GSoCSlotTransfer, properties)
response = self.get(self.url)
self.assertResponseOK(response)
list_data = self.getListData(self.url, 0)
self.assertEqual(len(list_data), 2)
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 testTasksWithFilters(self):
"""Tests with applying a filters on properties."""
# seed another organization
other_org = seeder_logic.seed(org_model.GCIOrganization)
# seed another task for that organization and the seeded mentor
task_properties = {
'mentors': [self.profile.key()],
'status': task_model.CLAIMED,
'org': other_org,
'student': None,
}
other_task = seeder_logic.seed(
task_model.GCITask, properties=task_properties)
# check querying tasks for organization filter
extra_filters = {task_model.GCITask.org: [self.org]}
query = task_logic.queryTasksForMentor(
self.profile.key(), extra_filters=extra_filters)
self.assertSetEqual(
set(entity.key() for entity in query),
set([self.task1.key(), self.task2.key()]))
# check querying tasks for status filter
extra_filters = {
task_model.GCITask.status: [task_model.CLAIMED, task_model.OPEN]
}
query = task_logic.queryTasksForMentor(
self.profile.key(), extra_filters=extra_filters)
self.assertSetEqual(
set(entity.key() for entity in query),
set([self.task1.key(), self.task2.key(), other_task.key()]))
def testListData(self):
user = profile_utils.seedNDBUser(host_for=[self.program])
profile_utils.loginNDB(user)
properties = {
'program': self.gsoc,
'nr_slots': 3,
'remarks': 'Sample Remark',
'status': 'pending',
}
# seed slot transfer entity for self.org
properties['parent'] = self.org.key.to_old_key()
seeder_logic.seed(slot_transfer_model.GSoCSlotTransfer, properties)
other_org = org_utils.seedSOCOrganization(
self.program.key(), status=org_model.Status.ACCEPTED)
# seed slot transfer entity for other_org
properties['parent'] = other_org.key.to_old_key()
seeder_logic.seed(slot_transfer_model.GSoCSlotTransfer, properties)
response = self.get(self.url)
self.assertResponseOK(response)
list_data = self.getListData(self.url, 0)
self.assertEqual(len(list_data), 2)
def testGetHostsForProgram(self):
"""Tests if a host entity for a program is returned.
"""
properties = {
'scope': self.sponsor,
}
program = seeder_logic.seed(Program, properties)
#hosts of the program
user_entities = []
for i in range(5):
properties = {'host_for': [self.sponsor.key()]}
entity = seeder_logic.seed(User, properties)
user_entities.append(entity)
host_entities = []
for i in range(5):
properties = {'parent': user_entities[i]}
entity = seeder_logic.seed(Host, properties)
host_entities.append(entity)
expected = [entity.key() for entity in host_entities]
hosts_list = host_logic.getHostsForProgram(program)
actual = [host.key() for host in hosts_list]
self.assertEqual(actual, expected)
#program with a different scope
program = seeder_logic.seed(Program)
expected = []
hosts_list = host_logic.getHostsForProgram(program)
actual = [host.key() for host in hosts_list]
self.assertEqual(actual, expected)
def testOrgAdminsForOrg(self):
"""Tests if organisation admins for a given GCI organisation are returned."""
org_admin_properties = {
'org_admin_for': [self.foo_org.key()],
'is_org_admin': True
}
foo_org_admin1 = seeder_logic.seed(GCIProfile, org_admin_properties)
foo_org_admin2 = seeder_logic.seed(GCIProfile, org_admin_properties)
org_admin_properties['org_admin_for'] = [self.bar_org.key()]
bar_org_admin = seeder_logic.seed(GCIProfile, org_admin_properties)
# Check for self.foo_org (two admins)
expected = [foo_org_admin1.key(), foo_org_admin2.key()]
actual = [
profiles.key()
for profiles in profile_logic.orgAdminsForOrg(self.foo_org)
]
self.assertEqual(expected, actual)
# Check for self.bar_org (just one admin)
expected = [bar_org_admin.key()]
actual = [
profiles.key()
for profiles in profile_logic.orgAdminsForOrg(self.bar_org)
]
self.assertEqual(expected, actual)
def createMentorWithProject(self, org):
"""Creates an mentor profile with a project for the current user.
"""
self.createMentor(org)
from soc.modules.gsoc.models.student_project import StudentProject
properties = {'mentor': self.profile}
seeder_logic.seed(StudentProject, 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):
self.gsoc_program = seeder_logic.seed(GSoCProgram)
self.gsoc_organization = seeder_logic.seed(GSoCOrganization,
{'scope': self.gsoc_program})
slot_transfer_properties = {'program': self.gsoc_program,
'status': 'accepted'}
organization_properties = {'scope': self.gsoc_program}
self.org_entities = seeder_logic.seedn(GSoCOrganization, 10,
organization_properties)
#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]
entity = seeder_logic.seed(GSoCSlotTransfer, properties)
self.slot_transfer_entities.append(entity)
#Assign multiple slot transfer entities to self.gsoc_organization
properties = slot_transfer_properties.copy()
properties.update({'parent': self.gsoc_organization})
self.gsoc_organization_slot_transfer_entities = seeder_logic.seedn(
GSoCSlotTransfer, 5, properties)
def setUp(self):
self.program = seeder_logic.seed(GSoCProgram)
organization_properties = {'program': self.program}
self.foo_organization = seeder_logic.seed(GSoCOrganization,
organization_properties)
#create mentors for foo_organization.
self.foo_mentors = []
for i in range(5):
email = '*****@*****.**' % str(i)
mentor = self.createMentor(email, self.foo_organization)
self.foo_mentors.append(mentor)
#create organization admins for foo_organization.
self.foo_org_admins = []
for i in range(5):
email = '*****@*****.**' % str(i)
admin = self.createOrgAdmin(email, self.foo_organization)
self.foo_org_admins.append(admin)
#create another organization bar_organization for our program.
self.bar_organization = seeder_logic.seed(GSoCOrganization,
organization_properties)
#assign mentors for bar_organization.
self.bar_mentors = []
for i in range(5):
email = '*****@*****.**' % str(i)
mentor = self.createMentor(email, self.bar_organization)
self.bar_mentors.append(mentor)
#assign an organization admin for bar_organization
email = '*****@*****.**'
self.bar_org_admin = self.createOrgAdmin(email, self.bar_organization)
def setUp(self):
self.program = seeder_logic.seed(GSoCProgram)
organization_properties = {'program': self.program}
self.foo_organization = seeder_logic.seed(GSoCOrganization,
organization_properties)
#create mentors for foo_organization.
self.foo_mentors = []
for i in range(5):
email = '*****@*****.**' % str(i)
mentor = self.createMentor(email, self.foo_organization)
self.foo_mentors.append(mentor)
#create organization admins for foo_organization.
self.foo_org_admins = []
for i in range(5):
email = '*****@*****.**' % str(i)
admin = self.createOrgAdmin(email, self.foo_organization)
self.foo_org_admins.append(admin)
#create another organization bar_organization for our program.
self.bar_organization = seeder_logic.seed(GSoCOrganization,
organization_properties)
#assign mentors for bar_organization.
self.bar_mentors = []
for i in range(5):
email = '*****@*****.**' % str(i)
mentor = self.createMentor(email, self.bar_organization)
self.bar_mentors.append(mentor)
#assign an organization admin for bar_organization
email = '*****@*****.**'
self.bar_org_admin = self.createOrgAdmin(email, self.bar_organization)
def testAcceptedOrgsAreDisplayedAfterOrganizationsHaveBeenAnnounced(self):
"""Tests that the list of the organizations can not be accessed before
organizations have been announced.
"""
org_properties = {'scope': self.gsoc, 'status': 'active'}
seeder_logic.seed(GSoCOrganization, org_properties)
seeder_logic.seed(GSoCOrganization, org_properties)
self.timeline.orgsAnnounced()
response = self.get(self.url1)
self.assertResponseOK(response)
self.assertAcceptedOrgsPageTemplatesUsed(response)
list_data = self.getListData(self.url1, 0)
#Third organization is self.gsoc
self.assertEqual(len(list_data), 3)
response = self.get(self.url2)
self.assertResponseOK(response)
self.assertAcceptedOrgsPageTemplatesUsed(response)
list_data = self.getListData(self.url2, 0)
self.assertEqual(len(list_data), 3)
response = self.get(self.url3)
self.assertResponseOK(response)
self.assertAcceptedOrgsPageTemplatesUsed(response)
list_data = self.getListData(self.url3, 0)
self.assertEqual(len(list_data), 3)
def setUp(self):
self.valid_list_id = 'valid_cached_list'
self.invalid_list_id = 'invalid_cached_list'
self.processing_list_id = 'processing_cached_list'
self.not_processing_list_id = 'not_processing_cached_list'
valid_cached_list_properties = {
'id': self.valid_list_id,
'valid_through': datetime.datetime.max
}
self.valid_list = seeder_logic.seed(
cached_list_model.CachedList, valid_cached_list_properties)
invalid_cached_list_properties = {
'id': self.invalid_list_id,
'valid_through': datetime.datetime.min
}
self.invalid_list = seeder_logic.seed(
cached_list_model.CachedList, invalid_cached_list_properties)
processing_cached_list_properties = {
'id': self.processing_list_id,
'is_processing': True
}
self.processing_list = seeder_logic.seed(
cached_list_model.CachedList, processing_cached_list_properties)
not_processing_cached_list_properties = {
'id': self.not_processing_list_id,
'is_processing': False
}
self.processing_list = seeder_logic.seed(
cached_list_model.CachedList, not_processing_cached_list_properties)
def testAcceptedOrgsAreDisplayedAfterOrganizationsHaveBeenAnnounced(self):
"""Tests that the list of the organizations can not be accessed before
organizations have been announced.
"""
org_properties = {'scope': self.gsoc, 'status': 'active'}
seeder_logic.seed(GSoCOrganization, org_properties)
seeder_logic.seed(GSoCOrganization, org_properties)
self.timeline.orgsAnnounced()
response = self.get(self.url1)
self.assertResponseOK(response)
self.assertAcceptedOrgsPageTemplatesUsed(response)
list_data = self.getListData(self.url1, 0)
#Third organization is self.gsoc
self.assertEqual(len(list_data), 3)
response = self.get(self.url2)
self.assertResponseOK(response)
self.assertAcceptedOrgsPageTemplatesUsed(response)
list_data = self.getListData(self.url2, 0)
self.assertEqual(len(list_data), 3)
response = self.get(self.url3)
self.assertResponseOK(response)
self.assertAcceptedOrgsPageTemplatesUsed(response)
list_data = self.getListData(self.url3, 0)
self.assertEqual(len(list_data), 3)
def setUp(self):
self.valid_list_id = 'valid_cached_list'
self.invalid_list_id = 'invalid_cached_list'
self.processing_list_id = 'processing_cached_list'
self.not_processing_list_id = 'not_processing_cached_list'
valid_cached_list_properties = {
'id': self.valid_list_id,
'valid_through': datetime.datetime.max
}
self.valid_list = seeder_logic.seed(cached_list_model.CachedList,
valid_cached_list_properties)
invalid_cached_list_properties = {
'id': self.invalid_list_id,
'valid_through': datetime.datetime.min
}
self.invalid_list = seeder_logic.seed(cached_list_model.CachedList,
invalid_cached_list_properties)
processing_cached_list_properties = {
'id': self.processing_list_id,
'is_processing': True
}
self.processing_list = seeder_logic.seed(
cached_list_model.CachedList, processing_cached_list_properties)
not_processing_cached_list_properties = {
'id': self.not_processing_list_id,
'is_processing': False
}
self.processing_list = seeder_logic.seed(
cached_list_model.CachedList,
not_processing_cached_list_properties)
def testTasksWithFilters(self):
"""Tests with applying a filters on properties."""
# seed another organization
other_org = seeder_logic.seed(org_model.GCIOrganization)
# seed another task for that organization and the seeded mentor
task_properties = {
"mentors": [self.profile.key()],
"status": task_model.CLAIMED,
"org": other_org,
"student": None,
}
other_task = seeder_logic.seed(task_model.GCITask, properties=task_properties)
# check querying tasks for organization filter
extra_filters = {task_model.GCITask.org: [self.org]}
query = task_logic.queryTasksForMentor(self.profile.key(), extra_filters=extra_filters)
self.assertSetEqual(set(entity.key() for entity in query), set([self.task1.key(), self.task2.key()]))
# check querying tasks for status filter
extra_filters = {task_model.GCITask.status: [task_model.CLAIMED, task_model.OPEN]}
query = task_logic.queryTasksForMentor(self.profile.key(), extra_filters=extra_filters)
self.assertSetEqual(
set(entity.key() for entity in query), set([self.task1.key(), self.task2.key(), other_task.key()])
)
def setUp(self):
self.program = program_utils.seedGCIProgram()
org_properties = {
'program': self.program
}
self.foo_org = seeder_logic.seed(GCIOrganization, org_properties)
self.bar_org = seeder_logic.seed(GCIOrganization, org_properties)
def createStudentWithProject(self):
"""Sets the current user to be a student with a project for the current program.
"""
self.createStudentWithProposal()
from soc.modules.gsoc.models.student_project import StudentProject
properties = {'link_id': self.profile.link_id, 'scope': self.profile,
'student': self.profile, 'parent': self.profile}
seeder_logic.seed(StudentProject, properties)
def createStudentWithProposal(self):
"""Sets the current user to be a student with a proposal for the current program.
"""
self.createStudent()
from soc.modules.gsoc.models.proposal import GSoCProposal
properties = {'link_id': self.profile.link_id, 'scope': self.profile,
'parent': self.profile, 'status': 'new'}
seeder_logic.seed(GSoCProposal, properties)
def testSeedingNdbKeyPropertySpecified(self):
"""Tests the entity can be seeded properly if ndb KeyProperty specified."""
ndb_dummy_entity = seeder_logic.seed(ndb_models.NdbDummyModel)
entity = seeder_logic.seed(ndb_models.NdbKeyProperty,
properties={'key': ndb_dummy_entity.key})
self.assertIsNotNone(entity)
self.assertIsInstance(entity.key, ndb.Key)
self.assertIsInstance(entity._properties['key'], ndb.KeyProperty)
def testSeedingNdbKeyPropertySpecified(self):
"""Tests the entity can be seeded properly if ndb KeyProperty specified."""
ndb_dummy_entity = seeder_logic.seed(ndb_models.NdbDummyModel)
entity = seeder_logic.seed(ndb_models.NdbKeyProperty,
properties={'key': ndb_dummy_entity.key})
self.assertIsNotNone(entity)
self.assertIsInstance(entity.key, ndb.Key)
self.assertIsInstance(entity._properties['key'], ndb.KeyProperty)
def testTimelineForProgram(self):
# seed a new program and a timeline for it
properties = {"key_name": "test_keyname"}
timeline = seeder_logic.seed(timeline_model.Timeline, properties)
program = seeder_logic.seed(program_model.Program, properties)
result = timeline_logic.isTimelineForProgram(timeline.key(), program.key())
self.assertTrue(result)
def testTimelineForProgram(self):
# seed a new program and a timeline for it
properties = {'key_name': 'test_keyname'}
timeline = seeder_logic.seed(timeline_model.Timeline, properties)
program = seeder_logic.seed(program_model.Program, properties)
result = timeline_logic.isTimelineForProgram(timeline.key(),
program.key())
self.assertTrue(result)
def setUp(self):
self.user = seeder_logic.seed(User)
self.program_timeline = seeder_logic.seed(GSoCTimeline)
program_properties = {'timeline': self.program_timeline, 'scope': self.user}
self.program = seeder_logic.seed(Program, program_properties)
self.gsoc_program = seeder_logic.seed(GSoCProgram, program_properties)
self.gci_program = seeder_logic.seed(GCIProgram, program_properties)
self.site = seeder_logic.seed(Site,)
self.organization = seeder_logic.seed(Organization)
self.gsoc_organization = seeder_logic.seed(GSoCOrganization)
self.gci_organization = seeder_logic.seed(GCIOrganization)
self.user_key_name = self.user.key().name()
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().name()
self.gci_org_key_name = self.gci_organization.key().name()
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
# seed an organization
self.org = seeder_logic.seed(org_model.GCIOrganization)
# seed a user
self.profile = seeder_logic.seed(profile_model.GCIProfile)
# seed a task
task_properties = {'org': self.org}
self.task = seeder_logic.seed(
task_model.GCITask, properties=task_properties)
def setUp(self):
self.item1 = {'name': 'foo'}
self.item2 = {'name': 'bar'}
self.item3 = {'name': 'baz'}
self.item4 = {'name': 'qux'}
self.item5 = {'name': 'quux'}
cached_list_properties = {
'id': 'test_list',
'list_data':
[self.item1, self.item2, self.item3, self.item4, self.item5]
}
seeder_logic.seed(cached_list_model.CachedList, cached_list_properties)
def testClosedTasksList(self):
"""Tests if the list of open tasks is rendered.
"""
task_prop = {'status': 'Closed', 'program': self.gci, 'org': self.org}
seeder_logic.seed(GCITask, task_prop)
seeder_logic.seed(GCITask, task_prop)
response = self.get(self.url)
self.assertResponseOK(response)
self.assertTemplatesUsed(response)
idx = 1
list_data = self.getListData(self.url, idx)
self.assertEqual(len(list_data), 2)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
# seed an organization
self.org = seeder_logic.seed(org_model.GCIOrganization)
# seed a user
self.profile = seeder_logic.seed(profile_model.GCIProfile)
# seed a task
task_properties = {'org': self.org}
self.task = seeder_logic.seed(task_model.GCITask,
properties=task_properties)
def testClosedTasksList(self):
"""Tests if the list of open tasks is rendered.
"""
task_prop = {'status': 'Closed', 'program': self.gci, 'org': self.org}
seeder_logic.seed(GCITask, task_prop)
seeder_logic.seed(GCITask, task_prop)
response = self.get(self.url)
self.assertResponseOK(response)
self.assertTemplatesUsed(response)
idx = 1
list_data = self.getListData(self.url, idx)
self.assertEqual(len(list_data), 2)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.init()
# TODO (daniel): Edit Site Page should work without an active program
program = seeder_logic.seed(program_model.Program)
site_properties = {
'key_name': 'site',
'active_program': program,
'tos': None,
}
self.site = seeder_logic.seed(site_model.Site, properties=site_properties)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
# seed an organization
self.org = seeder_logic.seed(org_model.GCIOrganization)
# seed a mentor
profile_properties = {"is_mentor": True, "mentor_for": [self.org.key()]}
self.profile = seeder_logic.seed(profile_model.GCIProfile, profile_properties)
# seed a few tasks for the seeded mentor
task_properties = {"mentors": [self.profile.key()], "status": task_model.OPEN, "org": self.org, "student": None}
self.task1 = seeder_logic.seed(task_model.GCITask, properties=task_properties)
self.task2 = seeder_logic.seed(task_model.GCITask, properties=task_properties)
def setUp(self):
self.item1 = {'name': 'foo'}
self.item2 = {'name': 'bar'}
self.item3 = {'name': 'baz'}
self.item4 = {'name': 'qux'}
self.item5 = {'name': 'quux'}
cached_list_properties = {
'id':
'test_list',
'list_data':
[self.item1, self.item2, self.item3, self.item4, self.item5]
}
seeder_logic.seed(cached_list_model.CachedList, cached_list_properties)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.init()
# TODO (daniel): Edit Site Page should work without an active program
program = seeder_logic.seed(program_model.Program)
site_properties = {
'key_name': 'site',
'active_program': program,
'tos': None,
}
self.site = seeder_logic.seed(site_model.Site,
properties=site_properties)
def testHasCreatedOrModifiedTask(self):
"""Tests profile_logic.hasCreatedOrModifiedTask."""
student_properties = {'is_student': True, 'scope': self.program}
student = seeder_logic.seed(GCIProfile, student_properties)
mentor_properties = {
'mentor_for': [self.foo_org.key()],
'is_mentor': True,
'scope': self.program
}
foo_mentor = seeder_logic.seed(GCIProfile, mentor_properties)
bar_mentor = seeder_logic.seed(GCIProfile, mentor_properties)
# Task is modified and created by another mentor.
task_utils.seedTask(self.program,
self.foo_org, [bar_mentor.key()],
student=student,
status=task_model.CLAIMED,
modified_by=bar_mentor,
created_by=bar_mentor)
self.assertFalse(profile_logic.hasCreatedOrModifiedTask(foo_mentor))
# Task is created by another mentor, but modified by given mentor.
task_utils.seedTask(self.program,
self.foo_org, [bar_mentor.key()],
student=student,
status=task_model.CLAIMED,
modified_by=foo_mentor,
created_by=bar_mentor)
self.assertTrue(profile_logic.hasCreatedOrModifiedTask(foo_mentor))
# Task is created by the given mentor, but modified by another mentor.
task_utils.seedTask(self.program,
self.foo_org, [bar_mentor.key()],
student=student,
status=task_model.CLAIMED,
modified_by=bar_mentor,
created_by=foo_mentor)
self.assertTrue(profile_logic.hasCreatedOrModifiedTask(foo_mentor))
# Task is modified and created by the given mentor.
task_utils.seedTask(self.program,
self.foo_org, [bar_mentor.key()],
student=student,
status=task_model.CLAIMED,
modified_by=foo_mentor,
created_by=foo_mentor)
self.assertTrue(profile_logic.hasCreatedOrModifiedTask(foo_mentor))
def testQueryAllMentorsKeysForOrg(self):
"""Tests that a list of keys for all the mentors in an organization are
returned.
"""
def runTest(org, mentors, org_admins):
"""Runs the test.
"""
mentor_keys = [entity.key() for entity in mentors]
org_admin_keys = [entity.key() for entity in org_admins]
expected_keys = set(mentor_keys + org_admin_keys)
actual_keys = set(profile_logic.queryAllMentorsKeysForOrg(org))
self.assertEqual(expected_keys, actual_keys)
#Test for foo_organization
mentors = self.foo_mentors
org_admins = self.foo_org_admins
org = self.foo_organization
runTest(org, mentors, org_admins)
#Test the same for bar_organization
mentors = self.bar_mentors
org_admins = [self.bar_org_admin]
org = self.bar_organization
runTest(org, mentors, org_admins)
#Create an organization which has no mentors and org_admins and test that
#an empty list is returned.
organization_properties = {'program': self.program}
org = seeder_logic.seed(GSoCOrganization, organization_properties)
mentors = []
org_admins = []
runTest(org, mentors, org_admins)
def testGetSlotTransferEntitiesForOrg(self):
"""Tests if all the slot transfer entities for an organization is returned.
"""
#Every organization has a single slot transfer entity.
expected = self.slot_transfer_entities[0]
actual = slot_transfer_logic.getSlotTransferEntitiesForOrg(
self.org_entities[0])
self.assertEqual(actual[0].key(), expected.key())
self.assertNotEqual(actual[0].key(), self.slot_transfer_entities[1].key())
#Multiple slot transfer entities for an organization. All the entities
#must be returned.
expected = [
entity.key() for entity in self.gsoc_organization_slot_transfer_entities]
slot_transfer_entities = slot_transfer_logic.getSlotTransferEntitiesForOrg(
self.gsoc_organization)
actual = [entity.key() for entity in slot_transfer_entities]
self.assertEqual(expected, actual)
#An organization has no slot transer entity
expected = []
organization = seeder_logic.seed(GSoCOrganization,
{'scope': self.gsoc_program})
actual = slot_transfer_logic.getSlotTransferEntitiesForOrg(organization)
self.assertEqual(expected, actual)
def setUp(self):
# seed an organization
self.org = seeder_logic.seed(org_model.GCIOrganization)
# seed a mentor
profile_properties = {
'is_mentor': True,
'mentor_for': [self.org.key()],
}
self.profile = seeder_logic.seed(profile_model.GCIProfile,
properties=profile_properties)
# seed a task
task_properties = {'org': self.org}
self.task = seeder_logic.seed(task_model.GCITask,
properties=task_properties)
def seedApplicationSurvey(program_key, **kwargs):
"""Seeds a new organization application survey for the specified program.
Args:
program_key: Program key to create a survey for.
kwargs: Optional values for other properties of the seeded entity.
Returns:
Newly seeded survey entity.
"""
user = profile_utils.seedNDBUser()
program = db.get(program_key)
properties = {
'scope': program_key,
'program': program_key,
'modified_by': user.key.to_old_key(),
'created_by': user.key.to_old_key(),
'author': user.key.to_old_key(),
'schema': ('[["item"],{"item":{"field_type":"input_text",'
'"required":false, "label":"test"}}]'),
'survey_content': None,
'key_name': '%s/%s/orgapp' % (program.prefix, program_key.name())
}
properties.update(kwargs)
return seeder_logic.seed(OrgAppSurvey, properties)
def testQueryAllMentorsKeysForOrg(self):
"""Tests that a list of keys for all the mentors in an organization are
returned.
"""
def runTest(org, mentors, org_admins):
"""Runs the test.
"""
mentor_keys = [entity.key() for entity in mentors]
org_admin_keys = [entity.key() for entity in org_admins]
expected_keys = set(mentor_keys + org_admin_keys)
actual_keys = set(profile_logic.queryAllMentorsKeysForOrg(org))
self.assertEqual(expected_keys, actual_keys)
#Test for foo_organization
mentors = self.foo_mentors
org_admins = self.foo_org_admins
org = self.foo_organization
runTest(org, mentors, org_admins)
#Test the same for bar_organization
mentors = self.bar_mentors
org_admins = [self.bar_org_admin]
org = self.bar_organization
runTest(org, mentors, org_admins)
#Create an organization which has no mentors and org_admins and test that
#an empty list is returned.
organization_properties = {'program': self.program}
org = seeder_logic.seed(GSoCOrganization, organization_properties)
mentors = []
org_admins = []
runTest(org, mentors, org_admins)
def createGSoCProposalDuplicate(self, student, program):
"""Creates and returns a seeded GSoCPropoposalDuplicate entity for
a given student in a given program.
"""
properties = {'program': program, 'student': student, 'is_duplicate': False}
proposal_duplicate = seeder_logic.seed(GSoCProposalDuplicate, properties)
return proposal_duplicate
def testOrgsForAnotherProgram(self):
"""Tests that status of organizations for another program is untouched."""
# seed another program
program = seeder_logic.seed(program_model.Program)
# seed a few pre-accepted and pre-rejected organizations
pre_accepted_orgs = []
for i in range(2):
org = org_utils.seedOrganization(
program.key(), org_id='pre_accepted_org_id_%s' % i,
status=org_model.Status.PRE_ACCEPTED)
pre_accepted_orgs.append(org.key)
pre_rejected_orgs = []
for i in range(3):
org = org_utils.seedOrganization(
program.key(), org_id='pre_rejrected_org_id_%s' % i,
status=org_model.Status.PRE_REJECTED)
pre_rejected_orgs.append(org.key)
mapreduce_control.start_map(
'ApplyOrgAdmissionDecisions', params=self.params)
test_support.execute_until_empty(self.get_task_queue_stub())
# check that pre-accepted organizations are still pre-accepted
for org_key in pre_accepted_orgs:
org = org_key.get()
self.assertEqual(org.status, org_model.Status.PRE_ACCEPTED)
# check that pre-rejected organizations are still pre-rejected
for org_key in pre_rejected_orgs:
org = org_key.get()
self.assertEqual(org.status, org_model.Status.PRE_REJECTED)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.program = seeder_logic.seed(program_model.Program)
self.org = org_utils.seedOrganization(
self.program.key(), org_id=TEST_ORG_ID, name=TEST_ORG_NAME)
self.app_response = survey_model.SurveyResponse(parent=self.org.key)
self.app_response.put()
def testGetProposalsToBeAcceptedForOrg(self):
"""Tests if all GSoCProposals to be accepted into a program for a given
organization are returned.
"""
#Test that for organization which has been allotted all its slots, an empty
#list is returned.
org = self.foo_organization
expected = []
actual = proposal_logic.getProposalsToBeAcceptedForOrg(org)
self.assertEqual(expected, actual)
#Test that for an organization which has empty slots, only accepted
#proposals are returned. We have both accepted and rejected proposals for
#bar_organization.
org = self.bar_organization
expected_proposals_entities = self.bar_to_be_accepted_proposals
expected = set([prop.key() for prop in expected_proposals_entities])
actual_proposals_entities = proposal_logic.getProposalsToBeAcceptedForOrg(org)
actual = set([prop.key() for prop in actual_proposals_entities])
self.assertEqual(expected, actual)
#Since self.happy_organization has more accepted projects than the available
#slots, a proposal with a higher score should be returned.
actual_proposals_entities = proposal_logic.getProposalsToBeAcceptedForOrg(
self.happy_organization)
actual = [prop.key() for prop in actual_proposals_entities]
expected = [self.happy_accepted_proposals[1].key()]
self.assertEqual(actual, expected)
#Create an organization which has empty slots but no accepted projects.
properties = {'scope': self.program, 'slots': 5}
organization = seeder_logic.seed(GSoCOrganization, properties)
expected = []
actual = proposal_logic.getProposalsToBeAcceptedForOrg(organization)
self.assertEqual(actual, expected)
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 seedApplicationSurvey(program_key, **kwargs):
"""Seeds a new organization application survey for the specified program.
Args:
program_key: Program key to create a survey for.
kwargs: Optional values for other properties of the seeded entity.
Returns:
Newly seeded survey entity.
"""
user = profile_utils.seedNDBUser()
program = db.get(program_key)
properties = {
'scope':
program_key,
'program':
program_key,
'modified_by':
user.key.to_old_key(),
'created_by':
user.key.to_old_key(),
'author':
user.key.to_old_key(),
'schema': ('[["item"],{"item":{"field_type":"input_text",'
'"required":false, "label":"test"}}]'),
'survey_content':
None,
'key_name':
'%s/%s/orgapp' % (program.prefix, program_key.name())
}
properties.update(kwargs)
return seeder_logic.seed(OrgAppSurvey, 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 seedTask(program, org, mentors, student=None, **kwargs):
"""Seeds a new task.
Args:
program: Program to which the task belongs.
org: Organization to which the task belongs.
mentors: List of mentor profile keys assigned to the task.
student: Profile entity of the student assigned to the task.
Returns:
A newly seeded task entity.
"""
properties = {
'program': program,
'org': org,
'status': task_model.OPEN,
'task_type': program.task_types[0],
'mentors': mentors,
'student': student,
'user': student.parent() if student else None,
'created_by': mentors[0] if mentors else None,
'modified_by': mentors[0] if mentors else None,
'created_on': datetime.datetime.now() - datetime.timedelta(20),
'modified_on': datetime.datetime.now() - datetime.timedelta(10)
}
properties.update(**kwargs)
return seeder_logic.seed(task_model.GCITask, properties,
auto_seed_optional_properties=False)
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 testOrgsForAnotherProgram(self):
"""Tests that status of organizations for another program is untouched."""
# seed another program
program = seeder_logic.seed(program_model.Program)
# seed a few pre-accepted and pre-rejected organizations
pre_accepted_orgs = []
for i in range(2):
org = org_utils.seedOrganization(
program.key(),
org_id='pre_accepted_org_id_%s' % i,
status=org_model.Status.PRE_ACCEPTED)
pre_accepted_orgs.append(org.key)
pre_rejected_orgs = []
for i in range(3):
org = org_utils.seedOrganization(
program.key(),
org_id='pre_rejrected_org_id_%s' % i,
status=org_model.Status.PRE_REJECTED)
pre_rejected_orgs.append(org.key)
mapreduce_control.start_map('ApplyOrgAdmissionDecisions',
params=self.params)
test_support.execute_until_empty(self.get_task_queue_stub())
# check that pre-accepted organizations are still pre-accepted
for org_key in pre_accepted_orgs:
org = org_key.get()
self.assertEqual(org.status, org_model.Status.PRE_ACCEPTED)
# check that pre-rejected organizations are still pre-rejected
for org_key in pre_rejected_orgs:
org = org_key.get()
self.assertEqual(org.status, org_model.Status.PRE_REJECTED)
