def test_create(self):
"""Anyone can create a team with themselves as captain."""
# Success.
user, team_dict = self.create()
self.assertEqual(team_dict['captain_id'], user.uid)
fetched_user = User.get_by_id(user.uid)
self.assertEqual(fetched_user.owned_teams, [team_dict['uid']])
# Program not found.
team_params = {'name': 'Team Foo', 'program_id': 'Program_dne'}
self.testapp.post_json(
'/api/teams',
team_params,
headers=self.login_headers(user),
status=400,
)
# Inactive program.
inactive_program = Program.create(
name="Inactive Program",
label='inactive',
active=False,
preview_url='foo.com',
)
inactive_program.put()
self.testapp.post_json(
'/api/teams',
dict(team_params, program_id=inactive_program.uid),
headers=self.login_headers(user),
status=400,
)
def test_team_in_program_with_use_cycles_false_gets_single_cycle(self):
user = User.create(name='foo', email='*****@*****.**')
user.put()
cycleless_program = Program.create(
label='cycleless',
name='Cycleless Program',
preview_url='http://cycle.less',
use_cycles=False,
min_cycles=1,
max_cycles=1
)
cycleless_program.put()
cycleless_team_params = {
"name": 'Cycleless Team',
"uid": 'Team_cycleless',
"program_id": cycleless_program.uid
}
response = self.testapp.post_json(
'/api/teams',
cycleless_team_params,
headers=self.login_headers(user)
)
team_uid = json.loads(response.body)['uid']
cycles = Cycle.get(team_id=team_uid)
self.assertEqual(len(cycles), 1)
def set_up(self):
# Let ConsistencyTestCase set up the datastore testing stub.
super(TestApiNetworks, self).set_up()
application = webapp2.WSGIApplication(api_routes,
config={
'webapp2_extras.sessions': {
'secret_key':
self.cookie_key
}
},
debug=True)
self.testapp = webtest.TestApp(application)
with mysql_connection.connect() as sql:
sql.reset({
'network': Network.get_table_definition(),
'organization': Organization.get_table_definition(),
'program': Program.get_table_definition(),
'user': User.get_table_definition(),
})
self.program = Program.create(
name="Engagement Project",
label='ep18',
min_cycles=3,
active=True,
preview_url='foo.com',
)
self.program.put()
def set_up(self):
# Let ConsistencyTestCase set up the datastore testing stub.
super(TestApiSurveys, self).set_up()
application = webapp2.WSGIApplication(api_routes,
config={
'webapp2_extras.sessions': {
'secret_key':
self.cookie_key
}
},
debug=True)
self.testapp = webtest.TestApp(application)
with mysql_connection.connect() as sql:
sql.reset({
'classroom': Classroom.get_table_definition(),
'metric': Metric.get_table_definition(),
'program': Program.get_table_definition(),
'survey': Survey.get_table_definition(),
'team': Team.get_table_definition(),
'user': User.get_table_definition(),
})
self.ep_program = Program.create(
name="Engagement Project",
label='ep18',
active=True,
preview_url='foo.com',
)
self.ep_program.put()
def test_create_for_team(self):
"""Should populate only with metrics active by default."""
metric1 = Metric.create(name="Community of Helpers",
label='community_of_helpers')
metric1.put()
metric2 = Metric.create(name="Feedback for Growth",
label='feedback_for_growth')
metric2.put()
program = Program.create(
name='Test Program',
label='test-program',
metrics=[
{
'uid': metric1.uid,
'default_active': True
},
{
'uid': metric2.uid,
'default_active': False
},
],
preview_url='foo.com',
)
program.put()
team = Team.create(
captain_id='User_captain',
program_id=program.uid,
)
survey = Survey.create_for_team(team)
self.assertEqual(survey.metrics, [metric1.uid])
self.assertEqual(survey.open_responses, [metric1.uid])
self.assertEqual(survey.meta, {})
def set_up(self):
# Let ConsistencyTestCase set up the datastore testing stub.
super(TestApiParticipants, self).set_up()
application = self.patch_webapp(webapp2.WSGIApplication)(
api_routes,
config={
'webapp2_extras.sessions': {
'secret_key': self.cookie_key
}
},
debug=True)
self.testapp = webtest.TestApp(application)
with mysql_connection.connect() as sql:
sql.reset({
'classroom': Classroom.get_table_definition(),
'cycle': Cycle.get_table_definition(),
'participant': Participant.get_table_definition(),
'program': Program.get_table_definition(),
'team': Team.get_table_definition(),
'user': User.get_table_definition(),
})
self.program = Program.create(
name="Engagement Project",
label='ep18',
min_cycles=3,
active=True,
preview_url='foo.com',
)
self.program.put()
def test_rserve_skips_existing(self):
program = Program.create(
name="The Engagement Project",
label="ep19",
preview_url='foo.com',
)
week = util.datelike_to_iso_string(datetime.date.today())
org = Organization.create(name="Organization",
captain_id="User_cap",
program_id=program.uid)
org_to_skip = Organization.create(name="Organization",
captain_id="User_cap",
program_id=program.uid)
Organization.put_multi([org, org_to_skip])
team = Team.create(name="Team",
captain_id="User_cap",
program_id=program.uid)
team_to_skip = Team.create(name="Team",
captain_id="User_cap",
program_id=program.uid)
Team.put_multi([team, team_to_skip])
cl = Classroom.create(name="Classroom",
team_id=team.uid,
code="foo",
contact_id="User_contact")
cl_to_skip = Classroom.create(name="Classroom",
team_id=team.uid,
code="foo",
contact_id="User_contact")
Classroom.put_multi([cl, cl_to_skip])
Report.put_multi([
Report.create(parent_id=org_to_skip.uid,
filename="foo",
issue_date=week),
Report.create(parent_id=team_to_skip.uid,
filename="foo",
issue_date=week),
Report.create(parent_id=cl_to_skip.uid,
filename="foo",
issue_date=week),
])
# Skips all the parents who have reports already this week.
orgs, teams, classes = cron_rserve.get_report_parents(
program, week, False)
self.assertEqual(len(orgs), 1)
self.assertEqual(len(teams), 1)
self.assertEqual(len(classes), 1)
# ...unless you force it, then they're all there.
orgs, teams, classes = cron_rserve.get_report_parents(
program, week, True)
self.assertEqual(len(orgs), 2)
self.assertEqual(len(teams), 2)
self.assertEqual(len(classes), 2)
def set_up(self):
# Let ConsistencyTestCase set up the datastore testing stub.
super(TestApiTeams, self).set_up()
application = webapp2.WSGIApplication(
api_routes,
config={
'webapp2_extras.sessions': {
'secret_key': self.cookie_key
}
},
debug=True
)
self.testapp = webtest.TestApp(application)
with mysql_connection.connect() as sql:
sql.reset({
'classroom': Classroom.get_table_definition(),
'cycle': Cycle.get_table_definition(),
'program': Program.get_table_definition(),
'organization': Organization.get_table_definition(),
'report': Report.get_table_definition(),
'survey': Survey.get_table_definition(),
'team': Team.get_table_definition(),
'user': User.get_table_definition(),
})
# See #848. Remove once resolved.
self.demo_program = Program.create(
name="Demo Program",
label='demoprogram',
min_cycles=3,
active=True,
preview_url='foo.com',
)
self.demo_program.put()
self.ep_program = Program.create(
name="Engagement Project",
label='ep19',
min_cycles=3,
active=True,
preview_url='foo.com',
)
self.ep_program.put()
def set_up(self):
# Let ConsistencyTestCase set up the datastore testing stub.
super(TestCron, self).set_up()
with mysql_connection.connect() as sql:
sql.reset({
'classroom': Classroom.get_table_definition(),
'organization': Organization.get_table_definition(),
'program': Program.get_table_definition(),
'report': Report.get_table_definition(),
'team': Team.get_table_definition(),
'user': User.get_table_definition(),
})
application = webapp2.WSGIApplication(
cron_routes,
config={'webapp2_extras.sessions': {
'secret_key': 'foo'
}},
debug=True)
self.testapp = webtest.TestApp(application)
self.taskqueue_stub = self.testbed.get_stub(
testbed.TASKQUEUE_SERVICE_NAME)
self.ep_program = Program.create(
name="Engagement Project",
label='ep19',
min_cycles=3,
active=True,
preview_url='foo.com',
)
self.ep_program.put()
self.beleset_program = Program.create(
name="Copilot Elevate",
label='beleset19',
send_cycle_email=False,
preview_url='foo.com',
)
self.beleset_program.put()
def create(self, program_label):
program = Program.create(
name="Foo",
label=program_label,
active=True,
preview_url='foo.com',
)
program.put()
captain = User.create(email='*****@*****.**', name="Captain PERTS")
team = Team.create(name='Team Foo',
program_id=program.uid,
captain_id=captain.uid)
team.put()
classrooms = [
Classroom.create(name='Class A',
team_id=team.uid,
num_students=5,
contact_id='User_contact',
code='foo'),
Classroom.create(name='Class B',
team_id=team.uid,
num_students=5,
contact_id='User_contact',
code='bar'),
Classroom.create(name='Class C',
team_id=team.uid,
num_students=5,
contact_id='User_contact',
code='baz'),
]
Classroom.put_multi(classrooms)
survey = Survey.create(team_id=team.uid)
survey.put()
captain.owned_teams = [team.uid]
captain.put()
start_date = datetime.date.today() - datetime.timedelta(days=7)
end_date = datetime.date.today() + datetime.timedelta(days=7)
cycle = Cycle.create(team_id=team.uid,
ordinal=1,
start_date=start_date,
end_date=end_date)
cycle.put()
return (program, captain, team, classrooms, cycle)
def set_up(self):
# Let ConsistencyTestCase set up the datastore testing stub.
super(TestApiReports, self).set_up()
# Necessary to determine gcs upload bucket name.
self.testbed.init_app_identity_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_blobstore_stub()
application = self.patch_webapp(webapp2.WSGIApplication)(
api_routes,
config={
'webapp2_extras.sessions': {
'secret_key': self.cookie_key
}
},
debug=True)
self.testapp = webtest.TestApp(application)
self.taskqueue_stub = self.testbed.get_stub(
testbed.TASKQUEUE_SERVICE_NAME)
with mysql_connection.connect() as sql:
sql.reset({
'classroom': Classroom.get_table_definition(),
'organization': Organization.get_table_definition(),
'program': Program.get_table_definition(),
'report': Report.get_table_definition(),
'team': Team.get_table_definition(),
'user': User.get_table_definition(),
})
if self.valid_jwt is None:
self.valid_jwt = jwt_helper.encode_rsa({
'user_id': 'User_rserve',
'email': '*****@*****.**',
'user_type': 'super_admin',
})
self.program = Program.create(
name="Engagement Project",
label='ep18',
min_cycles=3,
active=True,
preview_url='foo.com',
)
self.program.put()
def create(self):
program = Program.create(
name="Demo",
label='demo',
min_cycles=1,
preview_url='foo.com',
)
program.put()
team = Team.create(name='foo', program_id=program.uid)
captain = User.create(name='captain', email='*****@*****.**',
owned_teams=[team.uid])
team.captain_id = captain.uid
teammate = User.create(name='teammate', email='*****@*****.**',
owned_teams=[team.uid])
other = User.create(name='other', email='*****@*****.**')
User.put_multi((other, teammate, captain))
team.put()
cycles = (
# From a different team.
Cycle.create(
team_id='Team_other',
ordinal=1,
start_date=datetime.date(2000, 1, 1),
end_date=datetime.date(2000, 1, 1),
),
Cycle.create(
team_id=team.uid,
ordinal=1,
start_date=datetime.date(2000, 1, 1),
end_date=datetime.date(2000, 2, 1),
),
# Current.
Cycle.create(
team_id=team.uid,
ordinal=2,
start_date=datetime.date.today(),
end_date=datetime.date.today() + datetime.timedelta(weeks=4),
),
)
Cycle.put_multi(cycles)
return other, teammate, captain, team, cycles
def test_link_header_for_program(self):
"""Links header should work when filtering to program"""
program_cset = Program.create(
name="CSET",
label="cset19",
preview_url='foo.com',
)
program_cset.put()
cset_net = Network.create(name="cset Network",
program_id=program_cset.uid)
cset_net.put()
ep_nets, super_admin = self.create_for_paging(12)
# cset only has 1 organization, so no paging past first page.
response = self.testapp.get(
'/api/networks?program_id={}&n=10'.format(program_cset.uid),
headers=self.login_headers(super_admin),
)
self.assertEqual(
response.headers['Link'],
('<{path}?program_id={pid}&n=10&order=name>;rel=self,'
'<{path}?order=name&program_id={pid}&n=10>;rel=first,'
'<{path}?cursor=0&order=name&program_id={pid}&n=10>;rel=previous,'
'<{path}?cursor=0&order=name&program_id={pid}&n=10>;rel=next,'
'<{path}?cursor=0&order=name&program_id={pid}&n=10>;rel=last'
).format(path='/api/networks', pid=program_cset.uid))
# EP has 12 networks, so there is paging past first page.
response = self.testapp.get(
'/api/networks?program_id={}&n=10'.format(self.program.uid),
headers=self.login_headers(super_admin),
)
self.assertEqual(
response.headers['Link'],
('<{path}?program_id={pid}&n=10&order=name>;rel=self,'
'<{path}?order=name&program_id={pid}&n=10>;rel=first,'
'<{path}?cursor=0&order=name&program_id={pid}&n=10>;rel=previous,'
'<{path}?cursor=10&order=name&program_id={pid}&n=10>;rel=next,'
'<{path}?cursor=10&order=name&program_id={pid}&n=10>;rel=last'
).format(path='/api/networks', pid=self.program.uid))
def set_up(self):
# Let ConsistencyTestCase set up the datastore testing stub.
super(TestOrganizations, self).set_up()
with mysql_connection.connect() as sql:
sql.reset({
'organization': Organization.get_table_definition(),
'program': Program.get_table_definition(),
'team': Team.get_table_definition(),
'user': User.get_table_definition(),
})
ep_program = Program.create(
name="Engagement Project",
label=self.program_label,
active=True,
preview_url='foo.com',
)
self.ep_program = ep_program
ep_program.put()
def set_up(self):
# Let ConsistencyTestCase set up the datastore testing stub.
super(TestAuth, self).set_up()
with mysql_connection.connect() as sql:
sql.reset({
'classroom': Classroom.get_table_definition(),
'program': Program.get_table_definition(),
'team': Team.get_table_definition(),
'user': User.get_table_definition(),
})
self.program = Program.create(
name="Engagement Project",
label='ep18',
min_cycles=3,
active=True,
preview_url='foo.com',
)
self.program.put()
def test_config_enabled(self):
program = Program.create(
name='Program Foo',
label='TP1',
survey_config_enabled=True,
preview_url='foo.com',
)
program.put()
team = Team.create(captain_id='User_captain', program_id=program.uid)
team.put()
survey = Survey.create(team_id=team.uid)
survey.put()
# Enabled by program.
self.assertEqual(Survey.config_enabled(survey.uid), True)
# Disabled by program.
program.survey_config_enabled = False
program.put()
self.assertEqual(Survey.config_enabled(survey.uid), False)
def test_get_owned(self):
"""You can get a team you own."""
program = Program.create(
name='Program Foo',
label='TP1',
preview_url='foo.com',
)
program.put()
team = Team.create(name='foo', captain_id='User_cap',
program_id=program.uid)
team.put()
user = User.create(name='foo', email='*****@*****.**',
owned_teams=[team.uid])
user.put()
classroom = Classroom.create(name='foo', team_id=team.uid,
contact_id=user.uid, code='trout viper')
classroom.put()
response = self.testapp.get(
'/api/teams/{}'.format(team.uid),
headers=self.login_headers(user),
)
response_dict = json.loads(response.body)
self.assertEqual(response_dict['uid'], team.uid)
# Should have allowed endpoints for all contained classrooms.
jwt_payload, error = jwt_helper.decode(
response.headers['Authorization'][7:])
self.assertEqual(
jwt_payload['allowed_endpoints'],
[
'GET //neptune/api/project_cohorts/trout-viper/participation',
# This endpoint is available also b/c the user is the main
# contact of this classroom.
'GET //neptune/api/project_cohorts/trout-viper/completion'
],
)
def test_create_with_org_codes(self, org=None):
"""Can send org code(s) on POST to associate with team."""
other_program = Program.create(
name='Test Program',
label='TP1',
metrics=['Metric_1', 'Metric_2'],
min_cycles=2,
active=False,
preview_url='foo.com',
)
other_program.put()
if org is None:
org = Organization.create(
name='Org Correct',
program_id=self.demo_program.uid,
code='correct code',
)
org2 = Organization.create(
name='Org Second',
program_id=self.demo_program.uid,
code='second code',
)
other_org = Organization.create(
name='Org Other',
program_id=other_program.uid,
code='other code',
)
Organization.put_multi([org, org2, other_org])
user = User.create(name='foo', email='*****@*****.**')
user.put()
# Invalid org code.
team_params = {
'name': 'Team Foo',
'organization_code': 'does not exist',
'program_id': self.demo_program.uid,
}
self.testapp.post_json(
'/api/teams',
team_params,
headers=self.login_headers(user),
status=400,
)
# Org program and team program don't match.
self.testapp.post_json(
'/api/teams',
dict(team_params, organization_code=other_org.code),
headers=self.login_headers(user),
status=400,
)
# Success.
multi_code = ', '.join([org.code, org2.code])
response = self.testapp.post_json(
'/api/teams',
dict(team_params, organization_code=multi_code),
headers=self.login_headers(user),
)
team_dict = json.loads(response.body)
self.assertEqual(
set(team_dict['organization_ids']),
set([org.uid, org2.uid]),
)
self.assert_created_with_program(team_dict, self.demo_program)
def test_enforces_that_cycleless_programs_have_one_cycle(self):
with self.assertRaises(Exception):
program = Program.create(use_cycles=False,
min_cycles=1,
max_cycles=2)
