def test_league_table(self):
DBSetup().g72_finished()
DBSetup().g62_finished()
expected_overall_table = get_df_from_json('league_table_overall.json')
league_table = LeagueTable()
assert league_table.get_standing(Season.objects.first()).to_json(
) == expected_overall_table.to_json()
def test_get_all_livetickers_only_scheduled(self):
gameday_one = DBSetup().g62_status_empty()
first_game_gameday_one = Gameinfo.objects.filter(
gameday=gameday_one).first()
# only first two games shall be the next scheduled games
Gameinfo.objects.filter(gameday=gameday_one,
pk__gt=first_game_gameday_one.pk +
1).update(scheduled='11:00')
gameday_two = DBSetup().g62_status_empty()
first_game_gameday_two = Gameinfo.objects.filter(
gameday=gameday_two).first()
# only first two games for second gameday shall be the next scheduled games
Gameinfo.objects.filter(gameday=gameday_two,
pk__gt=first_game_gameday_two.pk +
1).update(scheduled='11:00')
Gameday.objects.all().update(date=datetime.today())
response = self.app.get(reverse(API_LIVETICKER_ALL))
assert response.status_code == HTTPStatus.OK
assert len(response.json) == 4
expected_result = self.expected_liveticker_result
expected_result['gameId'] = first_game_gameday_one.pk
print('expected_result', expected_result)
print('actual_result', response.json[0])
assert response.json[0] == expected_result
expected_result['gameId'] = first_game_gameday_two.pk
assert response.json[2] == expected_result
def test_post_team_log_updates_score(self):
DBSetup().g62_status_empty()
firstGame = Gameinfo.objects.first()
response = self.app.post_json(reverse(API_GAMELOG,
kwargs={'id': firstGame.pk}), {
'team':
'A1',
'gameId':
firstGame.pk,
'half':
1,
'event': [{
'name': 'Touchdown',
'player': '19'
}, {
'name': '2-Extra-Punkte',
'player': '7'
}]
},
headers=DBSetup().get_token_header())
assert response.status_code == HTTPStatus.CREATED
home: Gameresult = Gameresult.objects.get(gameinfo=firstGame,
isHome=True)
away: Gameresult = Gameresult.objects.get(gameinfo=firstGame,
isHome=False)
assert home.fh == 8
assert away.fh == 0
def test_delete_entry(self):
DBSetup().g62_status_empty()
game = DBSetup().create_teamlog_home_and_away()
game_service = GameService(game.pk)
gamelog = game_service.delete_gamelog(2)
assert gamelog.get_home_score() == 34
assert gamelog.get_home_firsthalf_score() == 13
def test_league_table_by_division_for_multiple_seasons(self):
test_season = Season.objects.create(name='test season')
another_season = Season.objects.create(name='another season')
any_season = Season.objects.create(name='any season')
all_seasons = [test_season, another_season, any_season]
DBSetup().g62_finished(season=test_season)
DBSetup().g72_finished(season=another_season)
DBSetup().g62_finished(season=any_season)
DBSetup().g72_finished(season=any_season)
west = League.objects.create(name='west')
south = League.objects.create(name='south')
teams_A = Team.objects.filter(name__startswith='A')
teams_B = Team.objects.filter(name__startswith='B')
for season in all_seasons:
for team in teams_A:
SeasonLeagueTeam.objects.create(season=season,
league=south,
team=team)
for team in teams_B:
SeasonLeagueTeam.objects.create(season=season,
league=west,
team=team)
expected_overall_table = get_df_from_json(
'league_table_division_south.json')
league_table = LeagueTable()
assert league_table.get_standing(
league='south',
season=any_season).to_json() == expected_overall_table.to_json()
def test_officials_get(self):
DBSetup().g62_status_empty()
last_game = Gameinfo.objects.last()
DBSetup().create_game_officials(last_game)
response = self.app.get(
reverse(API_GAME_OFFICIALS, kwargs={'pk': last_game.pk}))
assert response.status_code == HTTPStatus.OK
assert len(response.json) == 5
def test_has_finalround(self):
gameday_with_finalround = DBSetup().g62_finalround()
gameday_with_main_round = DBSetup().create_main_round_gameday()
gmw = GamedayModelWrapper(gameday_with_finalround.pk)
assert gmw.has_finalround()
gmw = GamedayModelWrapper(gameday_with_main_round.pk)
assert not gmw.has_finalround()
def test_put_game_possession(self):
DBSetup().g62_status_empty()
last_game: Gameinfo = Gameinfo.objects.last()
assert last_game.in_possession == 'A1'
response = self.app.put_json(reverse(API_GAME_POSSESSION,
kwargs={'pk': last_game.pk}),
{'team': 'name of team'},
headers=DBSetup().get_token_header())
assert response.status_code == HTTPStatus.OK
assert Gameinfo.objects.last().in_possession == 'name of team'
def test_team_log_entry_is_deleted(self):
gameinfo = DBSetup().create_teamlog_home_and_away()
response = self.app.delete_json(reverse(API_GAMELOG,
kwargs={'id': gameinfo.pk}),
{'sequence': 2},
headers=DBSetup().get_token_header())
assert response.status_code == HTTPStatus.OK
json_response = response.json
assert json_response['home']['score'] == 34
assert json_response['home']['firsthalf']['entries'][1]['isDeleted']
def test_post_team_log(self):
DBSetup().g62_status_empty()
another_user = DBSetup().create_new_user()
firstGame = Gameinfo.objects.first()
response = self.app.post_json(
reverse(API_GAMELOG, kwargs={'id': firstGame.pk}), {
'team':
'A1',
'gameId':
firstGame.pk,
'half':
1,
'event': [{
'name': 'Touchdown',
'player': '19'
}, {
'name': '1-Extra-Punkt',
'player': '7'
}]
},
headers=DBSetup().get_token_header(another_user))
assert response.status_code == HTTPStatus.CREATED
assert TeamLog.objects.first().author == another_user
assert response.json == {
'away': {
'firsthalf': {
'entries': [],
'score': 0
},
'name': 'A2',
'score': 0,
'secondhalf': {
'entries': [],
'score': 0
}
},
'gameId': firstGame.pk,
'home': {
'firsthalf': {
'entries': [{
'pat1': 7,
'sequence': 1,
'td': 19
}],
'score': 7
},
'name': 'A1',
'score': 7,
'secondhalf': {
'entries': [],
'score': 0
}
},
'isFirstHalf': True
}
def test_halftime_submitted(self):
DBSetup().g62_status_empty()
firstGame: Gameinfo = Gameinfo.objects.first()
response = self.app.put_json(reverse(API_GAME_HALFTIME,
kwargs={'pk': firstGame.pk}),
headers=DBSetup().get_token_header())
assert response.status_code == HTTPStatus.OK
firstGame = Gameinfo.objects.first()
assert firstGame.status == '2. Halbzeit'
assert re.match('^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]',
str(firstGame.gameHalftime))
def test_liveticker_get_all_ticks(self):
DBSetup().g62_status_empty()
last_game = Gameinfo.objects.last()
home = Gameresult.objects.get(gameinfo=last_game, isHome=True)
away = Gameresult.objects.get(gameinfo=last_game, isHome=False)
DBSetup().create_teamlog_home_and_away(home=home.team,
away=away.team,
gameinfo=last_game)
liveticker = Liveticker(last_game)
liveticker.collect_all_ticks()
ticks = liveticker.get_ticks()
assert len(ticks) == TeamLog.objects.all().count()
def test_league_table_multiple_season(self):
test_season = Season.objects.create(name='test season')
another_season = Season.objects.create(name='another season')
any_season = Season.objects.create(name='any season')
DBSetup().g62_finished(season=test_season)
DBSetup().g72_finished(season=another_season)
DBSetup().g62_finished(season=any_season)
DBSetup().g72_finished(season=any_season)
expected_overall_table = get_df_from_json('league_table_overall.json')
league_table = LeagueTable()
assert league_table.get_standing(
any_season).to_json() == expected_overall_table.to_json()
def test_game_setup_get(self):
DBSetup().g62_status_empty()
last_game = Gameinfo.objects.last()
DBSetup().create_gamesetup(last_game)
response = self.app.get(
reverse(API_GAME_SETUP, kwargs={'pk': last_game.pk}))
assert response.status_code == HTTPStatus.OK
assert response.json == {
"ctResult": "won",
"direction": "arrow_forward",
"fhPossession": "AWAY"
}
def test_update_7_teams_2_fields(self):
gameday = DBSetup().create_empty_gameday()
gameday.format = "7_2"
gameday.save()
group_B = DBSetup().create_teams('B', 3)
group_A = DBSetup().create_teams('A', 4)
groups = [group_A, group_B]
DBSetup().create_playoff_placeholder_teams()
sc = ScheduleCreator(gameday=Gameday.objects.get(pk=gameday.pk),
schedule=Schedule(gameday.format, groups))
sc.create()
Gameinfo.objects.filter(stage='Vorrunde').update(status='beendet')
finished_games = Gameinfo.objects.filter(status='beendet')
for game in finished_games:
update_gameresults(game)
su = ScheduleUpdate(gameday.pk, gameday.format)
su.update()
update_gameresults_by_standing_and_finish_game_for('HF')
su.update()
p5_first = Gameinfo.objects.filter(standing__in=['P5-1', 'P3'])
for game in p5_first:
update_gameresults(game)
p5_first.update(status='beendet')
su = ScheduleUpdate(gameday.pk, gameday.format)
su.update()
p5_first = Gameinfo.objects.filter(standing__in=['P5-2', 'P1'])
for game in p5_first:
update_gameresults(game)
p5_first.update(status='beendet')
def test_schedule_not_created_while_team_not_existent(self):
gameday = DBSetup().create_empty_gameday()
DBSetup().create_playoff_placeholder_teams()
DBSetup().create_teams('A', 3)
DBSetup().create_teams('B', 3)
assert Gameinfo.objects.filter(gameday_id=gameday.pk).exists() is False
groups = [['A1', 'A2', 'unknown team'], ['B1', 'B2', 'B3']]
with pytest.raises(TeamNotExistent) as err:
sc = ScheduleCreator(gameday=Gameday.objects.get(pk=gameday.pk),
schedule=Schedule(gameday.format, groups))
sc.create()
assert str(err.value) == 'unknown team'
assert Gameinfo.objects.all().count() == 0
assert Gameresult.objects.all().count() == 0
def test_update_9_teams_3_fields(self):
gameday = DBSetup().create_empty_gameday()
gameday.format = "9_3"
gameday.save()
group_A = DBSetup().create_teams('A', 3)
group_B = DBSetup().create_teams('B', 3)
group_C = DBSetup().create_teams('C', 3)
groups = [group_A, group_B, group_C]
DBSetup().create_playoff_placeholder_teams()
sc = ScheduleCreator(gameday=Gameday.objects.get(pk=gameday.pk),
schedule=Schedule(gameday.format, groups))
sc.create()
qualify_games = Gameinfo.objects.filter(stage='Vorrunde')
for game in qualify_games:
update_gameresults(game)
Gameinfo.objects.filter(stage='Vorrunde').update(status='beendet')
su = ScheduleUpdate(gameday.pk, gameday.format)
su.update()
check_if_first_standing('PO').is_updated_as_expected_with(
'B2', 'C2', 'C3')
check_if_first_standing('P7').is_updated_as_expected_with(
'A1', 'B1', 'B3')
update_gameresults_by_standing_and_finish_game_for('PO')
update_gameresults_and_finish_first_game_for_P7()
su.update()
check_if_first_standing('HF').is_updated_as_expected_with(
'C2', 'C3', 'B2')
check_if_first_standing('P7').is_updated_as_expected_with(
'B1', 'C1', 'A2')
check_if_first_standing('P5').is_updated_as_expected_with(
'A2', 'B2', 'B1')
update_gameresults_by_standing_and_finish_game_for('HF')
update_gameresults_and_finish_first_game_for_P7()
su.update()
check_if_first_standing('P7').is_updated_as_expected_with(
'C1', 'A1', 'C2')
check_if_first_standing('P1').is_updated_as_expected_with(
'B3', 'C3', 'A1')
check_if_first_standing('P3').is_updated_as_expected_with(
'A3', 'C2', 'C1')
update_gameresults_by_standing_and_finish_game_for('P5')
update_gameresults_and_finish_first_game_for_P7()
update_gameresults_by_standing_and_finish_game_for('P3')
update_gameresults_by_standing_and_finish_game_for('P1')
gmw = GamedayModelWrapper(gameday.pk)
DataFrameAssertion.expect(
gmw.get_final_table()).to_equal_json('final_table_9_teams.json')
DataFrameAssertion.expect(
gmw.get_schedule()).to_equal_json('schedule_9_teams_3_fields.json')
def test_league_table_for_league_is_displayed(self):
DBSetup().g72_finished()
DBSetup().g62_finished()
season = Season.objects.first()
west = League.objects.create(name='west')
south = League.objects.create(name='south')
teams_A = Team.objects.filter(name__startswith='A')
teams_B = Team.objects.filter(name__startswith='B')
for team in teams_A:
SeasonLeagueTeam.objects.create(season=season, league=south, team=team)
for team in teams_B:
SeasonLeagueTeam.objects.create(season=season, league=west, team=team)
response = self.app.get(reverse('league-table-league', kwargs={'season': season, 'league': south}))
assert 'team__name' in response.context['info']['schedule']
def test_update_score(self):
DBSetup().g62_status_empty()
team_A1 = Team.objects.get(name='A1')
team_A2 = Team.objects.get(name='A2')
game = DBSetup().create_teamlog_home_and_away(home=team_A1,
away=team_A2)
gamelog = GameLog(game)
game_service = GameService(game.pk)
game_service.update_score(gamelog)
assert Gameresult.objects.get(gameinfo=game, team=team_A1).fh == 21
assert Gameresult.objects.get(gameinfo=game, team=team_A1).sh == 21
assert Gameresult.objects.get(gameinfo=game, team=team_A1).pa == 3
assert Gameresult.objects.get(gameinfo=game, team=team_A2).fh == 0
assert Gameresult.objects.get(gameinfo=game, team=team_A2).sh == 3
assert Gameresult.objects.get(gameinfo=game, team=team_A2).pa == 42
def test_get_all_games_to_whistle_for_all_teams(self):
gameday = DBSetup().g62_status_empty()
first_game = Gameinfo.objects.first()
Gameinfo.objects.filter(id=first_game.pk).update(gameFinished='12:00')
gs = GamedayService.create(gameday.pk)
games_to_whistle = gs.get_games_to_whistle('*')
assert len(games_to_whistle) == 10
def test_mark_log_deleted(self):
gameinfo = DBSetup().create_teamlog_home_and_away()
first_team = Team.objects.first()
sequence = 2
gamelog = GameLog(gameinfo)
gamelog.mark_entries_as_deleted(sequence)
gamelog_list = TeamLog.objects.filter(sequence=sequence)
assert gamelog_list[
0].isDeleted, 'touchdown should be marked as deleted'
assert gamelog_list[1].isDeleted, 'PAT should be marked as deleted'
actual_gamelog = TeamLog.objects.filter(gameinfo=gameinfo,
team=first_team,
half=1)
actual_gamelog_entries_as_json = gamelog.create_entries_for_half(
actual_gamelog)
assert actual_gamelog_entries_as_json == [{
'sequence': 1,
'td': 19,
}, {
'sequence': 2,
'td': 19,
'pat2': 7,
'isDeleted': True
}, {
'sequence': 3,
'td': 19,
'pat1': 7,
}]
assert gamelog.get_home_firsthalf_score() == 13
assert gamelog.get_home_score() == 34
def test_get_games_to_whistle_for_specific_team(self):
gameday = DBSetup().g62_status_empty()
first_game = Gameinfo.objects.first()
first_team = Team.objects.first()
# first game is done and isn't counted
Gameinfo.objects.filter(id=first_game.pk).update(gameFinished='13:00')
# second game is officiated be a different team and isn't counted
Gameinfo.objects.filter(id=first_game.pk +
1).update(officials=first_team.pk + 1)
response = self.app.get(reverse(API_GAMEDAY_WHISTLEGAMES,
kwargs={
'pk': gameday.pk,
'team': 'officials'
}),
headers=DBSetup().get_token_header())
assert len(response.json) == 4
def test_entries_per_half(self):
firstGameEntry = DBSetup().create_teamlog_home_and_away()
gamelog = GameLog(firstGameEntry)
assert len(gamelog.get_entries_home_firsthalf()) == 5
assert len(gamelog.get_entries_home_secondhalf()) == 5
assert len(gamelog.get_entries_away_firsthalf()) == 0
assert len(gamelog.get_entries_away_secondhalf()) == 4
def test_only_one_gameday_is_live(self):
gameday = DBSetup().g62_status_empty()
first_game = Gameinfo.objects.first()
Gameinfo.objects.filter(pk__gt=first_game.pk +
1).update(scheduled='11:00')
liveticker_service = LivetickerService(gameday.pk)
assert len(liveticker_service.get_liveticker()) == 2
def test_multiple_gamedays_are_live(self):
gameday_one = DBSetup().g62_status_empty()
first_game_gameday_one = Gameinfo.objects.filter(
gameday=gameday_one).first()
Gameinfo.objects.filter(gameday=gameday_one,
pk__gt=first_game_gameday_one.pk +
1).update(scheduled='11:00')
gameday_two = DBSetup().g62_status_empty()
first_game_gameday_two = Gameinfo.objects.filter(
gameday=gameday_two).first()
Gameinfo.objects.filter(gameday=gameday_two,
pk__gt=first_game_gameday_two.pk +
1).update(scheduled='11:00')
Gameday.objects.all().update(date=datetime.today())
liveticker_service = LivetickerService()
assert len(liveticker_service.get_liveticker()) == 4
def test_is_home_in_possession(self):
DBSetup().g62_status_empty()
last_game: Gameinfo = Gameinfo.objects.last()
last_game.in_possession = 'A1'
liveticker = Liveticker(last_game)
assert liveticker.is_home_in_possession()
assert not liveticker.is_away_in_possession()
def test_schedule_is_updated(self, update_mock):
DBSetup().g62_status_empty()
gi: Gameinfo = Gameinfo.objects.first()
gi.status = 'beendet'
gi.save()
update_mock.assert_called_once()
def test_get_qualify_table(self):
gameday = DBSetup().g62_qualify_finished()
gmw = GamedayModelWrapper(gameday.pk)
expected_qualify_table = get_df_from_json('ts_qualify_table')
assert_frame_equal(gmw.get_qualify_table(),
expected_qualify_table,
check_dtype=False)
def test_get_team_by_points(self):
gameday = DBSetup().g62_finalround(sf='beendet')
gmw = GamedayModelWrapper(gameday.pk)
assert gmw.get_team_by_points(place=1, standing='HF', points=0) == 'B2'
assert gmw.get_team_by_points(place=1, standing='HF', points=3) == 'A1'
assert gmw.get_team_by_points(place=2, standing='HF', points=0) == 'A2'
assert gmw.get_team_by_points(place=2, standing='HF', points=3) == 'B1'
def test_get_mulitple_teams_by_standing_and_points(self):
gameday = DBSetup().g72_qualify_finished()
all_games = Gameinfo.objects.filter(gameday=gameday)
for game in all_games:
update_gameresults(game)
gmw = GamedayModelWrapper(gameday.pk)
assert gmw.get_teams_by(standing='HF', points=3) == ['B2', 'B1']