def __init__(self, series_by_wins_rules):
SeriesByWinsRules.__init__(self, series_by_wins_rules.name,
series_by_wins_rules.required_wins,
series_by_wins_rules.game_rules,
series_by_wins_rules.home_pattern,
series_by_wins_rules.oid)
def test_should_process_series_game_config(self):
playoff_comp_config = PlayoffSubCompetitionConfiguration(
"Playoff Comp", None, None, [], [], 1, 1, None)
group1 = CompetitionGroupConfiguration("Group 1", playoff_comp_config,
None, 1, None, 1, None)
group3 = CompetitionGroupConfiguration("Group 3", playoff_comp_config,
None, 1, None, 1, None)
group4 = CompetitionGroupConfiguration("Group 4", playoff_comp_config,
None, 1, None, 1, None)
series_config = SeriesConfiguration(
"Series 1", 5, playoff_comp_config, group1, 1, group1, 2,
SeriesByWinsRules("My Rules", 5, None, None, None), None, group3,
group4, group3, group4, 1, None)
competition = create_default_competition_for_testing("My Comp", 1)
playoff_comp = PlayoffSubCompetition("Playoff Comp", [], competition,
[], None, None, None, None, None,
None)
competition.sub_competitions.append(playoff_comp)
CompetitionConfigurator.process_series_configuration(
series_config, playoff_comp)
self.assertEqual(1, len(competition.sub_competitions[0].series))
new_series = competition.sub_competitions[0].series[0]
self.assertEqual("Series 1", new_series.name)
self.assertEqual(3, len(competition.get_all_groups()))
def create_default_playoff(groups):
competition = create_default_competition_for_testing("My Comp")
playoff = PlayoffSubCompetition("Playoff", [], competition, None, 1, 1, False, False, False, False)
competition.sub_competitions.append(playoff)
league = CompetitionGroup("League", None, None, 1, [], CompetitionGroupConfiguration.RANKING_TYPE)
r1_winners_group = CompetitionGroup("R1 Winners", None, 1, playoff, [], CompetitionGroupConfiguration.RANKING_TYPE)
r1_losers_group = CompetitionGroup("R1 Losers", None, 1, playoff, [], CompetitionGroupConfiguration.RANKING_TYPE)
r2_winners_group = CompetitionGroup("R2 Winners", None, 1, playoff, [], CompetitionGroupConfiguration.RANKING_TYPE)
r2_losers_group = CompetitionGroup("R2 Losers", None, 1, playoff, [], CompetitionGroupConfiguration.RANKING_TYPE)
eliminated = CompetitionGroup("Eliminated Group", None, 1, playoff, [], CompetitionGroupConfiguration.RANKING_TYPE)
league.rankings = [
CompetitionRanking(league, helpers.new_comp_team(competition, "Team 1", 5), 1),
CompetitionRanking(league, helpers.new_comp_team(competition, "Team 2", 5), 2),
CompetitionRanking(league, helpers.new_comp_team(competition, "Team 3", 5), 3),
CompetitionRanking(league, helpers.new_comp_team(competition, "Team 4", 5), 4),
CompetitionRanking(league, helpers.new_comp_team(competition, "Team 5", 5), 5),
CompetitionRanking(league, helpers.new_comp_team(competition, "Team 6", 5), 6),
CompetitionRanking(league, helpers.new_comp_team(competition, "Team 7", 5), 7),
CompetitionRanking(league, helpers.new_comp_team(competition, "Team 8", 5), 8),
CompetitionRanking(league, helpers.new_comp_team(competition, "Team 9", 5), 9),
CompetitionRanking(league, helpers.new_comp_team(competition, "Team 10", 5), 10),
]
groups.extend([league, r1_winners_group, r1_losers_group, r2_winners_group, r2_losers_group, eliminated])
game_rules_tie = GameRules("Can Tie", True)
game_rules_no_tie = GameRules("No Tie", False)
series_rules_by_goals_2 = SeriesByGoalsRules("By Goals 2 Games", 2, game_rules_tie, game_rules_no_tie, None)
series_rules_by_goals_3 = SeriesByGoalsRules("By Goals 3 Games", 3, game_rules_tie, game_rules_no_tie, None)
series_rules_by_goals_1 = SeriesByGoalsRules("By Goals 1 Games", 1, game_rules_tie, game_rules_no_tie, None)
series_rules_wins_4 = SeriesByWinsRules("4 wins", 4, game_rules_no_tie, [0, 0, 1, 1, 0, 1, 0])
series1 = SeriesByGoals(playoff, "Series 1", 1, None, None, 0, 0, 0, series_rules_by_goals_2,
league, 1, league, 8, r1_winners_group, league, r1_losers_group, league, False, False)
series2 = SeriesByGoals(playoff, "Series 2", 1, None, None, 0, 0, 0, series_rules_by_goals_3,
league, 2, league, 7, r1_winners_group, league, r1_losers_group, league, False, False)
series3 = SeriesByGoals(playoff, "Series 3", 1, None, None, 0, 0, 0, series_rules_by_goals_1,
league, 3, league, 6, r1_winners_group, league, r1_losers_group, league, False, False)
series4 = SeriesByWins(playoff, "Series 4", 1, None, None, 0, 0, series_rules_wins_4,
league, 4, league, 5, r1_winners_group, league, r1_losers_group, league, False, False)
series5 = SeriesByWins(playoff, "Series 5", 2, None, None, 0, 0, series_rules_wins_4,
r1_winners_group, 1, r1_winners_group, 4, r2_winners_group, league, r2_losers_group, league, False, False)
series6 = SeriesByGoals(playoff, "Series 6", 2, None, None, 0, 0, 0, series_rules_by_goals_1,
r1_winners_group, 2, r1_winners_group, 3, r2_winners_group, league, r2_losers_group, league, False, False)
series7 = SeriesByGoals(playoff, "Series 7", 2, None, None, 0, 0, 0, series_rules_by_goals_1,
r1_losers_group, 1, league, 2, r1_losers_group, eliminated, league, eliminated, league, False, False)
playoff.series.extend([series1, series2, series3, series4, series5, series6, series7])
return playoff
def test_should_process_by_goals_method_wrong_rules(self):
with pytest.raises(
DomainError,
match="Series My Configuration does not have the correct rules."
):
series = CompetitionConfigurator.process_series_by_goals_configuration(
SeriesConfiguration(
"My Configuration", 5, None, None, None, None, None,
SeriesByWinsRules("Test Rules", 4, None, None), None, None,
None, None, None, 1, None), None, None)
def create_best_of_series_rules(self,
series_name,
required_wins,
rules_id,
home_progression,
session=None):
commit = session is None
session = self.get_session(session)
repo = BasicRepository()
game_rules_repo = GameRulesRepository()
rules = game_rules_repo.get_by_oid(rules_id)
series_rules = SeriesByWinsRules(series_name, required_wins, rules,
home_progression)
repo.add(series_rules, session, SeriesByWinsRulesDTO)
self.commit(session, commit)
def setup_default_series(games):
home_team = Team("Team 1", 5, True)
away_team = Team("Team 2", 5, True)
competition = create_default_competition_for_testing("My Comp")
sub_competition = PlayoffSubCompetition("My Playoff", None,
competition, None, 1, 1, True,
False, False, False)
home_competition_team = CompetitionTeam(competition, home_team)
away_competition_team = CompetitionTeam(competition, away_team)
game_rules = GameRules("My Rules", False)
series_rules = SeriesByWinsRules("My Rules", games, game_rules, None)
series = SeriesByWins(sub_competition, "My Series", 1,
home_competition_team, away_competition_team, 0,
0, series_rules, None, None, None, None, None,
None, None, None, True, False)
return series
def test_should_process_by_wins_method(self):
competition = create_default_competition_for_testing("Test", 1)
sub_comp = PlayoffSubCompetition("Test", [], competition, [], 1, 1,
False, False, False, False)
competition.sub_competitions.append(sub_comp)
sub_comp_config = SubCompetitionConfiguration("Test", None, None, None,
None, None, None, None,
None)
group1 = CompetitionGroupConfiguration("Group 1", sub_comp_config,
None, 1, None, 1, None)
group3 = CompetitionGroupConfiguration("Group 3", sub_comp_config,
None, 1, None, 1, None)
group4 = CompetitionGroupConfiguration("Group 4", sub_comp_config,
None, 1, None, 1, None)
sub_comp.groups = [
CompetitionConfigurator.create_competition_group(
group1, competition),
CompetitionConfigurator.create_competition_group(
group3, competition),
CompetitionConfigurator.create_competition_group(
group4, competition)
]
series = CompetitionConfigurator.processes_series_by_wins_configuration(
SeriesConfiguration(
"Series 1", 5, None, group1, 1, group1, 2,
SeriesByWinsRules("My Rules", 4, None, None, None), group3,
group4, group3, group4, 1, None), sub_comp)
self.assertEqual("Series 1", series.name)
self.assertEqual("Group 1", series.home_team_from_group.name)
self.assertEqual("Group 1", series.away_team_from_group.name)
self.assertEqual("Group 3", series.winner_to_group.name)
self.assertEqual("Group 3", series.loser_to_group.name)
self.assertEqual("Group 4", series.winner_rank_from.name)
self.assertEqual("Group 4", series.loser_rank_from.name)
from teams.ConsoleUI.views.playoff_views import SeriesView
from teams.domain.comp_configorator import CompetitionConfigurator
from teams.domain.competition_configuration import CompetitionConfiguration, RankingGroupConfiguration, \
SeriesConfiguration, PlayoffSubCompetitionConfiguration, CompetitionTeamConfiguration
from teams.domain.game import GameRules
from teams.domain.scheduler import Scheduler
from teams.domain.series import SeriesByGoals, SeriesByWins
from teams.domain.series_rules import SeriesByWinsRules
from teams.services.game_service import GameService
from teams.services.view_models.playoff_view_models import SeriesViewModel
from teams.services.view_models.team_view_models import TeamViewModel
from tests.teams.domain.competition.testing_sample_data import western_teams, eastern_teams, pacific_teams, teams, \
central_teams, atlantic_teams, north_teams
playoff_game_rules = GameRules("Playoff Rules", False)
series_rules = SeriesByWinsRules("Best of 7", 4, playoff_game_rules,
[0, 0, 1, 1, 0, 1, 0])
series_rules_3 = SeriesByWinsRules("Best of 3", 2, playoff_game_rules,
[0, 0, 1])
competition_config = CompetitionConfiguration("Playoff Test", [], [], 1, 1,
None)
playoff_config = PlayoffSubCompetitionConfiguration("Playoff",
competition_config, [], [],
[], 1, 1, None)
competition_config.sub_competitions.append(playoff_config)
team_configs = []
# seeding group
league_config = RankingGroupConfiguration("League", playoff_config, None, 1, 1,
None)
def setup_config(rand, canadian_league_name, american_league_name,
playoff_name, season_game_rules, playoff_game_rules):
min_skill = 0
max_skill = 10
toronto = Team("Toronto", rand.randint(min_skill, max_skill), True)
montreal = Team("Montreal", rand.randint(min_skill, max_skill), True)
ottawa = Team("Ottawa", rand.randint(min_skill, max_skill), True)
quebec_city = Team("Quebec City", rand.randint(min_skill, max_skill), True)
vancouver = Team("Vancouver", rand.randint(min_skill, max_skill), True)
calgary = Team("Calgary", rand.randint(min_skill, max_skill), True)
edmonton = Team("Edmonton", rand.randint(min_skill, max_skill), True)
winnipeg = Team("Winnipeg", rand.randint(min_skill, max_skill), True)
boston = Team("Boston", rand.randint(min_skill, max_skill), True)
detroit = Team("Detroit", rand.randint(min_skill, max_skill), True)
new_york = Team("New York", rand.randint(min_skill, max_skill), True)
series_rules = SeriesByWinsRules("Best of 7", 4, playoff_game_rules,
[0, 0, 1, 1, 0, 1, 0])
series_rules_2 = SeriesByWinsRules("Best of 3", 2, playoff_game_rules,
[1, 0, 0])
competition_config = CompetitionConfiguration("Test", [], [], 1, 1, None)
# table config
canadian_table_config = TableSubCompetitionConfiguration(
canadian_league_name, competition_config, [], [], 1, 1, None)
american_table_config = TableSubCompetitionConfiguration(
american_league_name, competition_config, [], [], 1, 1, None)
competition_config.sub_competitions.append(canadian_table_config)
competition_config.sub_competitions.append(american_table_config)
canadian_config = RankingGroupConfiguration("Canadian",
canadian_table_config, None, 1,
1, None)
western_config = RankingGroupConfiguration("Western",
canadian_table_config,
canadian_config, 2, 1, None)
eastern_config = RankingGroupConfiguration("Eastern",
canadian_table_config,
canadian_config, 2, 1, None)
american_config = RankingGroupConfiguration("American",
american_table_config, None, 1,
1, None)
all_teams = [
calgary, edmonton, toronto, montreal, ottawa, vancouver, quebec_city,
winnipeg, boston, detroit, new_york
]
western_teams = [calgary, edmonton, vancouver, winnipeg]
eastern_teams = [toronto, montreal, ottawa, quebec_city]
american_teams = [boston, detroit, new_york]
canadian_teams = [
calgary, edmonton, toronto, montreal, ottawa, vancouver, quebec_city,
winnipeg
]
team_group_map = {
western_config.name: {
"config": western_config,
"teams": western_teams,
"sub_comp": canadian_table_config
},
eastern_config.name: {
"config": eastern_config,
"teams": eastern_teams,
"sub_comp": canadian_table_config
},
american_config.name: {
"config": american_config,
"teams": american_teams,
"sub_comp": american_table_config
},
canadian_config.name: {
"config": canadian_config,
"teams": canadian_teams,
"sub_comp": canadian_table_config
}
}
team_configs = []
for key in team_group_map.keys():
config = team_group_map[key]["config"]
teams = team_group_map[key]["teams"]
sub_comp = team_group_map[key]["sub_comp"]
for t in teams:
team_configs.append(
CompetitionTeamConfiguration(t, competition_config, config, 1,
None))
sub_comp.competition_groups.append(config)
competition_config.teams = team_configs
# playoff config
playoff_config = PlayoffSubCompetitionConfiguration(
playoff_name, competition_config, [], [], [], 1, 1, None)
competition_config.sub_competitions.append(playoff_config)
r1_winners = RankingGroupConfiguration("R1 Winners", playoff_config, None,
1, 1, None)
american_rep = RankingGroupConfiguration("American Champion",
playoff_config, None, 1, 1, None)
champion = RankingGroupConfiguration("Champion", playoff_config, None, 1,
1, None)
runner_up = RankingGroupConfiguration("Runner Up", playoff_config, None, 1,
1, None)
can_am_winners = RankingGroupConfiguration("CanAm Challenge Winners",
playoff_config, None, 1, 1,
None)
playoff_config.competition_groups = [
r1_winners, champion, runner_up, american_rep
]
# round 1
r1s1 = SeriesConfiguration("R1S1", 1, playoff_config, western_config, 1,
eastern_config, 2, series_rules, r1_winners,
canadian_config, None, None, 1, None)
r1s2 = SeriesConfiguration("R1S2", 1, playoff_config, eastern_config, 1,
western_config, 2, series_rules, r1_winners,
canadian_config, None, None, 1, None)
r1s3 = SeriesConfiguration("AMF", 1, playoff_config, american_config, 1,
american_config, 2, series_rules, american_rep,
american_config, None, None, 1, None)
# Final
final = SeriesConfiguration("Final", 2, playoff_config, r1_winners, 1,
r1_winners, 2, series_rules, champion,
canadian_config, runner_up, canadian_config, 1,
None)
# misc
can_am = SeriesConfiguration("CanAm", 3, playoff_config, canadian_config,
8, american_rep, 1, series_rules_2,
can_am_winners, None, None, None, 1, None)
series_config = [r1s1, r1s2, r1s3, final, can_am]
playoff_config.series = series_config
# configuration done
return competition_config
from teams.domain.series_rules import SeriesByWinsRules
from teams.domain.sub_competition import PlayoffSubCompetition
from teams.domain.team import Team
home_team = Team("Team 1", 5, True)
away_team = Team("Team 2", 5, True)
competition = Competition("My Comp", 1, None, None, True, True, False, False)
sub_competition = PlayoffSubCompetition("Playoff A", None, competition, 1, 1, True, True, False, False)
home_competition_team = CompetitionTeam(competition, home_team)
away_competition_team = CompetitionTeam(competition, away_team)
game_rules = GameRules("Playoff", False)
series_rules = SeriesByWinsRules("My Rules", 4, game_rules, [0, 0, 1, 1, 0, 1, 0])
series = SeriesByWins(sub_competition, "My Series", 1, home_competition_team, away_competition_team,
0, 0, series_rules, None, None, None, None, None, None, None, None,
True, False)
games = []
print(series.name)
while not series.is_complete():
complete_games = [g for g in games if g.complete and g.processed]
incomplete_games = [g for g in games if not g.complete]
games.extend(series.get_new_games(len(complete_games), len(incomplete_games)))
r = random