def testLeagueId(self):
"""Test league id parameter"""
mocker = MockLeague(self)
# invalid league id
rv = self.app.post(Routes['vteam'], json={'league_id': INVALID_ID})
expect = {}
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data),
Routes['vteam'] + " Post: invalid league id")
# valid league id
league_id = mocker.get_league()['league_id']
team = mocker.get_teams()[0]
team_id = team['team_id']
rv = self.app.post(Routes['vteam'], json={'league_id': league_id})
expect = {'games': 1,
'hits_allowed': 3,
'hits_for': 2,
'losses': 1,
'name': team['team_name'],
'runs_against': 6,
'runs_for': 1,
'ties': 0,
'wins': 0,
'espys': 0}
self.output(loads(rv.data))
self.output(expect)
self.assertTrue(len(loads(rv.data).keys()) > 0,
Routes['vteam'] + " Post: valid year")
self.assertEqual(expect,
loads(rv.data)[str(team_id)],
Routes['vteam'] + " Post: valid year")
def testPostLeagueId(self):
mocker = MockLeague(self)
# test an invalid league id
rv = self.app.post(Routes['vplayer'], data={'league_id': INVALID_ID})
expect = {}
self.output(expect)
self.output(loads(rv.data))
self.assertEqual(expect,
loads(rv.data),
Routes['vplayer'] + " Post: invalid league id")
# test an valid league id
league_id = mocker.get_league()['league_id']
expect = {'avg': 0.5,
'bats': 2,
'd': 0,
'e': 0,
'fc': 0,
'fo': 0,
'go': 0,
'hr': 1,
'id': mocker.get_players()[0]['player_id'],
'k': 1,
'rbi': 2,
's': 0,
'ss': 0}
player_check = mocker.get_players()[0]
rv = self.app.post(Routes['vplayer'], data={"league_id": league_id})
self.output(loads(rv.data))
self.assertTrue(len(loads(rv.data).keys()) == 4,
Routes['vplayer'] + " Post: valid league id")
self.assertEqual(loads(rv.data)[player_check['player_name']],
expect,
Routes['vplayer'] + " Post: valid league id")
def testActive(self):
"""Test active parameter"""
mocker = MockLeague(self)
# all players
player = mocker.get_players()[0]
expect = [player]
active = 0
name = player['player_name']
rv = self.app.post(Routes['vplayerLookup'], json={'active': active,
'player_name': name})
self.output(expect)
self.output(loads(rv.data))
self.assertTrue(len(loads(rv.data)) > 0,
Routes['vplayerLookup'] + ": active & non-active")
self.assertEqual(expect,
loads(rv.data),
Routes['vplayerLookup'] + ": active & non-active")
# now make the player non-active
self.deactivate_player(player)
# only active players
active = 1
rv = self.app.post(Routes['vplayerLookup'], json={'active': active,
'player_name': name})
expect = []
self.output(expect)
self.output(loads(rv.data))
activity = [_player['active'] for _player in loads(rv.data)]
error_message = Routes['vplayerLookup'] + ":non-active player returned"
self.assertTrue(False not in activity, error_message)
self.assertEqual(expect, loads(rv.data), error_message)
def testPost(self):
"""Test adding an invalid player to a team"""
# mock leagues tests a valid post
mocker = MockLeague(self)
player_id = mocker.get_players()[0]['player_id']
team_id = mocker.get_teams()[0]['team_id']
# invalid update
params = {"player_id": player_id}
rv = self.app.post(Routes['team_roster'] + "/" + str(INVALID_ID),
data=params,
headers=headers)
expect = {'details': INVALID_ID, 'message': TeamDoesNotExist.message}
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(loads(rv.data), expect,
Routes['team_roster'] + " POST: invalid data")
self.assertEqual(TeamDoesNotExist.status_code, rv.status_code,
Routes['team_roster'] + " PUT: invalid data")
# invalid player
params = {"player_id": INVALID_ID}
rv = self.app.post(Routes['team_roster'] + "/" + str(team_id),
data=params,
headers=headers)
expect = {'details': INVALID_ID, 'message': PlayerDoesNotExist.message}
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(loads(rv.data), expect,
Routes['team_roster'] + " POST: invalid data")
self.assertEqual(TeamDoesNotExist.status_code, rv.status_code,
Routes['team_roster'] + " PUT: invalid data")
def testPostYear(self):
"""Test year parameter"""
mocker = MockLeague(self)
# invalid year
rv = self.app.post(Routes['vteam'], data={'year': INVALID_YEAR})
expect = {}
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data),
Routes['vteam'] + " Post: invalid year")
# valid year
team_id = mocker.get_teams()[0]['team_id']
rv = self.app.post(Routes['vteam'], data={'year': VALID_YEAR})
expect = {'games': 1,
'hits_allowed': 3,
'hits_for': 2,
'losses': 1,
'name': 'Advanced Test Sponsor Test Team',
'runs_against': 6,
'runs_for': 1,
'ties': 0,
'wins': 0}
self.output(loads(rv.data))
self.output(expect)
self.assertTrue(len(loads(rv.data).keys()) > 0,
Routes['vteam'] + " Post: valid year")
self.assertEqual(expect,
loads(rv.data)[str(team_id)],
Routes['vteam'] + " Post: valid year")
def testPostGameId(self):
"""Test game id parameter"""
# test an invalid league id
mocker = MockLeague(self)
rv = self.app.post(Routes['vgame'], data={"game_id": INVALID_ID})
expect = []
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data),
Routes['vgame'] + " Post: invalid game id")
# test a valid league id
data = {"game_id": mocker.get_games()[0]['game_id']}
rv = self.app.post(Routes['vgame'], data=data)
games_data = loads(rv.data)
game_data = games_data[0]
expect = 1
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, len(games_data))
self.assertEqual(6, game_data['away_score'])
self.assertEqual(4, len(game_data['away_bats']))
self.assertEqual(1, game_data['home_score'])
self.assertEqual(4, len(game_data['home_bats']))
self.assertLeagueModelEqual(mocker.get_league(), game_data['league'])
def testPostPlayerId(self):
"""Test player id parameter"""
mocker = MockLeague(self)
# test an invalid player id
rv = self.app.post(Routes['vplayer'], data={'player_id': INVALID_ID})
expect = {}
self.output(expect)
self.output(loads(rv.data))
self.assertEqual(expect,
loads(rv.data),
Routes['vplayer'] + " Post: invalid player id")
# test an valid player id
player_id = mocker.get_players()[0]['player_id']
rv = self.app.post(Routes['vplayer'], data={"player_id": player_id})
expect = {'Test Player 1': {'avg': 0.5,
'bats': 2,
'd': 0,
'e': 0,
'fc': 0,
'fo': 0,
'go': 0,
'hr': 1,
'id': player_id,
'k': 1,
'rbi': 2,
's': 0,
'ss': 0}}
self.output(expect)
self.output(loads(rv.data))
self.assertEqual(expect,
loads(rv.data),
Routes['vplayer'] + " Post: valid player id")
def testGetLeagueDoesExistsNoGames(self):
"""Test a get request for a league that exist but invalid year"""
mocker = MockLeague(self)
league = mocker.get_league()
league_id = league['league_id']
result = self.app.get(f"{MAIN_ROUTE}/{INVALID_YEAR}/{league_id}")
expect = []
self.output(loads(result.data))
self.output(expect)
self.assertEqual(expect, loads(result.data),
f"{MAIN_ROUTE}: GET league that exists but no games")
def testGetLeagueExists(self):
"""Test a get request for a league that exists"""
mocker = MockLeague(self)
league = mocker.get_league()
league_id = league['league_id']
result = self.app.get(f"{MAIN_ROUTE}/{VALID_YEAR}/{league_id}")
expect = [mocker.get_division()]
self.output(loads(result.data))
self.output(expect)
self.assertEqual(expect, loads(result.data),
f"{MAIN_ROUTE}: GET league that exists but no games")
def testPlayerName(self):
"""Tests using a player name as a parameter"""
mocker = MockLeague(self)
league = mocker.get_league()
team = mocker.get_teams()[0]
player = mocker.get_players()[0]
sponsor = mocker.get_sponsor()
# test a test player names
params = {'player_name': mocker.get_players()[0]['player_name']}
rv = self.app.post(Routes['vplayerteamLookup'], data=params)
expect = [{
'captain': player,
'color': team['color'],
'espys': 0,
'league_id': league['league_id'],
'sponsor_id': sponsor['sponsor_id'],
'team_id': team['team_id'],
'team_name': team['team_name'],
'year': team['year']
}]
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data), Routes['vplayerteamLookup'])
# test a test player names
player_two = mocker.get_players()[3]
team_two = mocker.get_teams()[1]
params = {'player_name': "Test Player"}
rv = self.app.post(Routes['vplayerteamLookup'], data=params)
expect = [{
'captain': player,
'color': team['color'],
'espys': 0,
'league_id': league['league_id'],
'sponsor_id': sponsor['sponsor_id'],
'team_id': team['team_id'],
'team_name': team['team_name'],
'year': team['year']
}, {
'captain': player_two,
'color': team_two['color'],
'espys': 0,
'league_id': league['league_id'],
'sponsor_id': sponsor['sponsor_id'],
'team_id': team_two['team_id'],
'team_name': team_two['team_name'],
'year': team_two['year']
}]
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data), Routes['vplayerteamLookup'])
def testNonEmptyStat(self):
"""Test a stat that is not empty"""
MockLeague(self)
params = {'stat': "hr"}
rv = self.app.post(Routes['vleagueleaders'], json=params)
self.output(loads(rv.data))
self.assertTrue(len(loads(rv.data)) > 0, Routes['vleagueleaders'] +
" View: hr stat was empty for all years")
def testNonEmptyYear(self):
"""Test a non-empty year"""
MockLeague(self)
params = {'stat': "k", 'year': VALID_YEAR}
rv = self.app.post(Routes['vleagueleaders'], json=params)
self.output(loads(rv.data))
self.assertTrue(len(loads(rv.data)) > 0, Routes['vleagueleaders'] +
" View: hr stat was empty")
def testEmptyYear(self):
"""Test an empty year"""
MockLeague(self)
params = {'stat': "hr", 'year': INVALID_YEAR}
rv = self.app.post(Routes['vleagueleaders'], json=params)
expect = []
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data), Routes['vleagueleaders'] +
" View: empty stat on not-recording year")
def testPostLeagueId(self):
"""Test league id parameter"""
# test an invalid league id
mocker = MockLeague(self)
rv = self.app.post(Routes['vgame'], data={"league_id": INVALID_ID})
expect = []
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data),
Routes['vgame'] + " Post: invalid league id")
# test a valid league id
data = {"league_id": mocker.get_league()['league_id']}
rv = self.app.post(Routes['vgame'], data=data)
expect = 3
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, len(loads(rv.data)),
Routes['vgame'] + " Post: valid league id")
def testInvalidtStat(self):
"""Test a stat that is not valid"""
MockLeague(self)
params = {'stat': "XXX"}
rv = self.app.post(Routes['vleagueleaders'], data=params)
expect = {}
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(
rv.status_code, InvalidField.status_code,
Routes['vleagueleaders'] + " View: invalid stat accepted")
def testPlayerName(self):
"""Test player name parameter"""
mocker = MockLeague(self)
# non existent player name
expect = []
name = "NAME DOES NOT EXISTS FOR REASONS"
rv = self.app.post(Routes['vplayerLookup'], data={'player_name': name})
self.output(expect)
self.output(loads(rv.data))
self.assertEqual(expect, loads(rv.data),
Routes['vplayerLookup'] + ": invalid player name")
# a valid player
expect = [mocker.get_players()[0]]
name = mocker.get_players()[0]['player_name']
rv = self.app.post(Routes['vplayerLookup'], data={'player_name': name})
self.output(expect)
self.output(loads(rv.data))
self.assertEqual(expect, loads(rv.data),
Routes['vplayerLookup'] + ": valid player name")
def testEmail(self):
"""Test email parameter"""
mocker = MockLeague(self)
# non existent player name
expect = []
email = "*****@*****.**"
rv = self.app.post(Routes['vplayerLookup'], data={'email': email})
self.output(expect)
self.output(loads(rv.data))
self.assertEqual(expect, loads(rv.data),
Routes['vplayerLookup'] + ": invalid email")
# a valid email
expect = [mocker.get_players()[0]]
email = mocker.get_player_email(0)
rv = self.app.post(Routes['vplayerLookup'], data={'email': email})
self.output(expect)
self.output(loads(rv.data))
self.assertEqual(expect, loads(rv.data),
Routes['vplayerLookup'] + ": valid email")
def testEspysParameter(self):
"""Test that the espys are properly being calculated"""
mocker = MockLeague(self)
# add an espys to the team
self.add_espys(mocker.get_teams()[0],
mocker.get_sponsor(),
points=1)
# valid league id
league_id = mocker.get_league()['league_id']
team = mocker.get_teams()[0]
team_id = team['team_id']
rv = self.app.post(Routes['vteam'], json={'league_id': league_id})
expect = {'games': 1,
'hits_allowed': 3,
'hits_for': 2,
'losses': 1,
'name': team['team_name'],
'runs_against': 6,
'runs_for': 1,
'ties': 0,
'wins': 0,
'espys': 1}
self.output(loads(rv.data))
self.output(expect)
self.assertTrue(len(loads(rv.data).keys()) > 0,
Routes['vteam'] + " Post: valid year")
self.assertEqual(expect,
loads(rv.data)[str(team_id)],
Routes['vteam'] + " Post: valid year")
def testMockLeague(self):
"""Test schedule view for mocked league"""
league_id = MockLeague(self).league['league_id']
year = datetime.datetime.now().year
url = Routes['vschedule'] + "/" + str(year) + "/" + str(league_id)
rv = self.app.get(url)
game = {'away_team': 'Advanced Test Sponsor Test Team 2',
'home_team': 'Advanced Test Sponsor Test Team',
'score': '1-6'}
expect = ["1-6", "0-0", ""]
self.output(loads(rv.data))
self.output(expect)
for index, game in enumerate(loads(rv.data)['items']):
self.assertEqual(expect[index], game['score'])
def testPostYear(self):
MockLeague(self)
# test an invalid year
rv = self.app.post(Routes['vplayer'], data={'year': INVALID_YEAR})
expect = {}
self.output(expect)
self.output(loads(rv.data))
self.assertEqual(expect,
loads(rv.data),
Routes['vplayer'] + " Post: invalid year")
# test an valid year
rv = self.app.post(Routes['vplayer'], data={"year": VALID_YEAR})
self.output(loads(rv.data))
self.assertTrue(len(loads(rv.data).keys()) > 0,
Routes['vplayer'] + " Post: valid year")
def testPostYear(self):
"""Test the year parameter"""
# test an invalid year
MockLeague(self)
rv = self.app.post(Routes['vgame'], data={"year": INVALID_YEAR})
expect = []
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data),
Routes['vgame'] + " Post: invalid year")
# test a valid year
rv = self.app.post(Routes['vgame'], data={"year": VALID_YEAR})
expect = 3
self.output(loads(rv.data))
self.output(expect)
self.assertTrue(
len(loads(rv.data)) > 0, Routes['vgame'] + " Post: valid year")
def testGroupByTeam(self):
"""Test a non-empty year"""
MockLeague(self)
params = {'stat': "hr", 'year': VALID_YEAR}
not_grouped = self.app.post(Routes['vleagueleaders'], data=params)
params = {'stat': "hr", 'year': VALID_YEAR, 'group_by_team': 0}
grouped = self.app.post(Routes['vleagueleaders'], data=params)
self.output(loads(not_grouped.data))
self.output(loads(grouped.data))
self.assertFalse(
loads(not_grouped.data) == loads(grouped.data),
Routes['vleagueleaders'] + " View: group same as not grouped")
for entry in loads(grouped.data):
self.assertTrue(
entry['team_id'] is None, Routes['vleagueleaders'] +
" View: group by team, team should be None")
self.assertTrue(
entry['team'] is None, Routes['vleagueleaders'] +
" View: group by team, team should be None")
def testEmail(self):
"""Tests using a player email as a parameter"""
mocker = MockLeague(self)
league = mocker.get_league()
team = mocker.get_teams()[0]
player = mocker.get_players()[0]
sponsor = mocker.get_sponsor()
# test a test player emails
params = {'email': mocker.get_player_email(0)}
rv = self.app.post(Routes['vplayerteamLookup'], json=params)
expect = [{
'captain': player,
'color': team['color'],
'espys': 0,
'league_id': league['league_id'],
'sponsor_id': sponsor['sponsor_id'],
'team_id': team['team_id'],
'team_name': team['team_name'],
'year': team['year']
}]
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data), Routes['vplayerteamLookup'])
def testPostTeamId(self):
mocker = MockLeague(self)
# test an invalid team id
rv = self.app.post(Routes['vplayer'], json={'team_id': INVALID_ID})
expect = {}
self.output(expect)
self.output(loads(rv.data))
self.assertEqual(expect, loads(rv.data),
Routes['vplayer'] + " Post: invalid team id")
# test an valid team id
team_id = mocker.get_teams()[0]['team_id']
expect = {
'avg': 0.5,
'bats': 2,
'd': 0,
'e': 0,
'fc': 0,
'fo': 0,
'go': 0,
'hr': 1,
'id': mocker.get_players()[0]['player_id'],
'k': 1,
'rbi': 2,
's': 0,
'ss': 0
}
player_check = mocker.get_players()[0]
rv = self.app.post(Routes['vplayer'], json={"team_id": team_id})
self.output(loads(rv.data))
self.assertTrue(
len(loads(rv.data).keys()) == 2,
Routes['vplayer'] + " Post: valid team id")
self.assertEqual(
loads(rv.data)[player_check['player_name']], expect,
Routes['vplayer'] + " Post: valid team id")
absent_player_name = mocker.get_players()[2]['player_name']
player_present = absent_player_name in loads(rv.data).keys()
self.assertTrue(not player_present,
Routes['vplayer'] + " Post: valid team id")
def testGet(self):
# empty get
rv = self.app.get(Routes['team_roster'] + "/" + str(INVALID_ID))
expect = {'details': INVALID_ID, 'message': TeamDoesNotExist.message}
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data),
Routes['team_roster'] + " GET: team DNE")
self.assertEqual(TeamDoesNotExist.status_code, rv.status_code,
Routes['team_roster'] + " GET: team DNE")
# add some teams
mocker = MockLeague(self)
team = mocker.get_teams()[0]
team_id = team['team_id']
captain = mocker.get_players()[0]
player = mocker.get_players()[1]
league = mocker.get_league()
# get one team
rv = self.app.get(Routes['team_roster'] + "/" + str(team_id))
expect = {
'captain': captain,
'color': team['color'],
'espys': 0,
'league_id': league['league_id'],
'players': [captain, player],
'sponsor_id': team['sponsor_id'],
'team_id': team['team_id'],
'team_name': team['team_name'],
'year': date.today().year
}
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data),
Routes['team_roster'] + " GET: on non-empty set")
def testDelete(self):
""" Test deleting player from team roster"""
# add player to team
mocker = MockLeague(self)
team_id = mocker.get_teams()[0]['team_id']
player_id = mocker.get_players()[0]['player_id']
player_two_id = mocker.get_players()[2]['player_id']
# invalid combination
query = "?player_id=" + str(player_two_id)
url_request = Routes['team_roster'] + "/" + str(team_id) + query
rv = self.app.delete(url_request, headers=headers)
expect = {'details': player_two_id, 'message': PlayerNotOnTeam.message}
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data),
Routes['team_roster'] + "DELETE: Invalid combination")
self.assertEqual(PlayerNotOnTeam.status_code, rv.status_code,
Routes['team_roster'] + " PUT: invalid data")
# team does not exists
query = "?player_id=" + str(player_id)
url_request = Routes['team_roster'] + "/" + str(INVALID_ID) + query
rv = self.app.delete(url_request, headers=headers)
expect = {'details': INVALID_ID, 'message': TeamDoesNotExist.message}
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data),
Routes['team_roster'] + "DELETE: Invalid player id")
self.assertEqual(TeamDoesNotExist.status_code, rv.status_code,
Routes['team_roster'] + " PUT: invalid player id")
# player does not exist
query = "?player_id=" + str(INVALID_ID)
url_request = Routes['team_roster'] + "/" + str(team_id) + query
rv = self.app.delete(url_request, headers=headers)
expect = {'details': INVALID_ID, 'message': PlayerNotOnTeam.message}
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(expect, loads(rv.data),
Routes['team_roster'] + "DELETE: Invalid player id")
self.assertEqual(PlayerNotOnTeam.status_code, rv.status_code,
Routes['team_roster'] + " PUT: invalid player id")
# proper deletion
query = "?player_id=" + str(player_id)
url_request = Routes['team_roster'] + "/" + str(team_id) + query
rv = self.app.delete(url_request, headers=headers)
expect = None
self.output(loads(rv.data))
self.output(expect)
self.assertEqual(SUCCESSFUL_DELETE_CODE, rv.status_code,
Routes['team_roster'] + "DELETE: Invalid combination")
self.assertEqual(expect, loads(rv.data),
Routes['team_roster'] + "DELETE: Invalid combination")
# make sure player it not on team
team = Team.query.get(team_id)
player = Player.query.get(player_id)
self.assertTrue(player.id not in [p.id for p in team.players],
Routes['team_roster'] + " DELETE: player not removed")
self.assertTrue(player.id != team.player_id,
Routes['team_roster'] + " DELETE: player not removed")
