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)