def override(start_time, end_time, ev_ids, user):
re = requests.post(api_v0('events/override'),
json={'start': start_time,
'end': end_time,
'event_ids': ev_ids,
'user': user})
assert re.status_code == 200
return re
def test_api_v0_get_teams(team):
team_name = team.create()
re = requests.get(api_v0('teams'))
assert re.status_code == 200
teams = re.json()
assert isinstance(teams, list)
assert len(teams) >= 1
assert team_name in teams
def create(self, team_name, roster_name, json):
re = requests.post(api_v0('teams/%s/rosters/%s/schedules' %
(team_name, roster_name)),
json=json)
assert re.status_code == 201
schedule_id = re.json()['id']
self.created.append(schedule_id)
return schedule_id
def test_v0_populate_vacation_propagate(user, team, roster, role, schedule, event):
user_name = user.create()
user_name_2 = user.create()
team_name = team.create()
team_name_2 = team.create()
role_name = role.create()
roster_name = roster.create(team_name)
schedule_id = schedule.create(team_name,
roster_name,
{'role': role_name,
'events': [{'start': 0, 'duration': 604800}],
'advanced_mode': 0,
'auto_populate_threshold': 14})
user.add_to_roster(user_name, team_name, roster_name)
user.add_to_roster(user_name_2, team_name, roster_name)
user.add_to_team(user_name, team_name_2)
# Populate for team 1
re = requests.post(api_v0('schedules/%s/populate' % schedule_id), json = {'start': time.time()})
assert re.status_code == 200
# Create conflicting vacation event in team 2 for user 1
re = requests.get(api_v0('events?team=%s' % team_name))
assert re.status_code == 200
events = re.json()
assert len(events) == 2
assert events[0]['user'] != events[1]['user']
for e in events:
event.create({
'start': e['start'],
'end': e['end'],
'user': user_name,
'team': team_name_2,
'role': "vacation",
})
# Populate again for team 1
re = requests.post(api_v0('schedules/%s/populate' % schedule_id), json = {'start': time.time()})
assert re.status_code == 200
# Ensure events are both for user 2 (since user 1 is busy in team 2)
re = requests.get(api_v0('events?team=%s&include_subscribed=false' % team_name))
assert re.status_code == 200
events = re.json()
assert len(events) == 2
assert events[0]['user'] == events[1]['user'] == user_name_2
def cleanup(self):
for team in self.created:
requests.delete(api_v0('teams/' + team))
if self.created:
self.cursor.execute('DELETE FROM team WHERE name IN %s', (self.created,))
self.connection.commit()
self.cursor.close()
self.connection.close()
def test_api_v0_round_robin(user, team, roster, role, schedule, event):
user_name = user.create()
user_name_2 = user.create()
user_name_3 = user.create()
team_name = team.create()
role_name = role.create()
roster_name = roster.create(team_name)
user.add_to_roster(user_name, team_name, roster_name)
user.add_to_roster(user_name_2, team_name, roster_name)
user.add_to_roster(user_name_3, team_name, roster_name)
schedule_id = schedule.create(team_name,
roster_name,
{'role': role_name,
'events': [{'start': 0, 'duration': 604800}],
'advanced_mode': 0,
'auto_populate_threshold': 28,
'scheduler': {'name': 'round-robin',
'data': [user_name, user_name_2, user_name_3]}})
def clean_up():
re = requests.get(api_v0('events?team='+team_name))
for ev in re.json():
requests.delete(api_v0('events/%d' % ev['id']))
clean_up()
start = time.time()
# Create an event for user 1
event.create({'start': start,
'end': start + 1000,
'user': user_name,
'team': team_name,
'role': role_name})
re = requests.post(api_v0('schedules/%s/populate' % schedule_id), json = {'start': start + 2000})
assert re.status_code == 200
re = requests.get(api_v0('events?team=%s' % team_name))
assert re.status_code == 200
events = re.json()
# Check that newly populated events start with user 2, then loop back to user 1
assert events[1]['user'] == user_name_2
assert events[2]['user'] == user_name_3
assert events[3]['user'] == user_name
clean_up()
def test_api_v0_fill_gap_skip_busy(user, team, role, roster, event):
user_name = user.create()
user_name_2 = user.create()
user_name_3 = user.create()
user_name_4 = user.create()
team_name = team.create()
role_name = role.create()
role_name_2 = role.create()
roster_name = roster.create(team_name)
start = int(time.time()) + 1000
user.add_to_roster(user_name, team_name, roster_name)
user.add_to_roster(user_name_2, team_name, roster_name)
user.add_to_roster(user_name_3, team_name, roster_name)
user.add_to_roster(user_name_4, team_name, roster_name)
# Create events: user_name will be the expected user, with events far from
# the suggestion time (start + 2000). user_name_4 will be a busy user, who
# would otherwise be chosen.
event.create({
'start': start,
'end': start + 1000,
'user': user_name,
'team': team_name,
'role': role_name
})
event.create({
'start': start + 1000,
'end': start + 2000,
'user': user_name_2,
'team': team_name,
'role': role_name
})
event.create({
'start': start + 3000,
'end': start + 4000,
'user': user_name_3,
'team': team_name,
'role': role_name
})
event.create({
'start': start + 4000,
'end': start + 5000,
'user': user_name,
'team': team_name,
'role': role_name
})
event.create({
'start': start + 1000,
'end': start + 3000,
'user': user_name_4,
'team': team_name,
'role': role_name_2
})
re = requests.get(
api_v0('teams/%s/rosters/%s/%s/suggest?start=%s' %
(team_name, roster_name, role_name, start + 2000)))
assert re.status_code == 200
assert re.json()['user'] == user_name
def test_api_v0_users():
user_name = 'test_v0_users_user'
def clean_up():
requests.delete(api_v0('users/' + user_name))
clean_up()
# test adding user
re = requests.post(api_v0('users'), json={'name': user_name})
assert re.status_code == 201
re = requests.get(api_v0('users/' + user_name))
assert re.status_code == 200
response = json.loads(re.text)
assert 'contacts' in response
assert response['full_name'] != 'Juan Doş'
# test updating user
re = requests.put(api_v0('users/' + user_name),
json={
'full_name': 'Juan Doş',
'time_zone': 'PDT'
})
assert re.status_code == 204
# test updating user contacts
re = requests.put(api_v0('users/' + user_name),
json={
'full_name': 'Juan Doş',
'contacts': {
'call': '+1 333-333-3339'
}
})
assert re.status_code == 204
# make sure update has gone through, test get
re = requests.get(api_v0('users/' + user_name))
assert re.status_code == 200
response = re.json()
assert response['full_name'] == 'Juan Doş'
user_id = response['id']
re = requests.get(api_v0('users?id=%s' % user_id))
assert re.status_code == 200
response = re.json()
assert response[0]['full_name'] == 'Juan Doş'
re = requests.get(api_v0('users'),
params={
'name': user_name,
'fields': ['full_name', 'time_zone', 'contacts']
})
assert re.status_code == 200
response = json.loads(re.text)
assert response[0]['full_name'] == 'Juan Doş'
assert response[0]['time_zone'] == 'PDT'
assert response[0]['contacts']['call'] == '+1 333-333-3339'
clean_up()
def create(self, team_name):
roster_name = '_'.join(
[self.prefix, 'roster',
str(len(self.created))])
re = requests.post(api_v0('teams/%s/rosters' % team_name),
json={'name': roster_name})
assert re.status_code in [201, 422]
self.created.append((roster_name, team_name))
return roster_name
def test_api_v0_override_multiple(team, user, role, event):
team_name = team.create()
role_name = role.create()
user_name = user.create()
override_user = user.create()
user.add_to_team(user_name, team_name)
user.add_to_team(override_user, team_name)
ev1 = event.create({'start': start-1000,
'end': start+1000,
'user': user_name,
'team': team_name,
'role': role_name})
ev2 = event.create({'start': start+1000,
'end': start+2000,
'user': user_name,
'team': team_name,
'role': role_name})
ev3 = event.create({'start': start+2000,
'end': end-1000,
'user': user_name,
'team': team_name,
'role': role_name})
ev4 = event.create({'start': end-1000,
'end': end+1000,
'user': user_name,
'team': team_name,
'role': role_name})
re = override(start, end, [ev1, ev2, ev3, ev4], override_user)
assert len(re.json()) == 3
re = requests.get(api_v0('events?user='******'start'])
assert len(events) == 2
assert events[0]['start'] == start - 1000
assert events[0]['end'] == start
assert events[1]['start'] == end
assert events[1]['end'] == end + 1000
re = requests.get(api_v0('events?user='******'start'] == start
assert events[0]['end'] == end
def test_api_v0_populate_skip(user, team, roster, role, schedule, event):
user_name = user.create()
user_name_2 = user.create()
team_name = team.create()
role_name = role.create()
roster_name = roster.create(team_name)
schedule_id = schedule.create(team_name,
roster_name,
{'role': role_name,
'events': [{'start': 0, 'duration': 604800}],
'advanced_mode': 0,
'auto_populate_threshold': 14})
user.add_to_roster(user_name, team_name, roster_name)
user.add_to_roster(user_name_2, team_name, roster_name)
re = requests.post(api_v0('schedules/%s/populate' % schedule_id), json = {'start': time.time()})
assert re.status_code == 200
re = requests.get(api_v0('events?team=%s' % team_name))
assert re.status_code == 200
events = re.json()
assert len(events) == 2
event.create({
'start': events[0]['start'],
'end': events[0]['end'],
'user': user_name,
'team': team_name,
'role': role_name,
})
re = requests.post(api_v0('schedules/%s/populate' % schedule_id), json = {'start': time.time()})
assert re.status_code == 200
re = requests.get(api_v0('events?team=%s' % team_name))
assert re.status_code == 200
events = re.json()
assert len(events) == 2
schedule_ids = set([ev['schedule_id'] for ev in events])
assert None in schedule_ids
assert schedule_id in schedule_ids
def test_api_v0_auto_add_rosters_users_to_team(team, user, roster):
'''
User should be automatically added to team when added to a roster
'''
team_name = team.create()
roster_name = roster.create(team_name)
user_name = user.create()
# make sure user is not in the team
team = requests.get(api_v0('teams/' + team_name)).json()
assert user_name not in team['users']
# add user to roster
requests.post(api_v0('teams/%s/rosters/%s/users' % (team_name, roster_name)),
json={'name': user_name})
# check to make sure user is also added to the team
team = requests.get(api_v0('teams/' + team_name)).json()
assert user_name in team['users']
def test_api_v0_schedules_with_spaces_in_roster_name(team):
team_name = 'test_v0 spaces team foo'
roster_name = 'test_v0 spaces roster foo'
re = requests.post(api_v0('teams'),
json={
'name': team_name,
'scheduling_timezone': 'UTC'
})
assert re.status_code == 201
team.mark_for_cleaning(team_name)
re = requests.post(api_v0('teams/%s/rosters' % team_name),
json={'name': roster_name})
assert re.status_code == 201
re = requests.get(
api_v0('teams/%s/rosters/%s/schedules' %
(team_name, urllib.quote(roster_name, safe=''))))
assert re.status_code == 200
def create(self):
name = '_'.join([self.prefix, 'team', str(len(self.created))])
re = requests.post(api_v0('teams'),
json={
'name': name,
'scheduling_timezone': 'utc'
})
assert re.status_code in [201, 422]
self.created.add(name)
return name
def test_api_v0_team_summary(team, user, role, event):
team_name = team.create()
user_name = user.create()
user_name_2 = user.create()
role_name = role.create()
role_name_2 = role.create()
user.add_to_team(user_name, team_name)
user.add_to_team(user_name_2, team_name)
start, end = int(time.time()), int(time.time()+36000)
event_data_1 = {'start': start,
'end': end,
'user': user_name,
'team': team_name,
'role': role_name}
event_data_2 = {'start': start - 5,
'end': end - 5,
'user': user_name_2,
'team': team_name,
'role': role_name_2}
event_data_3 = {'start': start + 50000,
'end': end + 50000,
'user': user_name,
'team': team_name,
'role': role_name}
event_data_4 = {'start': start + 50005,
'end': end + 50005,
'user': user_name_2,
'team': team_name,
'role': role_name_2}
event_data_5 = {'start': start + 50001,
'end': end + 50001,
'user': user_name,
'team': team_name,
'role': role_name}
# Create current events
event.create(event_data_1)
event.create(event_data_2)
# Create next events
event.create(event_data_3)
event.create(event_data_4)
# Create extra future event that isn't the next event
event.create(event_data_5)
re = requests.get(api_v0('teams/%s/summary' % team_name))
assert re.status_code == 200
results = re.json()
keys = ['start', 'end', 'role', 'user']
assert all(results['current'][role_name][0][key] == event_data_1[key] for key in keys)
assert all(results['current'][role_name_2][0][key] == event_data_2[key] for key in keys)
assert all(results['next'][role_name][0][key] == event_data_3[key] for key in keys)
assert all(results['next'][role_name_2][0][key] == event_data_4[key] for key in keys)
def test_notify_on_swap(user, role, team, event):
user_name = user.create()
user_name_2 = user.create()
team_name = team.create()
role_name = role.create()
user.add_to_team(user_name, team_name)
user.add_to_team(user_name_2, team_name)
start, end = int(time.time() + 100), int(time.time() + 36000)
ev_id = event.create({
'start': start,
'end': end,
'user': user_name,
'team': team_name,
'role': role_name,
})
ev_id_2 = event.create({
'start': start + 100,
'end': end + 100,
'user': user_name_2,
'team': team_name,
'role': role_name,
})
# set up notification settings
notification = {'team': team_name, 'roles': [role_name], 'mode': 'email', 'type': EVENT_SWAPPED,
'only_if_involved': True}
re = requests.post(api_v0('users/%s/notifications' % user_name), json=notification)
assert re.status_code == 201
re = requests.post(api_v0('users/%s/notifications' % user_name_2), json=notification)
assert re.status_code == 201
# Swap these events
re = requests.post(api_v0('events/swap'), json={'events': [{'id': ev_id, 'linked': False},
{'id': ev_id_2, 'linked': False}]})
assert re.status_code == 200
notifications = get_notifications([user_name, user_name_2], EVENT_SWAPPED)
assert len(notifications) == 2
assert {n['user'] for n in notifications} == {user_name, user_name_2}
def test_api_v0_services_current_oncall(team, service, user, role, event):
team_name = team.create()
service_name = service.create()
service.associate_team(service_name, team_name)
user_name = user.create()
user_name_2 = user.create()
role_name = role.create()
role_name_2 = role.create()
user.add_to_team(user_name, team_name)
user.add_to_team(user_name_2, team_name)
start, end = int(time.time()), int(time.time() + 36000)
event_data_1 = {
'start': start,
'end': end,
'user': user_name,
'team': team_name,
'role': role_name
}
event_data_2 = {
'start': start - 5,
'end': end - 5,
'user': user_name_2,
'team': team_name,
'role': role_name_2
}
# Create current event
event.create(event_data_1)
# Create extra event with different role
event.create(event_data_2)
re = requests.get(
api_v0('services/%s/oncall/%s' % (service_name, role_name)))
assert re.status_code == 200
results = re.json()
assert results[0]['start'] == start
assert results[0]['end'] == end
re = requests.get(api_v0('services/%s/oncall' % service_name))
assert re.status_code == 200
results = re.json()
assert len(results) == 2
def test_api_v0_user_teams(team, user):
team_name = team.create()
user_name = user.create()
# should get an empty team list
re = requests.get(api_v0('users/%s/teams' % user_name))
assert re.status_code == 200
assert re.json() == []
# should not get an empty team list
re = requests.post(api_v0('teams/%s/users' % team_name),
json={'name': user_name})
assert re.status_code == 201
re = requests.get(api_v0('users/%s/teams' % user_name))
assert re.status_code == 200
assert team_name in re.json()
# should get 404 on invalid user
re = requests.get(api_v0('users/invalid_user_foobar-123/teams'))
assert re.status_code == 404
def test_v0_subscription_oncall(user, role, team, service, event):
team_name = team.create()
team_name_2 = team.create()
service_name = service.create()
service.associate_team(service_name, team_name)
user_name = user.create()
user_name_2 = user.create()
role_name = role.create()
user.add_to_team(user_name, team_name)
user.add_to_team(user_name_2, team_name_2)
re = requests.post(api_v0('teams/%s/subscriptions' % team_name),
json={
'role': role_name,
'subscription': team_name_2
})
assert re.status_code == 201
start = int(time.time())
ev1 = event.create({
'start': start,
'end': start + 1000,
'user': user_name,
'team': team_name,
'role': role_name
})
ev2 = event.create({
'start': start,
'end': start + 1000,
'user': user_name_2,
'team': team_name_2,
'role': role_name
})
re = requests.get(
api_v0('services/%s/oncall/%s' % (service_name, role_name)))
assert re.status_code == 200
results = re.json()
users = [ev['user'] for ev in results]
assert user_name in users
assert user_name_2 in users
assert len(results) == 2
def test_api_v0_update_team(team):
team_name = team.create()
new_team_name = "new-moninfra-update"
email = '*****@*****.**'
slack = '#slack'
override_num = '1234'
# setup DB state
requests.delete(api_v0('teams/' + new_team_name))
re = requests.get(api_v0('teams/' + new_team_name))
assert re.status_code == 404
re = requests.get(api_v0('teams/' + team_name))
assert re.status_code == 200
# edit team name/email/slack
re = requests.put(api_v0('teams/' + team_name),
json={
'name': new_team_name,
'email': email,
'slack_channel': slack,
'override_phone_number': override_num
})
assert re.status_code == 200
team.mark_for_cleaning(new_team_name)
# verify result
re = requests.get(api_v0('teams/' + team_name))
assert re.status_code == 404
re = requests.get(api_v0('teams/' + new_team_name))
assert re.status_code == 200
data = re.json()
assert data['email'] == email
assert data['slack_channel'] == slack
assert data['override_phone_number'] == override_num
def test_api_v0_get_team(team, role, roster, schedule):
team_name = team.create()
role_name = role.create()
roster_name = roster.create(team_name)
schedule.create(
team_name, roster_name, {
'role': role_name,
'events': [{
'start': 0,
'duration': 60 * 60 * 24 * 7
}],
'advanced_mode': 0
})
# by default, it should return everything
re = requests.get(api_v0('teams/' + team_name))
assert re.status_code == 200
team = re.json()
assert isinstance(team, dict)
expected_set = {
'users', 'admins', 'services', 'rosters', 'name', 'id',
'slack_channel', 'slack_channel_notifications', 'email',
'scheduling_timezone', 'iris_plan', 'iris_enabled',
'override_phone_number'
}
assert expected_set == set(team.keys())
# it should also support filter by fields
re = requests.get(
api_v0('teams/%s?fields=users&fields=services&fields=admins' %
team_name))
assert re.status_code == 200
team = re.json()
assert isinstance(team, dict)
expected_set = {
'users', 'admins', 'services', 'name', 'id', 'slack_channel',
'slack_channel_notifications', 'email', 'scheduling_timezone',
'iris_plan', 'iris_enabled', 'override_phone_number'
}
assert expected_set == set(team.keys())
def test_api_v0_team_admin(team, user):
team_name = team.create()
re = requests.get(api_v0('teams/%s/admins') % team_name)
assert re.status_code == 200
# Make sure the test user was made an admin after making the team
assert len(re.json()) == 1
admin_user = user.create()
# test create admin
re = requests.post(api_v0('teams/%s/admins' % team_name),
json={'name': admin_user})
assert re.status_code == 201
# verify result
re = requests.get(api_v0('teams/%s/admins' % team_name))
assert re.status_code == 200
assert admin_user in set(re.json())
# user should be also added to team automatically
re = requests.get(api_v0('teams/%s' % team_name))
assert re.status_code == 200
assert admin_user in re.json()['users']
# test delete admin
re = requests.delete(api_v0('teams/%s/admins/%s' %
(team_name, admin_user)))
# verify result
re = requests.get(api_v0('teams/%s/admins' % team_name))
assert re.status_code == 200
assert admin_user not in set(re.json())
def test_api_v0_invalid_schedule_event(team, roster, role, schedule):
team_name = team.create()
roster_name = roster.create(team_name)
role_name = role.create()
api_url = api_v0('teams/%s/rosters/%s/schedules' %
(team_name, roster_name))
re = requests.post(api_url,
json={
'role':
role_name,
'events': [{
'duration': 100
}, {
'start': 150,
'duration': 300
}],
'advanced_mode':
1
})
assert re.status_code == 400
re = requests.post(api_url,
json={
'role': role_name,
'events': [{
'start': 150
}],
'advanced_mode': 1
})
assert re.status_code == 400
re = requests.post(api_url,
json={
'role': role_name,
'events': [{
'start': 150,
'duration': 300
}],
'advanced_mode': 0
})
assert re.status_code == 400
re = requests.post(api_url,
json={
'role': role_name,
'events': 7 * [{
'start': 150,
'duration': 300
}],
'advanced_mode': 0
})
assert re.status_code == 400
def test_api_v0_populate_new(user, team, roster, role, schedule):
user_name = user.create()
user_name_2 = user.create()
team_name = team.create()
role_name = role.create()
roster_name = roster.create(team_name)
schedule_id = schedule.create(
team_name, roster_name, {
'role': role_name,
'events': [{
'start': 0,
'duration': 604800
}],
'advanced_mode': 0,
'auto_populate_threshold': 14
})
user.add_to_roster(user_name, team_name, roster_name)
user.add_to_roster(user_name_2, team_name, roster_name)
def clean_up():
re = requests.get(api_v0('events?team=' + team_name))
for ev in re.json():
requests.delete(api_v0('events/%d' % ev['id']))
clean_up()
re = requests.post(api_v0('schedules/%s/populate' % schedule_id),
json={'start': time.time()})
assert re.status_code == 200
re = requests.get(api_v0('events?team=%s' % team_name))
assert re.status_code == 200
events = re.json()
assert len(events) == 2
users = set([ev['user'] for ev in events])
assert user_name in users
assert user_name_2 in users
clean_up()
def test_invalid_event_swap(team, user, role, event):
team_name = team.create()
user_name = user.create()
role_name = role.create()
user.add_to_team(user_name, team_name)
start = int(time.time()) + 100
ev1 = event.create({
'start': start,
'end': start + 1000,
'user': user_name,
'team': team_name,
'role': role_name
})
# test swap with invalid event id
re = requests.post(api_v0('events/swap'),
json={
'events': [{
'id': ev1,
'linked': False
}, {
'id': None,
'linked': False
}]
})
assert re.status_code == 400
# test swap without event id
re = requests.post(
api_v0('events/swap'),
json={'events': [{
'id': ev1,
'linked': False
}, {
'linked': False
}]})
assert re.status_code == 400
def test_notification_settings(team, user, role):
team_name = team.create()
team_name_2 = team.create()
user_name = user.create()
role_name = role.create()
role_name_2 = role.create()
def clean_up():
re = requests.get(api_v0('events?team='+team_name))
for ev in re.json():
requests.delete(api_v0('events/%d' % ev['id']))
clean_up()
# test get notification settings, make sure there are none
re = requests.get(api_v0('users/%s/notifications' % user_name))
assert re.status_code == 200
assert re.json() == []
# test adding notification setting
notification = {'team': team_name, 'roles': [role_name, role_name_2], 'mode': 'email', 'type': EVENT_CREATED,
'only_if_involved': True}
re = requests.post(api_v0('users/%s/notifications' % user_name), json=notification)
assert re.status_code == 201
setting_id = re.json()['id']
# check that setting values are correct
re = requests.get(api_v0('users/%s/notifications' % user_name))
assert re.status_code == 200
data = re.json()
assert len(data) == 1
assert all([notification[key] == data[0][key] for key in notification])
# test editing setting
new_setting = {'team': team_name_2, 'roles': [role_name_2], 'mode': 'sms', 'type': EVENT_DELETED,
'only_if_involved': False}
re = requests.put(api_v0('notifications/%s' % setting_id), json=new_setting)
assert re.status_code == 200
# check that setting now has new values
re = requests.get(api_v0('users/%s/notifications' % user_name))
assert re.status_code == 200
data = re.json()
assert len(data) == 1
assert all([new_setting[key] == data[0][key] for key in new_setting])
# test deleting setting
re = requests.delete(api_v0('notifications/%s' % setting_id))
assert re.status_code == 200
# make sure it was deleted
re = requests.get(api_v0('users/%s/notifications' % user_name))
assert re.status_code == 200
assert re.json() == []
def test_api_v0_subscription_events(user, role, team, event):
team_name = team.create()
team_name_2 = team.create()
user_name = user.create()
role_name = role.create()
user.add_to_team(user_name, team_name)
user.add_to_team(user_name, team_name_2)
start = int(time.time()) + 1000
ev1 = event.create({
'start': start,
'end': start + 1000,
'user': user_name,
'team': team_name,
'role': role_name
})
ev2 = event.create({
'start': start + 1000,
'end': start + 2000,
'user': user_name,
'team': team_name_2,
'role': role_name
})
re = requests.post(api_v0('teams/%s/subscriptions' % team_name),
json={
'role': role_name,
'subscription': team_name_2
})
assert re.status_code == 201
re = requests.get(api_v0('events?team__eq=%s' % team_name))
ev_ids = [ev['id'] for ev in re.json()]
assert ev1 in ev_ids
assert ev2 in ev_ids
re = requests.get(
api_v0('events?team__eq=%s&include_subscribed=False' % team_name))
ev_ids = [ev['id'] for ev in re.json()]
assert ev1 in ev_ids
assert len(ev_ids) == 1
def test_api_v0_team_current_oncall(team, user, role, event):
team_name = team.create()
user_name = user.create()
user_name_2 = user.create()
role_name = role.create()
role_name_2 = role.create()
user.add_to_team(user_name, team_name)
user.add_to_team(user_name_2, team_name)
start, end = int(time.time()), int(time.time() + 36000)
event_data_1 = {
'start': start,
'end': end,
'user': user_name,
'team': team_name,
'role': role_name
}
event_data_2 = {
'start': start - 5,
'end': end - 5,
'user': user_name_2,
'team': team_name,
'role': role_name_2
}
event.create(event_data_1)
event.create(event_data_2)
re = requests.get(api_v0('teams/%s/oncall/%s' % (team_name, role_name)))
assert re.status_code == 200
results = re.json()
assert results[0]['start'] == start
assert results[0]['end'] == end
re = requests.get(api_v0('teams/%s/oncall' % team_name))
assert re.status_code == 200
results = re.json()
assert len(results) == 2
def test_api_v0_fill_gap_new_user(user, team, role, roster, event):
user_name = user.create()
user_name_2 = user.create()
user_name_3 = user.create()
user_name_4 = user.create()
user_name_5 = user.create()
team_name = team.create()
role_name = role.create()
roster_name = roster.create(team_name)
start = int(time.time()) + 100
user.add_to_roster(user_name, team_name, roster_name)
user.add_to_roster(user_name_2, team_name, roster_name)
user.add_to_roster(user_name_3, team_name, roster_name)
user.add_to_roster(user_name_4, team_name, roster_name)
user.add_to_roster(user_name_5, team_name, roster_name)
event.create({
'start': start,
'end': start + 1000,
'user': user_name,
'team': team_name,
'role': role_name
})
event.create({
'start': start + 1000,
'end': start + 2000,
'user': user_name_2,
'team': team_name,
'role': role_name
})
event.create({
'start': start + 3000,
'end': start + 4000,
'user': user_name_3,
'team': team_name,
'role': role_name
})
event.create({
'start': start + 4000,
'end': start + 5000,
'user': user_name_4,
'team': team_name,
'role': role_name
})
re = requests.get(
api_v0(
'teams/%s/rosters/%s/%s/suggest?start=%s&end=%s' %
(team_name, roster_name, role_name, start + 2000, start + 3000)))
assert re.status_code == 200
assert re.json()['user'] == user_name_5
def test_notify_on_override(user, role, team, event):
user_name = user.create()
user_name_2 = user.create()
team_name = team.create()
role_name = role.create()
user.add_to_team(user_name, team_name)
user.add_to_team(user_name_2, team_name)
start, end = int(time.time() + 100), int(time.time() + 36000)
ev_id = event.create({
'start': start,
'end': end,
'user': user_name,
'team': team_name,
'role': role_name,
})
# set up notification settings
notification = {'team': team_name, 'roles': [role_name], 'mode': 'email', 'type': EVENT_SUBSTITUTED,
'only_if_involved': True}
re = requests.post(api_v0('users/%s/notifications' % user_name), json=notification)
assert re.status_code == 201
re = requests.post(api_v0('users/%s/notifications' % user_name_2), json=notification)
assert re.status_code == 201
re = requests.post(api_v0('events/override'),
json={'start': start + 200,
'end': end - 200,
'event_ids': [ev_id],
'user': user_name_2})
assert re.status_code == 200
notifications = get_notifications([user_name, user_name_2], EVENT_SUBSTITUTED)
assert len(notifications) == 2
assert {n['user'] for n in notifications} == {user_name, user_name_2}
