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 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."""
# seed a new program
self.program = program_utils.seedProgram()
# seed a couple of organizations
self.organization_one = org_utils.seedOrganization(self.program.key())
self.organization_two = org_utils.seedOrganization(self.program.key())
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
# seed a new program
self.program = program_utils.seedProgram()
# seed a couple of organizations
self.organization_one = org_utils.seedOrganization(self.program.key())
self.organization_two = org_utils.seedOrganization(self.program.key())
# seed a new org admin for organization one
self.org_admin = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.organization_one.key])
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.program = program_utils.seedProgram()
self.orgs = []
# seed some accepted organizations
for _ in range(TEST_ORGS_NUMBER):
self.orgs.append(org_utils.seedOrganization(
self.program.key(), status=org_model.Status.ACCEPTED))
# seed some rejected organizations
for _ in range(TEST_ORGS_NUMBER):
self.orgs.append(org_utils.seedOrganization(
self.program.key(), status=org_model.Status.REJECTED))
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
program = program_utils.seedProgram()
profile = profile_utils.seedNDBProfile(program.key())
org = org_utils.seedOrganization(program.key())
self.connection = connection_utils.seed_new_connection(
profile.key, org.key)
def testSuccessfulActivation(self):
"""Test that given a valid token and date, an AnonymousConnection will be
used to activate a new Connection for the user."""
org = org_utils.seedOrganization(self.program.key())
profile = profile_utils.seedNDBProfile(self.program.key())
connection_logic.createAnonymousConnection(
'*****@*****.**', org, connection_model.ORG_ADMIN_ROLE)
anonymous_connection = connection_model.AnonymousConnection.all().get()
connection_logic.activateAnonymousConnection(
profile, anonymous_connection.token)
query = connection_model.Connection.query(
connection_model.Connection.org_role ==
connection_model.ORG_ADMIN_ROLE,
ancestor=profile.key)
connection = query.get()
self.assertEquals(connection.user_role, connection_model.NO_ROLE)
self.assertEquals(connection.organization, org.key)
anonymous_connection = connection_model.AnonymousConnection.all().get()
self.assertIsNone(anonymous_connection)
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 setUp(self):
"""See unittest.TestCase.setUp for specification."""
# seed two programs for the same sponsor
sponsor = program_utils.seedSponsor()
self.program_one = program_utils.seedProgram(sponsor_key=sponsor.key())
program_two = program_utils.seedProgram(sponsor_key=sponsor.key())
org_one = org_utils.seedOrganization(self.program_one.key())
org_two = org_utils.seedOrganization(program_two.key())
self.mentor_keys = set()
# seed a few mentors for both programs
for _ in range(_NUMBER_OF_MENTORS):
self.mentor_keys.add(profile_utils.seedNDBProfile(
self.program_one.key(), mentor_for=[org_one.key]).key)
profile_utils.seedNDBProfile(program_two.key(), mentor_for=[org_two.key])
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.program = program_utils.seedProgram()
self.profile = profile_utils.seedNDBProfile(self.program.key())
org = org_utils.seedOrganization(self.program.key())
self.connection = connection_utils.seed_new_connection(
self.profile.key, org.key)
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 setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.program = program_utils.seedProgram()
self.orgs = []
# seed some accepted organizations
for _ in range(TEST_ORGS_NUMBER):
self.orgs.append(
org_utils.seedOrganization(self.program.key(),
status=org_model.Status.ACCEPTED))
# seed some rejected organizations
for _ in range(TEST_ORGS_NUMBER):
self.orgs.append(
org_utils.seedOrganization(self.program.key(),
status=org_model.Status.REJECTED))
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
program = program_utils.seedProgram()
# seed an organization
self.org = org_utils.seedOrganization(program.key())
# seed a profile
self.profile = profile_utils.seedNDBProfile(program.key())
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
program = program_utils.seedProgram()
# seed a few organizations
self.first_org = org_utils.seedOrganization(program.key())
self.second_org = org_utils.seedOrganization(program.key())
self.third_org = org_utils.seedOrganization(program.key())
# seed a few profiles
first_profile = profile_utils.seedNDBProfile(program.key())
second_profile = profile_utils.seedNDBProfile(program.key())
self.first_connection = connection_utils.seed_new_connection(
first_profile.key, self.first_org.key)
self.second_connection = connection_utils.seed_new_connection(
second_profile.key, self.first_org.key)
self.third_connection = connection_utils.seed_new_connection(
first_profile.key, self.second_org.key)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
program = program_utils.seedProgram()
# seed a few organizations
self.first_org = org_utils.seedOrganization(program.key())
self.second_org = org_utils.seedOrganization(program.key())
self.third_org = org_utils.seedOrganization(program.key())
# seed a few profiles
first_profile = profile_utils.seedNDBProfile(program.key())
second_profile = profile_utils.seedNDBProfile(program.key())
self.first_connection = connection_utils.seed_new_connection(
first_profile.key, self.first_org.key)
self.second_connection = connection_utils.seed_new_connection(
second_profile.key, self.first_org.key)
self.third_connection = connection_utils.seed_new_connection(
first_profile.key, self.second_org.key)
def testQueryForAnonymousConnection(self):
"""Test that the function will correctly fetch AnonymousConnection objects
given a valid token."""
program = program_utils.seedProgram()
org = org_utils.seedOrganization(program.key())
connection_logic.createAnonymousConnection(org=org,
org_role=connection_model.MENTOR_ROLE, email='*****@*****.**')
token = connection_model.AnonymousConnection.all().get().token
connection = connection_logic.queryAnonymousConnectionForToken(token)
self.assertIsNotNone(connection)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
program = program_utils.seedProgram()
self.org_app = program_utils.seedApplicationSurvey(program.key())
self.org = org_utils.seedOrganization(program.key())
self.kwargs = {
'sponsor': org_model.getSponsorId(self.org.key),
'program': org_model.getProgramId(self.org.key),
'organization': org_model.getOrgId(self.org.key)
}
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
program = program_utils.seedProgram()
self.org_app = program_utils.seedApplicationSurvey(program.key())
self.org = org_utils.seedOrganization(program.key())
self.kwargs = {
'sponsor': org_model.getSponsorId(self.org.key),
'program': org_model.getProgramId(self.org.key),
'organization': org_model.getOrgId(self.org.key)
}
def testOrganization(self):
"""Tests organization function."""
# seed a program
program = program_utils.seedProgram()
# seed an organization
organization = org_utils.seedOrganization(program.key())
url = self.linker.organization(
organization.key, soc_urls.UrlNames.ORG_PROFILE_EDIT)
self.assertEqual(
'/gsoc/org/profile/edit/%s' % organization.key.id(), url)
def testMentorDeniedAccess(self):
"""Tests that a mentor is denied access."""
# seed a profile who is a mentor
org = org_utils.seedOrganization(self.program.key())
profile_utils.seedNDBProfile(
self.program.key(), user=self.user, mentor_for=[org.key])
access_checker = access.ProgramAdministratorAccessChecker()
with self.assertRaises(exception.UserError) as context:
access_checker.checkAccess(self.data, None)
self.assertEqual(context.exception.message,
access._MESSAGE_NOT_PROGRAM_ADMINISTRATOR)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
self.org = org_utils.seedOrganization(program.key())
kwargs = {
'sponsor': sponsor.key().name(),
'program': program.program_id,
'organization': self.org.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.seedProgram(sponsor_key=sponsor.key())
self.org = org_utils.seedOrganization(program.key())
kwargs = {
'sponsor': sponsor.key().name(),
'program': program.program_id,
'organization': self.org.org_id,
}
self.data = request_data.RequestData(None, None, kwargs)
def testConnectionDoesNotExist(self):
"""Tests that False is returned if connection does not exist."""
# seed a connection between the org and another profile
other_profile = profile_utils.seedNDBProfile(self.program.key())
connection_utils.seed_new_connection(other_profile.key, self.org.key)
# seed a connection between the profile and another org
other_org = org_utils.seedOrganization(self.program.key())
connection_utils.seed_new_connection(self.profile.key, other_org.key)
self.assertFalse(
connection_logic.connectionExists(self.profile.key, self.org.key))
def testConnectionDoesNotExist(self):
"""Tests that False is returned if connection does not exist."""
# seed a connection between the org and another profile
other_profile = profile_utils.seedNDBProfile(self.program.key())
connection_utils.seed_new_connection(other_profile.key, self.org.key)
# seed a connection between the profile and another org
other_org = org_utils.seedOrganization(self.program.key())
connection_utils.seed_new_connection(self.profile.key, other_org.key)
self.assertFalse(
connection_logic.connectionExists(self.profile.key, self.org.key))
def testMentorDeniedAccess(self):
"""Tests that a mentor is denied access."""
# seed a profile who is a mentor
org = org_utils.seedOrganization(self.program.key())
profile_utils.seedNDBProfile(self.program.key(),
user=self.user,
mentor_for=[org.key])
access_checker = access.ProgramAdministratorAccessChecker()
with self.assertRaises(exception.UserError) as context:
access_checker.checkAccess(self.data, None)
self.assertEqual(context.exception.message,
access._MESSAGE_NOT_PROGRAM_ADMINISTRATOR)
def testQueryForAnonymousConnection(self):
"""Test that the function will correctly fetch AnonymousConnection objects
given a valid token."""
program = program_utils.seedProgram()
org = org_utils.seedOrganization(program.key())
connection_logic.createAnonymousConnection(
org=org,
org_role=connection_model.MENTOR_ROLE,
email='*****@*****.**')
token = connection_model.AnonymousConnection.all().get().token
connection = connection_logic.queryAnonymousConnectionForToken(token)
self.assertIsNotNone(connection)
def testForRoleForManyOrgs(self):
"""Tests that the user still have roles for other organizations."""
# seed another organization
other_org = org_utils.seedOrganization(self.program.key())
self.profile.mentor_for = [self.org.key, other_org.key]
self.profile.org_admin_for = [self.org.key]
self.profile.put()
profile_logic.assignNoRoleForOrg(self.profile, self.org.key)
self.assertTrue(self.profile.is_mentor)
self.assertListEqual(self.profile.mentor_for, [other_org.key])
self.assertFalse(self.profile.is_admin)
self.assertListEqual(self.profile.admin_for, [])
def testForMentorForAnotherOrg(self):
"""Tests that a user is still only a mentor for another organization."""
# seed another organization
other_org = org_utils.seedOrganization(self.program.key())
self.profile.mentor_for = [other_org.key]
self.profile.put()
profile_logic.assignOrgAdminRoleForOrg(self.profile, self.org.key)
self.assertTrue(self.profile.is_mentor)
self.assertIn(self.org.key, self.profile.mentor_for)
self.assertIn(other_org.key, self.profile.mentor_for)
self.assertTrue(self.profile.is_admin)
self.assertListEqual(self.profile.admin_for, [self.org.key])
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
self.survey = program_utils.seedApplicationSurvey(program.key())
# seed some organizations with survey responses
self.app_responses = set()
for _ in range(TEST_ORGS_NUMBER):
org = org_utils.seedOrganization(program.key())
self.app_responses.add(
org_utils.seedApplication(org.key, self.survey.key()).key)
# seed some organizations without survey responses
for _ in range(TEST_ORGS_NUMBER):
org_utils.seedOrganization(program.key())
other_program = program_utils.seedProgram(sponsor_key=sponsor.key())
other_survey = program_utils.seedApplicationSurvey(other_program.key())
# seed some organizations with survey responses for other survey
for _ in range(TEST_ORGS_NUMBER):
org = org_utils.seedOrganization(other_program.key())
org_utils.seedApplication(org.key, other_survey.key())
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
self.survey = program_utils.seedApplicationSurvey(program.key())
# seed some organizations with survey responses
self.app_responses = set()
for _ in range(TEST_ORGS_NUMBER):
org = org_utils.seedOrganization(program.key())
self.app_responses.add(
org_utils.seedApplication(org.key, self.survey.key()).key)
# seed some organizations without survey responses
for _ in range(TEST_ORGS_NUMBER):
org_utils.seedOrganization(program.key())
other_program = program_utils.seedProgram(sponsor_key=sponsor.key())
other_survey = program_utils.seedApplicationSurvey(other_program.key())
# seed some organizations with survey responses for other survey
for _ in range(TEST_ORGS_NUMBER):
org = org_utils.seedOrganization(other_program.key())
org_utils.seedApplication(org.key, other_survey.key())
def testExpiredConnection(self):
"""Test that a user is prevented from activating a Connection that was
created more than a week ago."""
org = org_utils.seedOrganization(self.program.key())
profile = profile_utils.seedNDBProfile(self.program.key())
connection_logic.createAnonymousConnection(
org=org, org_role=connection_model.ORG_ADMIN_ROLE,
email='*****@*****.**')
# Cause the anonymous connection to "expire."
anonymous_connection = connection_model.AnonymousConnection.all().get()
anonymous_connection.expiration_date = datetime.today() - timedelta(1)
anonymous_connection.put()
with self.assertRaises(ValueError):
connection_logic.activateAnonymousConnection(profile, 'bad token')
def testUserOrg(self):
"""Tests userOrg function."""
# seed a program
program = program_utils.seedProgram()
# seed a profile
profile = profile_utils.seedNDBProfile(program.key())
# seed an organization
org = org_utils.seedOrganization(program.key())
self.assertEqual(
'/gci/student_tasks_for_org/%s/%s/%s' % (program.key().name(),
profile.key.parent().id(), org.org_id),
self.linker.userOrg(
profile.key, org.key, gci_url_names.GCI_STUDENT_TASKS_FOR_ORG))
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.init()
# TODO(daniel): it should not seed GSoC Program here
self.program = program_utils.seedGSoCProgram()
properties = {'parent': self.program}
seeder_logic.seed(program_model.ProgramMessages, properties=properties)
self.site = program_utils.seedSite()
self.org = org_utils.seedOrganization(self.program.key())
self.profile = profile_utils.seedNDBProfile(self.program.key(),
admin_for=[self.org.key])
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.init()
# TODO(daniel): it should not seed GSoC Program here
self.program = program_utils.seedGSoCProgram()
properties = {'parent': self.program}
seeder_logic.seed(program_model.ProgramMessages, properties=properties)
self.site = program_utils.seedSite()
self.org = org_utils.seedOrganization(self.program.key())
self.profile = profile_utils.seedNDBProfile(
self.program.key(), admin_for=[self.org.key])
def testExpiredConnection(self):
"""Test that a user is prevented from activating a Connection that was
created more than a week ago."""
org = org_utils.seedOrganization(self.program.key())
profile = profile_utils.seedNDBProfile(self.program.key())
connection_logic.createAnonymousConnection(
org=org,
org_role=connection_model.ORG_ADMIN_ROLE,
email='*****@*****.**')
# Cause the anonymous connection to "expire."
anonymous_connection = connection_model.AnonymousConnection.all().get()
anonymous_connection.expiration_date = datetime.today() - timedelta(1)
anonymous_connection.put()
with self.assertRaises(ValueError):
connection_logic.activateAnonymousConnection(profile, 'bad token')
def testConnectionExists(self):
"""Tests that connection is returned correctly if exists."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
org = org_utils.seedOrganization(program.key())
profile = profile_utils.seedNDBProfile(program.key())
connection = connection_utils.seed_new_connection(profile.key, org.key)
kwargs = {
'sponsor': sponsor.link_id,
'program': program.program_id,
'user': profile.profile_id,
'id': str(connection.key.id())
}
data = request_data.RequestData(None, None, kwargs)
url_connection = data.url_connection
self.assertEqual(connection.key, url_connection.key)
def testConnectionExists(self):
"""Tests that connection is returned correctly if exists."""
sponsor = program_utils.seedSponsor()
program = program_utils.seedProgram(sponsor_key=sponsor.key())
org = org_utils.seedOrganization(program.key())
profile = profile_utils.seedNDBProfile(program.key())
connection = connection_utils.seed_new_connection(profile.key, org.key)
kwargs = {
'sponsor': sponsor.link_id,
'program': program.program_id,
'user': profile.profile_id,
'id': str(connection.key.id())
}
data = request_data.RequestData(None, None, kwargs)
url_connection = data.url_connection
self.assertEqual(connection.key, url_connection.key)
def testCorrectMessagesReturned(self):
"""Tests that correct messages are returned."""
# seed a couple of messages for the connection
message1 = connection_utils.seed_new_connection_message(
self.connection.key, author=self.profile.key)
message2 = connection_utils.seed_new_connection_message(self.connection.key)
# seed another organization and a connection
other_org = org_utils.seedOrganization(self.program.key())
other_connection = connection_utils.seed_new_connection(
self.profile.key, other_org.key)
# create a few messages for the other connection
for _ in range(4):
connection_utils.seed_new_connection_message(
other_connection.key, author=self.profile.key)
# check that only correct messages are returned
messages = connection_logic.getConnectionMessages(self.connection.key)
expected_keys = set([message1.key, message2.key])
actual_keys = set([message.key for message in messages])
self.assertEqual(actual_keys, expected_keys)
def testCorrectMessagesReturned(self):
"""Tests that correct messages are returned."""
# seed a couple of messages for the connection
message1 = connection_utils.seed_new_connection_message(
self.connection.key, author=self.profile.key)
message2 = connection_utils.seed_new_connection_message(
self.connection.key)
# seed another organization and a connection
other_org = org_utils.seedOrganization(self.program.key())
other_connection = connection_utils.seed_new_connection(
self.profile.key, other_org.key)
# create a few messages for the other connection
for _ in range(4):
connection_utils.seed_new_connection_message(
other_connection.key, author=self.profile.key)
# check that only correct messages are returned
messages = connection_logic.getConnectionMessages(self.connection.key)
expected_keys = set([message1.key, message2.key])
actual_keys = set([message.key for message in messages])
self.assertEqual(actual_keys, expected_keys)
def testSuccessfulActivation(self):
"""Test that given a valid token and date, an AnonymousConnection will be
used to activate a new Connection for the user."""
org = org_utils.seedOrganization(self.program.key())
profile = profile_utils.seedNDBProfile(self.program.key())
connection_logic.createAnonymousConnection(
'*****@*****.**', org, connection_model.ORG_ADMIN_ROLE)
anonymous_connection = connection_model.AnonymousConnection.all().get()
connection_logic.activateAnonymousConnection(
profile, anonymous_connection.token)
query = connection_model.Connection.query(
connection_model.Connection.org_role == connection_model.ORG_ADMIN_ROLE,
ancestor=profile.key)
connection = query.get()
self.assertEquals(connection.user_role, connection_model.NO_ROLE)
self.assertEquals(connection.organization, org.key)
anonymous_connection = connection_model.AnonymousConnection.all().get()
self.assertIsNone(anonymous_connection)
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.init()
# seed a few organizations; some of them are pre-rejected, some are
# pre-accepted and some organizations on which no decisions have been taken;
# the last group should not occur in production but this will check that
# "undecided" organizations are not processed by the mapper
seeded_orgs = ([], [], [])
statuses = (
org_model.Status.PRE_ACCEPTED,
org_model.Status.PRE_REJECTED,
org_model.Status.APPLYING)
for i in range(4 * len(statuses)):
org = org_utils.seedOrganization(
self.program.key(), org_id='org_id_%s' % i,
status=statuses[i % len(statuses)])
seeded_orgs[i % len(statuses)].append(org.key)
self.admins = []
for i in range(int(1.5 * len(seeded_orgs))):
admin = profile_utils.seedNDBProfile(
self.program.key(), admin_for=seeded_orgs[i % len(seeded_orgs)])
self.admins.append(admin)
self.program_messages = self.program.getProgramMessages()
self.pre_accepted_orgs = seeded_orgs[0]
self.pre_rejected_orgs = seeded_orgs[1]
self.applying_orgs = seeded_orgs[2]
# set parameters of the MapReduce job
self.params = {
'entity_kind': 'melange.models.organization.Organization',
'program_key': str(self.program.key())
}
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
self.init()
# seed a few organizations; some of them are pre-rejected, some are
# pre-accepted and some organizations on which no decisions have been taken;
# the last group should not occur in production but this will check that
# "undecided" organizations are not processed by the mapper
seeded_orgs = ([], [], [])
statuses = (org_model.Status.PRE_ACCEPTED,
org_model.Status.PRE_REJECTED, org_model.Status.APPLYING)
for i in range(4 * len(statuses)):
org = org_utils.seedOrganization(self.program.key(),
org_id='org_id_%s' % i,
status=statuses[i %
len(statuses)])
seeded_orgs[i % len(statuses)].append(org.key)
self.admins = []
for i in range(int(1.5 * len(seeded_orgs))):
admin = profile_utils.seedNDBProfile(
self.program.key(),
admin_for=seeded_orgs[i % len(seeded_orgs)])
self.admins.append(admin)
self.program_messages = self.program.getProgramMessages()
self.pre_accepted_orgs = seeded_orgs[0]
self.pre_rejected_orgs = seeded_orgs[1]
self.applying_orgs = seeded_orgs[2]
# set parameters of the MapReduce job
self.params = {
'entity_kind': 'melange.models.organization.Organization',
'program_key': str(self.program.key())
}
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
program = seeder_logic.seed(program_model.Program)
self.org = org_utils.seedOrganization(program.key())
self.survey_key = db.Key.from_path('Survey', 'test_survey_name')
def setUp(self):
"""See unittest.TestCase.setUp for specification."""
program = seeder_logic.seed(program_model.Program)
self.org = org_utils.seedOrganization(program.key())
self.survey_key = db.Key.from_path('Survey', 'test_survey_name')
