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 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 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 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 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 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 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 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 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 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 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)
