def testMain(self):
# add some background
day = datetime.date.today() + datetime.timedelta(days=1)
game = addGame(self, day=day.strftime("%Y-%m-%d"), time="22:40")
team_model = Team.query.get(game['home_team_id'])
team = team_model.json()
player = self.add_player("Test Kik Bot Captain", "*****@*****.**",
"m")
self.add_player_to_team(team, player, captain=True)
route = Routes['kikupcominggames']
# non-subscribed player
data = {'name': 'DoesNotExist'}
expect = {
'details': 'DoesNotExist',
'message': PlayerDoesNotExist.message
}
rv = self.app.post(route, data=data, headers=KIK_HEADER)
self.output(loads(rv.data))
self.output(expect)
m = route + " POST: Player DNE for upcoming games"
self.assertEqual(rv.status_code, PlayerDoesNotExist.status_code, m)
self.assertEqual(expect, loads(rv.data), m)
# subscribed player upcoming games
data = {'name': player['player_name']}
rv = self.app.post(route, data=data, headers=KIK_HEADER)
self.output(loads(rv.data))
self.output(expect)
m = route + " POST: Subscribed player for upcoming games"
self.assertEqual(rv.status_code, SUCCESSFUL_GET_CODE, m)
self.assertTrue(len(loads(rv.data)) > 0, m)
self.assertEqual(game['game_id'], loads(rv.data)[0]['game_id'], m)
def testGameDelete(self):
# delete invalid game id
rv = self.app.delete(Routes['game'] + "/" + str(INVALID_ID),
headers=headers)
expect = {'details': INVALID_ID, 'message': GameDoesNotExist.message}
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(loads(rv.data), expect,
Routes['game'] + " DELETE: on invalid game id")
self.assertEqual(rv.status_code, GameDoesNotExist.status_code,
Routes['game'] + " DELETE: on invalid game id")
# add a game
game = addGame(self)
# delete valid game id
rv = self.app.delete(Routes['game'] + "/" + str(game['game_id']),
headers=headers)
expect = None
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(loads(rv.data), expect,
Routes['game'] + " DELETE: on valid game id")
self.assertEqual(rv.status_code, 200,
Routes['game'] + " DELETE: on valid game id")
def testMain(self):
# add some background
game = addGame(self)
team_model = Team.query.get(game['home_team_id'])
team = team_model.json()
player = self.add_player("Test Bot Captain", "*****@*****.**", "m")
self.add_player_to_team(team, player, captain=True)
route = Routes['botcaptaingames']
# valid request
data = {'player_id': player['player_id'],
'team': team['team_id']}
rv = self.app.post(route, json=data, headers=headers)
self.output(loads(rv.data))
self.output(game)
error = Routes['botcaptaingames'] + " POST: Valid Captain's games"
self.assertTrue(len(loads(rv.data)) > 0, error)
self.assertEqual(rv.status_code, SUCCESSFUL_GET_CODE, error)
self.assertGameModelEqual(game, loads(rv.data)[0], error)
# submit score
self.submit_a_score(player, game, 1, hr=[player['player_id']])
# second valid request
data = {'player_id': player['player_id'],
'team': team['team_id']}
expect = []
rv = self.app.post(route, json=data, headers=headers)
self.output(loads(rv.data))
self.output(expect)
error = Routes['botcaptaingames'] + " POST: Invalid Captain's games"
self.assertEqual(rv.status_code, SUCCESSFUL_GET_CODE, error)
self.assertEqual(expect, loads(rv.data), error)
def testMain(self):
# add some background
game = addGame(self)
team_model = Team.query.get(game['home_team_id'])
team = team_model.json()
player = self.add_player("Test Bot Captain", "*****@*****.**", "m")
self.add_player_to_team(team, player, captain=True)
route = Routes['botsubmitscore']
# invalid captain
data = {'player_id': INVALID_ID,
'game_id': game['game_id'],
'score': 1,
'hr': [player['player_id']],
'ss': []}
expect = {'details': INVALID_ID,
'message': PlayerNotSubscribed.message}
rv = self.app.post(route, json=data, headers=headers)
self.output(loads(rv.data))
self.output(expect)
error = Routes['botsubmitscore'] + " POST: invalid bot user name"
code = PlayerNotSubscribed.status_code
self.assertEqual(rv.status_code, code, error)
self.assertEqual(expect, loads(rv.data), error)
# invalid game
data = {'player_id': player['player_id'],
'game_id': INVALID_ID,
'score': 1,
'hr': [player['player_id']],
'ss': []}
expect = {'details': INVALID_ID, 'message': GameDoesNotExist.message}
rv = self.app.post(route, json=data, headers=headers)
self.output(loads(rv.data))
self.output(expect)
error = Routes['botsubmitscore'] + " POST: invalid game id"
self.assertEqual(rv.status_code, GameDoesNotExist.status_code, error)
self.assertEqual(expect, loads(rv.data), error)
# more hr than runs scored
data = {'player_id': player['player_id'],
'game_id': game['game_id'],
'score': 1,
'hr': [player['player_id'], player['player_id']],
'ss': []}
expect = {'details': 'More hr than score',
'message': InvalidField.message}
rv = self.app.post(route, json=data, headers=headers)
self.output(loads(rv.data))
self.output(expect)
error = Routes['botsubmitscore'] + " POST: more hr than runs"
self.assertEqual(rv.status_code, InvalidField.status_code, error)
self.assertEqual(expect, loads(rv.data), error)
# normal request
self.submit_a_score(player, game, 1, hr=[player['player_id']])
def testMain(self):
# add some background
day = datetime.date.today() - datetime.timedelta(days=1)
game = addGame(self, day=day.strftime("%Y-%m-%d"), time="22:40")
team_model = Team.query.get(game['home_team_id'])
team = team_model.json()
player = self.add_player("Test Kik Bot Captain", "*****@*****.**",
"m")
self.add_player_to_team(team, player, captain=True)
kik = "testKikCaptain"
route = Routes['kikcaptaingames']
# invalid captian request
data = {'kik': kik, "team": team['team_id']}
expect = {'details': None, 'message': NotTeamCaptain.message}
rv = self.app.post(route, data=data, headers=KIK_HEADER)
self.output(loads(rv.data))
self.output(expect)
m = route + " POST: Invalid Captain's games"
self.assertEqual(rv.status_code, NotTeamCaptain.status_code, m)
self.assertEqual(expect, loads(rv.data), m)
# add the kik name to the captain
player = self.add_kik_to_player(player, kik)
# valid request
data = {'kik': kik, "team": team['team_id']}
rv = self.app.post(route, data=data, headers=KIK_HEADER)
self.output(loads(rv.data))
self.output(expect)
m = route + " POST: Valid Captain's games"
self.assertEqual(rv.status_code, SUCCESSFUL_GET_CODE, m)
self.assertTrue(len(loads(rv.data)) > 0, m)
self.assertEqual(game['game_id'], loads(rv.data)[0]['game_id'], m)
# submit score
self.submit_a_score_by_kik(kik, game, 1, hr=[player['player_id']])
# second valid request
data = {'kik': kik, "team": team['team_id']}
expect = []
rv = self.app.post(route, data=data, headers=KIK_HEADER)
self.output(loads(rv.data))
self.output(expect)
m = Routes['kikcaptaingames'] + " POST: Invalid Captain's games"
self.assertEqual(rv.status_code, SUCCESSFUL_GET_CODE, m)
self.assertEqual(expect, loads(rv.data), m)
def testGameGet(self):
# add a game
game = addGame(self)
# invalid Game id
expect = {'details': INVALID_ID, "message": GameDoesNotExist.message}
self.getTest(Routes['game'] + "/" + str(INVALID_ID),
GameDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=Routes['game'] + " Get: Invalid Game")
# valid Game id
self.getTest(Routes['game'] + "/" + str(game['game_id']),
SUCCESSFUL_GET_CODE,
self.assertGameModelEqual,
game,
error_message=Routes['game'] + " Get: valid Game")
def testMain(self):
# non-subscribed player
day = datetime.date.today() + datetime.timedelta(days=1)
game = addGame(self, day=day.strftime("%Y-%m-%d"), time="22:40")
team_model = Team.query.get(game['home_team_id'])
team = team_model.json()
player = self.add_player("Test Bot Captain", "*****@*****.**", "m")
self.add_player_to_team(team, player, captain=True)
route = Routes['botupcominggames']
# invalid player id
data = {'player_id': INVALID_ID}
expect = {'details': INVALID_ID, 'message': PlayerDoesNotExist.message}
rv = self.app.post(route, json=data, headers=headers)
self.output(loads(rv.data))
self.output(expect)
error = route + " POST: Player DNE for upcoming games"
self.assertEqual(rv.status_code, PlayerDoesNotExist.status_code, error)
self.assertEqual(expect, loads(rv.data), error)
# subscribed player upcoming games
data = {'player_id': player['player_id']}
expect = [{
'away_team': game['away_team'],
'away_team_id': game['away_team_id'],
'date': game['date'],
'field': game['field'],
'game_id': game['game_id'],
'home_team': game['home_team'],
'home_team_id': game['home_team_id'],
'league_id': game['league_id'],
'division_id': game['division_id'],
'status': game['status'],
'time': game['time']
}]
rv = self.app.post(Routes['botupcominggames'],
json=data,
headers=headers)
self.output(loads(rv.data))
self.output(expect)
error = route + " POST: Subscribed player for upcoming games"
self.assertEqual(rv.status_code, SUCCESSFUL_GET_CODE, error)
self.assertEqual(expect, loads(rv.data), error)
def testMain(self):
# this api was not used so testing is not complete
# add some background
sponsor = self.add_sponsor("Test Kik Sposnor")
game = addGame(self)
team_model = Team.query.get(game['home_team_id'])
team = team_model.json()
player = self.add_player("Test Kik Bot Captain", "*****@*****.**",
"m")
self.add_player_to_team(team, player, captain=True)
kik = "testKikCaptain"
route = Routes['kiktransaction']
# player not subscribed
data = {'kik': kik, "sponsor": sponsor['sponsor_name'], "amount": 1}
expect = {'details': kik, 'message': PlayerNotSubscribed.message}
rv = self.app.post(route, data=data, headers=KIK_HEADER)
self.output(loads(rv.data))
self.output(expect)
m = route + " Post: transaction for player not subscribed"
self.assertEqual(rv.status_code, PlayerNotSubscribed.status_code, m)
self.assertEqual(expect, loads(rv.data), m)
# subscribe the player
player = self.add_kik_to_player(player, kik)
# sponsor does not exist
data = {'kik': kik, "sponsor": "FUCKINGDOESNOTEXIST", "amount": 1}
expect = {
'details': 'FUCKINGDOESNOTEXIST',
'message': SponsorDoesNotExist.message
}
rv = self.app.post(route, data=data, headers=KIK_HEADER)
self.output(loads(rv.data))
self.output(expect)
m = route + " Post: sponsor does not exist"
self.assertEqual(rv.status_code, SponsorDoesNotExist.status_code, m)
self.assertEqual(expect, loads(rv.data), m)
def testBateInvalidPost(self):
# Note Valid Requests are tested in BaseTest method add_bat
# missing parameters
game = addGame(self)
player = self.add_player("Test Player",
"*****@*****.**",
gender="M")
params = {}
expect = {
'message': {
'game_id': MISSING_PARAMETER,
'hit': MISSING_PARAMETER,
'player_id': MISSING_PARAMETER,
'team_id': MISSING_PARAMETER
}
}
error_message = (Routes['bat'] +
" POST: request with missing parameter")
self.postInvalidTest(Routes['bat'],
params,
InvalidField.status_code,
self.assertEqual,
expect,
error_message=error_message)
# testing invalid player
params = {
'game_id': game['game_id'],
'player_id': INVALID_ID,
'team_id': game['home_team_id'],
'rbi': 2,
'hit': "hr",
'inning': 1
}
expect = {'details': INVALID_ID, 'message': PlayerDoesNotExist.message}
error_message = (Routes['bat'] +
" POST: request with invalid player id")
self.postInvalidTest(Routes['bat'],
params,
PlayerDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=error_message)
# testing invalid game
params = {
'game_id': INVALID_ID,
'player_id': player['player_id'],
'team_id': game['home_team_id'],
'rbi': 2,
'hit': "hr",
'inning': 1
}
expect = {'details': INVALID_ID, 'message': GameDoesNotExist.message}
error_message = (Routes['bat'] +
" POST: request with invalid game id")
self.postInvalidTest(Routes['bat'],
params,
GameDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=error_message)
# testing invalid team
params = {
'game_id': game['game_id'],
'player_id': player['player_id'],
'team_id': INVALID_ID,
'rbi': 2,
'hit': "hr",
'inning': 1
}
expect = {'details': str(INVALID_ID),
'message': TeamDoesNotExist.message}
error_message = (Routes['bat'] +
" POST: request with invalid team id")
self.postInvalidTest(Routes['bat'],
params,
TeamDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=error_message)
# testing invalid rbi
params = {
'game_id': INVALID_ID,
'player_id': player['player_id'],
'team_id': game['home_team_id'],
'rbi': 100,
'hit': "hr",
'inning': 1
}
expect = {'details': 'Bat - rbi', 'message': InvalidField.message}
error_message = (Routes['bat'] +
" POST: request with invalid rbi")
self.postInvalidTest(Routes['bat'],
params,
InvalidField.status_code,
self.assertEqual,
expect,
error_message=error_message)
# testing invalid inning
params = {
'game_id': INVALID_ID,
'player_id': player['player_id'],
'team_id': game['home_team_id'],
'rbi': 1,
'hit': "hr",
'inning': -1
}
expect = {'details': 'Bat - inning', 'message': InvalidField.message}
error_message = (Routes['bat'] +
" POST: request with invalid inning")
self.postInvalidTest(Routes['bat'],
params,
InvalidField.status_code,
self.assertEqual,
expect,
error_message=error_message)
# testing invalid hit
params = {
'game_id': INVALID_ID,
'player_id': player['player_id'],
'team_id': game['home_team_id'],
'rbi': 1,
'hit': "xx",
'inning': 1
}
expect = {'details': 'Bat - hit', 'message': InvalidField.message}
error_message = (Routes['bat'] +
" POST: request with invalid hit")
self.postInvalidTest(Routes['bat'],
params,
InvalidField.status_code,
self.assertEqual,
expect,
error_message=error_message)
def testBatPut(self):
# add a bat
bat = addBat(self, "S")
invalid_route = Routes['bat'] + "/" + str(INVALID_ID)
valid_route = Routes['bat'] + "/" + str(bat['bat_id'])
# invalid bat ID
params = {
'game_id': bat['game_id'],
'player_id': bat['player_id'],
'team_id': bat['team_id'],
'rbi': 4,
'hit': "HR",
'inning': 1}
expect = {'details': INVALID_ID, 'message': BatDoesNotExist.message}
error_message = Routes['bat'] + " PUT: invalid Bat id"
self.putTest(invalid_route,
params,
BatDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=error_message)
# test invalid game_id
params = {
'game_id': INVALID_ID,
'player_id': bat['player_id'],
'team_id': bat['team_id'],
'rbi': 4,
'hit': "HR",
'inning': 1}
expect = {'details': INVALID_ID, 'message': GameDoesNotExist.message}
error_message = Routes['bat'] + " PUT: invalid game"
self.putTest(valid_route,
params,
GameDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=error_message)
# test invalid player_id
params = {
'game_id': bat['game_id'],
'player_id': INVALID_ID,
'team_id': bat['team_id'],
'rbi': 4,
'hit': "HR",
'inning': 1}
expect = {'details': INVALID_ID, 'message': PlayerDoesNotExist.message}
error_message = Routes['bat'] + " PUT: invalid player"
self.putTest(valid_route,
params,
PlayerDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=error_message)
# test invalid team_id
params = {
'game_id': bat['game_id'],
'player_id': bat['player_id'],
'team_id': INVALID_ID,
'rbi': 4,
'hit': "HR",
'inning': 1}
expect = {'details': str(INVALID_ID),
'message': TeamDoesNotExist.message}
error_message = Routes['bat'] + " PUT: invalid team"
self.putTest(valid_route,
params,
TeamDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=error_message)
# test invalid rbi
params = {
'game_id': bat['game_id'],
'player_id': bat['player_id'],
'team_id': bat['team_id'],
'rbi': 10,
'hit': "HR",
'inning': 1}
expect = {'details': 'Bat - rbi', 'message': InvalidField.message}
error_message = Routes['bat'] + " PUT: invalid rbi"
self.putTest(valid_route,
params,
InvalidField.status_code,
self.assertEqual,
expect,
error_message=error_message)
# test invalid hit
params = {
'game_id': bat['game_id'],
'player_id': bat['player_id'],
'team_id': bat['team_id'],
'rbi': 1,
'hit': "XX",
'inning': 1}
expect = {'details': 'Bat - hit', 'message': InvalidField.message}
error_message = Routes['bat'] + " PUT: invalid hit"
self.putTest(valid_route,
params,
InvalidField.status_code,
self.assertEqual,
expect,
error_message=error_message)
# test invalid inning
params = {
'game_id': bat['game_id'],
'player_id': bat['player_id'],
'team_id': bat['team_id'],
'rbi': 4,
'hit': "HR",
'inning': -1}
expect = {'details': 'Bat - inning', 'message': InvalidField.message}
error_message = Routes['bat'] + " PUT: invalid inning"
self.putTest(valid_route,
params,
InvalidField.status_code,
self.assertEqual,
expect,
error_message=error_message)
# valid update
second_game = addGame(self)
sponsor = self.add_sponsor("Second Sponsor")
league = self.add_league("Second League")
second_team = self.add_team("test team two",
sponsor=sponsor,
league=league)
second_player = self.add_player("test player two",
"*****@*****.**",
"M")
params = {
'game_id': second_game['game_id'],
'player_id': second_player['player_id'],
'team_id': second_team['team_id'],
'rbi': 4,
'hit': "HR",
'inning': 1
}
bat['game_id'] = params['game_id']
bat['player_id'] = params['player_id']
bat['team_id'] = params['team_id']
bat['rbi'] = params['rbi']
bat['hit'] = params['hit']
bat['inning'] = params['inning']
expect = None
error_message = Routes['bat'] + " PUT: valid parameters"
self.putTest(valid_route,
params,
SUCCESSFUL_PUT_CODE,
self.assertEqual,
expect,
error_message=error_message)
# test a get to make sure it was updated
error_message = Routes['bat'] + " GET: updated bat"
self.getTest(valid_route,
SUCCESSFUL_GET_CODE,
self.assertBatModelEqual,
bat,
error_message=error_message)
def testGamePut(self):
# add a game
game = addGame(self)
invalid_route = Routes['game'] + "/" + str(INVALID_ID)
valid_route = Routes['game'] + "/" + str(game['game_id'])
# invalid game id
params = {
'home_team_id': game['home_team_id'],
'away_team_id': game['away_team_id'],
'date': "2014-08-22",
'time': "11:37",
'league_id': game['league_id'],
'status': "Championship",
'field': "WP1"
}
expect = {'details': INVALID_ID, 'message': GameDoesNotExist.message}
error_message = Routes['game'] + " PUT: invalid game id"
self.putTest(invalid_route,
params,
GameDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=error_message)
# invalid home team
params = {
'home_team_id': INVALID_ID,
'away_team_id': game['away_team_id'],
'date': "2014-08-22",
'time': "11:37",
'league_id': game['league_id'],
'status': "Championship",
'field': "WP1"
}
expect = {'details': INVALID_ID, 'message': TeamDoesNotExist.message}
error_message = Routes['game'] + " PUT: invalid home team"
self.putTest(valid_route,
params,
TeamDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=error_message)
# invalid away team
params = {
'home_team_id': game['home_team_id'],
'away_team_id': INVALID_ID,
'date': "2014-08-22",
'time': "11:37",
'league_id': game['league_id'],
'status': "Championship",
'field': "WP1"
}
expect = {'details': INVALID_ID, 'message': TeamDoesNotExist.message}
error_message = Routes['game'] + " PUT: invalid away team"
self.putTest(valid_route,
params,
TeamDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=error_message)
# invalid league
params = {
'home_team_id': game['home_team_id'],
'away_team_id': game['away_team_id'],
'date': "2014-08-22",
'time': "11:37",
'league_id': INVALID_ID,
'status': "Championship",
'field': "WP1"
}
expect = {'details': INVALID_ID, 'message': LeagueDoesNotExist.message}
error_message = Routes['game'] + " PUT: invalid league"
self.putTest(valid_route,
params,
LeagueDoesNotExist.status_code,
self.assertEqual,
expect,
error_message=error_message)
# invalid date
params = {
'home_team_id': game['home_team_id'],
'away_team_id': game['away_team_id'],
'date': "xx-08-22",
'time': "11:37",
'league_id': game['league_id'],
'status': "Championship",
'field': "WP1"
}
expect = {'details': 'Game - date', 'message': InvalidField.message}
error_message = Routes['game'] + " PUT: invalid date"
self.putTest(valid_route,
params,
InvalidField.status_code,
self.assertEqual,
expect,
error_message=error_message)
# invalid time
params = {
'home_team_id': game['home_team_id'],
'away_team_id': game['away_team_id'],
'date': "2014-08-22",
'time': "XX:37",
'league_id': game['league_id'],
'status': "Championship",
'field': "WP1"
}
expect = {'details': 'Game - time', 'message': InvalidField.message}
error_message = Routes['game'] + " PUT: invalid time"
self.putTest(valid_route,
params,
InvalidField.status_code,
self.assertEqual,
expect,
error_message=error_message)
# invalid status
params = {
'home_team_id': game['home_team_id'],
'away_team_id': game['away_team_id'],
'date': "2014-08-22",
'time': "11:37",
'league_id': game['league_id'],
'status': 1,
'field': "WP1"
}
expect = {'details': 'Game - status', 'message': InvalidField.message}
error_message = Routes['game'] + " PUT: invalid status"
self.putTest(valid_route,
params,
InvalidField.status_code,
self.assertEqual,
expect,
error_message=error_message)
# invalid field
params = {
'home_team_id': game['home_team_id'],
'away_team_id': game['away_team_id'],
'date': "2014-08-22",
'time': "11:37",
'league_id': game['league_id'],
'status': "Championship",
'field': 1
}
expect = {'details': 'Game - field', 'message': InvalidField.message}
error_message = Routes['game'] + " PUT: invalid field"
self.putTest(valid_route,
params,
InvalidField.status_code,
self.assertEqual,
expect,
error_message=error_message)
# valid update parameters
params = {
'home_team_id': game['home_team_id'],
'away_team_id': game['away_team_id'],
'date': "2014-08-22",
'time': "11:37",
'league_id': game['league_id'],
'status': "Championship",
'field': "WP1"
}
game['home_team_id'] = params['home_team_id']
game['away_team_id'] = params['away_team_id']
game['date'] = params['date']
game['time'] = params['time']
game['league_id'] = params['league_id']
game['status'] = params['status']
game['field'] = params['field']
expect = None
error_message = Routes['game'] + " PUT: valid update"
self.putTest(valid_route,
params,
SUCCESSFUL_PUT_CODE,
self.assertEqual,
expect,
error_message=error_message)
# test a valid get
error_message = Routes['game'] + " GET: just updated game"
self.getTest(valid_route,
SUCCESSFUL_GET_CODE,
self.assertGameModelEqual,
game,
error_message=error_message)
def testMain(self):
# add some background
game = addGame(self)
team_model = Team.query.get(game['home_team_id'])
team = team_model.json()
player = self.add_player("Test Kik Bot Captain", "*****@*****.**",
"m")
self.add_player_to_team(team, player, captain=True)
kik = "testKikCaptain"
route = Routes['kiksubmitscore']
# invalid captain
data = {
'kik': kik,
'game_id': game['game_id'],
'score': 1,
'hr': [player['player_id']],
'ss': []
}
expect = {'details': kik, 'message': PlayerNotSubscribed.message}
rv = self.app.post(route, data=data, headers=KIK_HEADER)
self.output(loads(rv.data))
self.output(expect)
m = route + " POST: invalid kik user name"
self.assertEqual(rv.status_code, PlayerNotSubscribed.status_code, m)
self.assertEqual(expect, loads(rv.data), m)
# add the kik name to the captain
player = self.add_kik_to_player(player, kik)
# invalid game
data = {
'kik': kik,
'game_id': INVALID_ID,
'score': 1,
'hr': [player['player_id']],
'ss': []
}
expect = {'details': INVALID_ID, 'message': GameDoesNotExist.message}
rv = self.app.post(route, data=data, headers=KIK_HEADER)
self.output(loads(rv.data))
self.output(expect)
m = route + " POST: invalid game id"
self.assertEqual(rv.status_code, GameDoesNotExist.status_code, m)
self.assertEqual(expect, loads(rv.data), m)
# more hr than runs scored
data = {
'kik': kik,
'game_id': game['game_id'],
'score': 1,
'hr': [player['player_id'], player['player_id']],
'ss': []
}
expect = {
'details': 'More hr than score',
'message': InvalidField.message
}
rv = self.app.post(route, data=data, headers=KIK_HEADER)
self.output(loads(rv.data))
self.output(expect)
m = route + " POST: more hr than runs"
self.assertEqual(rv.status_code, InvalidField.status_code, m)
self.assertEqual(expect, loads(rv.data), m)
# normal request
self.submit_a_score_by_kik(kik, game, 1, hr=[player['player_id']])
