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): # 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.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.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() # 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): # 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): # 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): """See unittest.TestCase.setUp for specification.""" self.init() self.pre_accepted_org = org_utils.seedSOCOrganization( self.program.key(), status=org_model.Status.PRE_ACCEPTED) self.pre_rejected_org = org_utils.seedSOCOrganization( self.program.key(), status=org_model.Status.PRE_REJECTED) self.accepted_org = org_utils.seedSOCOrganization( self.program.key(), status=org_model.Status.ACCEPTED) self.rejected_org = org_utils.seedSOCOrganization( self.program.key(), status=org_model.Status.REJECTED) self.applying_org = org_utils.seedSOCOrganization( self.program.key(), status=org_model.Status.APPLYING)
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 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 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].key) 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.organization.key) actual = [entity.key() for entity in slot_transfer_entities] self.assertEqual(expected, actual) # An organization has no slot transfer entity expected = [] other_organization = org_utils.seedSOCOrganization(self.program.key()) actual = slot_transfer_logic.getSlotTransferEntitiesForOrg( other_organization.key) self.assertEqual(expected, actual)
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. expected = [] actual = proposal_logic.getProposalsToBeAcceptedForOrg( self.foo_organization) 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. 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(self.bar_organization)) 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. organization = org_utils.seedSOCOrganization( self.program.key(), slot_allocation=5) expected = [] actual = proposal_logic.getProposalsToBeAcceptedForOrg(organization) self.assertEqual(actual, expected)
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.key)) self.assertSetEqual(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. org = org_utils.seedSOCOrganization(self.program.key()) mentors = [] org_admins = [] runTest(org, mentors, org_admins)
def setUp(self): """See unittest.TestCase.setUp for specification.""" self.init() self.org = org_utils.seedSOCOrganization( self.program.key(), name=TEST_ORG_NAME) self.app_response = survey_model.SurveyResponse(parent=self.org.key) self.app_response.put()
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].key) 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.organization.key) actual = [entity.key() for entity in slot_transfer_entities] self.assertEqual(expected, actual) # An organization has no slot transfer entity expected = [] other_organization = org_utils.seedSOCOrganization(self.program.key()) actual = slot_transfer_logic.getSlotTransferEntitiesForOrg( other_organization.key) self.assertEqual(expected, actual)
def createNewOrg(self, override=None): """Creates a new organization for the defined properties. This new organization will not be stored in self.org but returned. """ if not self.program: self.createProgram() return org_utils.seedSOCOrganization(self.program.key(), **override or {})
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 testListData(self): """Tests that correct list data is loaded.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile = profile_utils.seedNDBProfile(self.program.key(), user=user) first_org = org_utils.seedSOCOrganization( self.program.key(), status=org_model.Status.ACCEPTED) connection_utils.seed_new_connection(profile.key, first_org.key) other_org = org_utils.seedSOCOrganization( self.program.key(), status=org_model.Status.ACCEPTED) connection_utils.seed_new_connection(profile.key, other_org.key) list_data = self.getListData(_getListForUserUrl(self.program), 0) # check that all two connections are listed self.assertEqual(len(list_data), 2)
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 an organization self.organization = org_utils.seedSOCOrganization(self.program.key()) # seed a new profile self.profile = profile_utils.seedNDBProfile(self.program.key())
def testInvalidData(self): """Tests that organization is not created if data is not valid.""" user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[self.org.key]) backup_admin = profile_utils.seedNDBProfile(self.program.key()) # valid set of data valid_postdata = { 'org_id': TEST_ORG_ID, 'name': TEST_ORG_NAME, 'blog': TEST_BLOG, 'description': TEST_DESCRIPTION, 'facebook': TEST_FACEBOOK, 'feed_url': TEST_FEED_URL, 'google_plus': TEST_GOOGLE_PLUS, 'license': TEST_LICENSE, 'logo_url': TEST_LOGO_URL, 'ideas_page': TEST_IDEAS_PAGE, 'irc_channel': TEST_IRC_CHANNEL, 'backup_admin': backup_admin.profile_id, 'mailing_list': TEST_MAILING_LIST, 'tags': TEST_TAGS, 'twitter': TEST_TWITTER, 'web_page': TEST_WEB_PAGE, 'eligible_country': True } # the organization is not from the eligible countries postdata = valid_postdata.copy() postdata['eligible_country'] = False response = self.post( _getOrgProfileCreateUrl(self.program), postdata=postdata) self.assertTrue(response.context['error']) # the organization with the same org_id already exists org_utils.seedSOCOrganization(self.program.key(), org_id='duplicate') postdata = valid_postdata.copy() postdata['org_id'] = 'duplicate' response = self.post( _getOrgProfileCreateUrl(self.program), postdata=postdata) self.assertResponseBadRequest(response)
def setUp(self): """See unittest.TestCase.setUp for specification.""" self.init() contact = contact_model.Contact(mailing_list=TEST_MAILING_LIST) self.org = org_utils.seedSOCOrganization( self.program.key(), org_id=TEST_ORG_ID, name=TEST_ORG_NAME, ideas_page=TEST_IDEAS_PAGE, tags=TEST_TAGS.split(','), contact=contact, is_veteran=not OTHER_TEST_IS_VETERAN) self.app_response = survey_model.SurveyResponse(parent=self.org.key) self.app_response.put()
def setUp(self): """See unittest.UnitTest.setUp for specification.""" self.init() contact = { 'blog': TEST_BLOG, 'mailing_list': TEST_MAILING_LIST, 'twitter': TEST_TWITTER, } self.org = org_utils.seedSOCOrganization( self.program.key(), contact=contact)
def testForOrgAdminForAnotherOrg(self): # seed another organization organization_two = org_utils.seedSOCOrganization(self.program.key()) profile = profile_utils.seedNDBProfile( self.program.key(), admin_for=[organization_two.key]) # profile with an org admin role can still become an org admin can_become = profile_logic.canBecomeOrgAdmin(profile) self.assertTrue(can_become)
def 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 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 testListData(self): """Tests that all connections for orgs administrated by user are listed.""" # seed another organization which is administrated by the user second_org = org_utils.seedSOCOrganization(self.program.key()) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile = profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[self.org.key, second_org.key]) # seed a few connections for first organization for _ in range(_NUMBER_OF_CONNECTIONS_FOR_MAIN_ORG): other_profile = profile_utils.seedNDBProfile(self.program.key()) connection_utils.seed_new_connection(other_profile.key, self.org.key) for _ in range(_NUMBER_OF_CONNECTIONS_FOR_SECOND_ORG): other_profile = profile_utils.seedNDBProfile(self.program.key()) connection_utils.seed_new_connection(other_profile.key, second_org.key) # seed another organization which is not administrated by the user third_org = org_utils.seedSOCOrganization(self.program.key()) # seed a few connections for the other organization for _ in range(_NUMBER_OF_CONNECTIONS_FOR_THIRD_ORG): other_profile = profile_utils.seedNDBProfile(self.program.key()) connection_utils.seed_new_connection(other_profile.key, third_org.key) list_data = self.getListData( _getListConnectionsForOrgAdminUrl(profile), 0) # check that all connections are listed: the ones created above for the main # org and the second plus two for the organization admin itself self.assertEqual( len(list_data), _NUMBER_OF_CONNECTIONS_FOR_MAIN_ORG + _NUMBER_OF_CONNECTIONS_FOR_SECOND_ORG + 2)
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): # 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 testCreateAnonymousConnection(self): """Test that an AnonymousConnection can be created successfully.""" program = program_utils.seedProgram() org = org_utils.seedSOCOrganization(program.key()) connection_logic.createAnonymousConnection(org=org, org_role=connection_model.MENTOR_ROLE, email='*****@*****.**') expected_expiration = datetime.today() + timedelta(7) connection = connection_model.AnonymousConnection.all().get() self.assertEquals(expected_expiration.date(), connection.expiration_date.date()) self.assertEquals(connection_model.MENTOR_ROLE, connection.org_role) self.assertEquals('*****@*****.**', connection.email)
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 seedProposal(student_key, program_key, org_key=None, mentor_key=None, **kwargs): """Seeds a new proposal entity. Args: student_key: Key of the student who is an author of the proposal. program_key: Key of the program to which the proposal applies. org_key: Key of the organization to which the proposal is submitted. mentor_key: Key of the mentor assigned to the proposal. Returns: The newly seeded proposal entity. """ org_key = org_key or org_utils.seedSOCOrganization(program_key).key mentor_key = mentor_key or profile_utils.seedNDBProfile( program_key, mentor_for=[org_key]).key properties = { 'scope': student_key.to_old_key(), 'score': 0, 'nr_scores': 0, 'is_publicly_visible': False, 'accept_as_project': False, 'is_editable_post_deadline': False, 'extra': None, 'parent': student_key.to_old_key(), 'status': 'pending', 'has_mentor': True, 'program': program_key, 'org': org_key.to_old_key(), 'mentor': mentor_key.to_old_key(), 'abstract': TEST_ABSTRACT, 'title': TEST_TITLE, 'content': TEST_CONTENT, } properties.update(**kwargs) proposal = proposal_model.GSoCProposal(**properties) proposal.put() if proposal.status != proposal_model.STATUS_WITHDRAWN: student = student_key.get() student.student_data.number_of_proposals += 1 student.put() return proposal
def testOrgAdminForAnotherOrgForbidden(self): self.timeline_helper.studentsAnnounced() other_org = org_utils.seedSOCOrganization(self.program.key()) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[other_org.key]) project = _createProjectForMentor(self.gsoc, self.org, self.dev_test) url = self._getProjectUpdateUrl(project) response = self.get(url) self.assertErrorTemplatesUsed(response) self.assertResponseForbidden(response)
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 testForMentorForTwoOrgs(self): # seed another organization organization_two = org_utils.seedSOCOrganization(self.program.key()) # make the profile a mentor for organization two self.mentor.mentor_for.append(organization_two.key) self.mentor.put() profile_logic.resignAsMentorForOrg(self.mentor, self.organization.key) # the profile is not a mentor for organization anymore self.assertNotIn(self.organization.key, self.mentor.mentor_for) # the profile should still be a mentor for organization_two self.assertTrue(self.mentor.is_mentor) self.assertIn(organization_two.key, self.mentor.mentor_for)
def testCreateAnonymousConnection(self): """Test that an AnonymousConnection can be created successfully.""" program = program_utils.seedProgram() org = org_utils.seedSOCOrganization(program.key()) connection_logic.createAnonymousConnection( org=org, org_role=connection_model.MENTOR_ROLE, email='*****@*****.**') expected_expiration = datetime.today() + timedelta(7) connection = connection_model.AnonymousConnection.all().get() self.assertEquals(expected_expiration.date(), connection.expiration_date.date()) self.assertEquals(connection_model.MENTOR_ROLE, connection.org_role) self.assertEquals('*****@*****.**', connection.email)
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 seedProject(student, program_key, proposal_key=None, org_key=None, mentor_key=None, **kwargs): """Seeds a new project entity. Args: student: Profile entity of the student who is an author of the project. program_key: Key of the program to which the project applies. proposal_key: Key of the proposal corresponding to the project. org_key: Key of the organization to which the project is submitted. mentor_key: Key of the mentor assigned to the project. Returns: The newly seeded project entity. """ org_key = org_key or org_utils.seedSOCOrganization(program_key).key mentor_key = mentor_key or profile_utils.seedNDBProfile( program_key, mentor_for=[org_key]).key proposal_key = proposal_key or proposal_utils.seedProposal( student.key, program_key, org_key=org_key, mentor_key=mentor_key).key() properties = { 'program': program_key, 'org': org_key.to_old_key(), 'status': project_model.STATUS_ACCEPTED, 'parent': student.key.to_old_key(), 'mentors': [mentor_key.to_old_key()], 'proposal': proposal_key, 'title': TEST_TITLE, 'abstract': TEST_ABSTRACT, } properties.update(**kwargs) project = project_model.GSoCProject(**properties) project.put() student.student_data.number_of_projects += 1 student.student_data.project_for_orgs.append(org_key) student.student_data.project_for_orgs = list( set(student.student_data.project_for_orgs)) student.put() return project
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 testOrgAdminForAnotherOrgForbidden(self): self.timeline_helper.studentsAnnounced() other_org = org_utils.seedSOCOrganization(self.program.key()) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile(self.program.key(), user=user, admin_for=[other_org.key]) project = _createProjectForMentor(self.gsoc, self.org, self.dev_test) url = self._getProjectUpdateUrl(project) response = self.get(url) self.assertErrorTemplatesUsed(response) self.assertResponseForbidden(response)
def seedProposal( student_key, program_key, org_key=None, mentor_key=None, **kwargs): """Seeds a new proposal entity. Args: student_key: Key of the student who is an author of the proposal. program_key: Key of the program to which the proposal applies. org_key: Key of the organization to which the proposal is submitted. mentor_key: Key of the mentor assigned to the proposal. Returns: The newly seeded proposal entity. """ org_key = org_key or org_utils.seedSOCOrganization(program_key).key mentor_key = mentor_key or profile_utils.seedNDBProfile( program_key, mentor_for=[org_key]).key properties = { 'scope': student_key.to_old_key(), 'score': 0, 'nr_scores': 0, 'is_publicly_visible': False, 'accept_as_project': False, 'is_editable_post_deadline': False, 'extra': None, 'parent': student_key.to_old_key(), 'status': 'pending', 'has_mentor': True, 'program': program_key, 'org': org_key.to_old_key(), 'mentor': mentor_key.to_old_key(), 'abstract': TEST_ABSTRACT, 'title': TEST_TITLE, 'content': TEST_CONTENT, } properties.update(**kwargs) proposal = proposal_model.GSoCProposal(**properties) proposal.put() if proposal.status != proposal_model.STATUS_WITHDRAWN: student = student_key.get() student.student_data.number_of_proposals += 1 student.put() return proposal
def testProjectList(self): """Tests that project list shows projects for the organization.""" self.timeline_helper.studentsAnnounced() # seed a few projects for the organization for _ in range(NUMBER_OF_PROJECTS): student = profile_utils.seedSOCStudent(self.program) project_utils.seedProject( student, self.program.key(), org_key=self.org.key) # seed a project for another organization other_org = org_utils.seedSOCOrganization(self.program.key()) student = profile_utils.seedSOCStudent(self.program) project_utils.seedProject( student, self.program.key(), org_key=other_org.key) # check that only orgs for the first organization are listed data = self.getListData(_getOrgHomeUrl(self.org), 0) self.assertEqual(NUMBER_OF_PROJECTS, len(data))
def seedProject( student, program_key, proposal_key=None, org_key=None, mentor_key=None, **kwargs): """Seeds a new project entity. Args: student: Profile entity of the student who is an author of the project. program_key: Key of the program to which the project applies. proposal_key: Key of the proposal corresponding to the project. org_key: Key of the organization to which the project is submitted. mentor_key: Key of the mentor assigned to the project. Returns: The newly seeded project entity. """ org_key = org_key or org_utils.seedSOCOrganization(program_key).key mentor_key = mentor_key or profile_utils.seedNDBProfile( program_key, mentor_for=[org_key]).key proposal_key = proposal_key or proposal_utils.seedProposal( student.key, program_key, org_key=org_key, mentor_key=mentor_key).key() properties = { 'program': program_key, 'org': org_key.to_old_key(), 'status': project_model.STATUS_ACCEPTED, 'parent': student.key.to_old_key(), 'mentors': [mentor_key.to_old_key()], 'proposal': proposal_key, 'title': TEST_TITLE, 'abstract': TEST_ABSTRACT, } properties.update(**kwargs) project = project_model.GSoCProject(**properties) project.put() student.student_data.number_of_projects += 1 student.student_data.project_for_orgs.append(org_key) student.student_data.project_for_orgs = list( set(student.student_data.project_for_orgs)) student.put() return project
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 testForOtherOrgAdmin(self): other_org = org_utils.seedSOCOrganization(self.program.key()) user = profile_utils.seedNDBUser() profile_utils.loginNDB(user) profile_utils.seedNDBProfile( self.program.key(), user=user, admin_for=[self.org.key]) project = _createProjectForMentor(self.gsoc, other_org, self.dev_test) sponsor_id, program_id, user_id = project.parent_key().name().split('/') kwargs = { 'sponsor': sponsor_id, 'program': program_id, 'user': user_id, 'id': project.key().id(), } data = request_data.RequestData(None, None, kwargs) self.assertFalse(project_details._isUpdateLinkVisible(data))
def createOrg(self, override=None): """Creates an organization for the defined properties.""" return org_utils.seedSOCOrganization(self.program.key(), **override or {})
def setUp(self): """See unittest.TestCase.setUp for specification.""" self.init() self.org = org_utils.seedSOCOrganization(self.program.key())
def setUp(self): """See unittest.TestCase.testUp for specification.""" self.init() self.org = org_utils.seedSOCOrganization( self.program.key(), name=TEST_ORG_NAME, status=org_model.Status.ACCEPTED)