def test_should_add_team_multiple_parents(self): competition = create_default_competition_for_testing("My Comp", 3) sub_comp = TableSubCompetition("My Sub Comp", None, competition, [], 1, False, False, False, False) competition.sub_competitions.append(sub_comp) parent_comp_group_config = CompetitionGroupConfiguration( "Parent Group 1", sub_comp, None, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) comp_group_config = CompetitionGroupConfiguration( "Team Group 1", sub_comp, parent_comp_group_config, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) comp_group = CompetitionConfigurator.create_competition_group( comp_group_config, competition) self.assertEqual(2, len(competition.get_all_groups())) team = Team("My Team", 5, True) competition_team_configuration = CompetitionTeamConfiguration( team, None, comp_group_config, 1, None) comp_team = CompetitionTeam(competition, team) competition.teams = [comp_team] CompetitionConfigurator.process_competition_team_configuration( competition_team_configuration, competition) self.assertEqual(1, len(competition.teams)) self.assertEqual(1, len(comp_group.rankings)) self.assertEqual(1, len(comp_group.parent_group.rankings)) self.assertEqual(comp_team.oid, comp_group.rankings[0].team.oid) self.assertEqual(comp_team.oid, comp_group.parent_group.rankings[0].team.oid)
def test_should_create_group_group_already_setup(self): sub_comp_config = SubCompetitionConfiguration( "My Sub Comp", None, None, None, 1, SubCompetitionConfiguration.TABLE_TYPE, 1, None) comp_group_config = CompetitionGroupConfiguration( "Group 1 Config", sub_comp_config, None, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) # current_groups = [] competition = create_default_competition_for_testing("My Comp") sub_comp = TableSubCompetition("My Sub Comp", [], competition, [], 1, False, False, False, False) competition.sub_competitions.append(sub_comp) group = CompetitionConfigurator.create_competition_group( comp_group_config, competition) # try it again group = CompetitionConfigurator.create_competition_group( comp_group_config, competition) self.assertEqual("Group 1 Config", group.name) self.assertIsNone(group.parent_group) self.assertEqual(group.sub_competition.oid, sub_comp.oid) self.assertEqual(group.group_type, CompetitionGroupConfiguration.RANKING_TYPE) self.assertEqual(0, len(group.rankings)) self.assertEqual(1, len(competition.get_all_groups())) self.assertEqual( 1, len([ g for g in competition.get_all_groups() if g.oid == group.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_create_sub_com_sub_comp_already_created(self): with pytest.raises( DomainError, match="Sub competition My Sub Comp is already setup."): sub_comp = SubCompetitionConfiguration("My Sub Comp", None, None, None, 1, None, 1, None) competition = create_default_competition_for_testing( "My Comp", 5, [sub_comp]) CompetitionConfigurator.create_sub_competition( sub_comp, competition)
def test_should_process_series_game_not_playoff_sub_comp(self): competition = create_default_competition_for_testing("My Comp", 1) with pytest.raises( DomainError, match= "Sub Competition Table Comp is not a playoff sub competition." ): CompetitionConfigurator.process_series_configuration( None, TableSubCompetition("Table Comp", None, competition, [], None, None, None, None, None))
def test_should_fail_group_not_created(self): with pytest.raises( DomainError, match="Group Team Group 1 has not been created yet."): competition = create_default_competition_for_testing("My Comp") sub_comp_config = SubCompetitionConfiguration( "Test", None, None, None, None, None, None, None, None) comp_group_config = CompetitionGroupConfiguration( "Team Group 1", sub_comp_config, None, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) team = Team("My Team", 5, True) competition_team_configuration = CompetitionTeamConfiguration( team, None, comp_group_config, 1, None) CompetitionConfigurator.process_competition_team_configuration( competition_team_configuration, competition)
def test_create_table_sub_com(self): sub_competition_config = TableSubCompetitionConfiguration( "Table Sub", None, [], [], 3, 1, None) competition = create_default_competition_for_testing("My Comp", 5) sub_comp = CompetitionConfigurator.create_table_sub_competition( sub_competition_config, competition) self.assertEqual(sub_competition_config.name, sub_comp.name) self.assertEqual(0, len(sub_comp.records)) self.assertEqual(competition.oid, sub_comp.competition.oid) self.assertEqual(sub_competition_config.order, sub_comp.order) self.assertFalse(sub_comp.setup) self.assertFalse(sub_comp.started) self.assertFalse(sub_comp.finished) self.assertFalse(sub_comp.post_processed)
def test_create_playoff_sub_comp(self): sub_competition_config = PlayoffSubCompetitionConfiguration( "Playoff Sub Sub", None, [], [], [], 3, 1, None) competition = create_default_competition_for_testing("My Comp", 5) sub_comp = CompetitionConfigurator.create_playoff_sub_competition( sub_competition_config, competition) self.assertEqual(sub_competition_config.name, sub_comp.name) self.assertEqual(0, len(sub_comp.series)) self.assertEqual(competition.oid, sub_comp.competition.oid) self.assertEqual(sub_competition_config.order, sub_comp.order) self.assertFalse(sub_comp.setup) self.assertFalse(sub_comp.started) self.assertFalse(sub_comp.finished) self.assertFalse(sub_comp.post_processed) self.assertEqual(1, sub_comp.current_round)
def test_should_fail_too_many_groups(self): with pytest.raises(DomainError, match="Group Team Group 1 has multiple groups 2."): competition = create_default_competition_for_testing("My Comp") sub_comp = TableSubCompetition("My Sub Comp", None, competition, [], 1, False, False, False, False) competition.sub_competitions.append(sub_comp) comp_group_config = CompetitionGroupConfiguration( "Team Group 1", sub_comp, None, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) comp_group = CompetitionConfigurator.create_competition_group( comp_group_config, competition) sub_comp.groups.append(comp_group) team = Team("My Team", 5, True) competition_team_configuration = CompetitionTeamConfiguration( team, None, comp_group_config, 1, None) CompetitionConfigurator.process_competition_team_configuration( competition_team_configuration, competition)
def test_should_create_group_top_parent_exists_middle_does_not(self): sub_comp_config = SubCompetitionConfiguration( "My Sub Comp", None, None, None, 1, SubCompetitionConfiguration.TABLE_TYPE, 1, None) comp_parent_group_config2 = CompetitionGroupConfiguration( "Parent 2 Config", sub_comp_config, None, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) comp_parent_group_config = CompetitionGroupConfiguration( "Parent 1 Config", sub_comp_config, comp_parent_group_config2, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) comp_group_config = CompetitionGroupConfiguration( "Group 1 Config", sub_comp_config, comp_parent_group_config, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) competition = create_default_competition_for_testing("My Comp") sub_comp = TableSubCompetition("My Sub Comp", [], competition, [], 1, False, False, False, False) competition.sub_competitions.append(sub_comp) parent_parent = CompetitionConfigurator.create_competition_group( comp_parent_group_config2, competition) group = CompetitionConfigurator.create_competition_group( comp_group_config, competition) parent = group.parent_group self.assertIsNotNone(parent.parent_group) self.assertEqual(parent_parent.oid, parent.parent_group.oid) self.assertEqual(3, len(competition.get_all_groups())) self.assertEqual( 1, len([ g for g in competition.get_all_groups() if g.oid == group.oid ])) self.assertEqual( 1, len([ g for g in competition.get_all_groups() if g.oid == parent.oid ])) self.assertEqual( 1, len([ g for g in competition.get_all_groups() if g.oid == parent_parent.oid ]))
def test_should_add_team_team_does_not_exist(self): competition = create_default_competition_for_testing("My Comp") sub_comp = TableSubCompetition("My Sub Comp", [], competition, [], 1, False, False, False, False) competition.sub_competitions.append(sub_comp) comp_group_config = CompetitionGroupConfiguration( "Team Group 1", sub_comp, None, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) comp_group = CompetitionConfigurator.create_competition_group( comp_group_config, competition) team = Team("My Team", 5, True) competition_team_configuration = CompetitionTeamConfiguration( team, sub_comp, comp_group_config, 1, None) CompetitionConfigurator.process_competition_team_configuration( competition_team_configuration, competition) self.assertEqual(1, len(competition.teams)) self.assertEqual(1, len(comp_group.rankings)) self.assertEqual(team.oid, comp_group.rankings[0].team.parent_team.oid)
def test_should_not_create_group_sub_competition_does_not_exist(self): with pytest.raises( DomainError, match="You are setting up groups before sub competitions."): sub_comp_config = SubCompetitionConfiguration( "My Sub Comp", None, [], None, 1, SubCompetitionConfiguration.TABLE_TYPE, 1, None) comp_parent_group_config = CompetitionGroupConfiguration( "Parent 1 Config", sub_comp_config, None, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) comp_group_config = CompetitionGroupConfiguration( "Group 1 Config", sub_comp_config, comp_parent_group_config, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) current_groups = [] competition = create_default_competition_for_testing("My Comp") group = CompetitionConfigurator.create_competition_group( comp_group_config, competition)
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_not_create_group_competition_not_there(self): with pytest.raises( DomainError, match="Competition has to exist before the groups can be setup." ): competition = create_default_competition_for_testing("My Comp") competition.sub_competitions = [ TableSubCompetition("My Sub Comp", None, competition, [], None, None, None, None, None) ] sub_comp_config = SubCompetitionConfiguration( "My Sub Comp", None, [], None, 1, SubCompetitionConfiguration.TABLE_TYPE, 1, None) comp_parent_group_config = CompetitionGroupConfiguration( "Parent 1 Config", sub_comp_config, None, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) comp_group_config = CompetitionGroupConfiguration( "Group 1 Config", sub_comp_config, comp_parent_group_config, 1, CompetitionGroupConfiguration.RANKING_TYPE, 1, None) group = CompetitionConfigurator.create_competition_group( comp_group_config, None)
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)
def test_sort_rankings(self): competition = create_default_competition_for_testing("My Comp") table = TableSubCompetition("My Table", [], None, None, 1, False, False, False, False) competition.sub_competitions.append(table) teams = [ helpers.new_comp_team(competition, "Team 1", 5), helpers.new_comp_team(competition, "Team 2", 5), helpers.new_comp_team(competition, "Team 3", 5), helpers.new_comp_team(competition, "Team 4", 5), helpers.new_comp_team(competition, "Team 5", 5), helpers.new_comp_team(competition, "Team 6", 5), helpers.new_comp_team(competition, "Team 7", 5), helpers.new_comp_team(competition, "Team 8", 5) ] records = [ TableRecord(table, -1, teams[0], 255, 10, 0, 0, 0, 0, 0, ""), TableRecord(table, -1, teams[1], 255, 9, 0, 2, 0, 0, 0, ""), TableRecord(table, -1, teams[2], 255, 6, 2, 2, 0, 0, 0, ""), TableRecord(table, -1, teams[3], 255, 7, 3, 0, 0, 0, 0, ""), TableRecord(table, -1, teams[4], 255, 0, 0, 4, 12, 12, 0, ""), TableRecord(table, -1, teams[5], 255, 0, 0, 4, 6, 12, 0, ""), TableRecord(table, -1, teams[6], 255, 0, 0, 4, 12, 6, 0, ""), TableRecord(table, -1, teams[7], 255, 0, 10, 0, 12, 6, 0, "") ] table.records = records group1 = CompetitionGroup("League", None, table, 1, [], CompetitionGroupConfiguration.RANKING_TYPE) group2 = CompetitionGroup("East", None, table, 1, [], CompetitionGroupConfiguration.RANKING_TYPE) group3 = CompetitionGroup("West", None, table, 1, [], CompetitionGroupConfiguration.RANKING_TYPE) [group1.add_team_to_group(t) for t in teams] for i in range(len(records)): if i % 2 == 0: group2.add_team_to_group(teams[i]) else: group3.add_team_to_group(teams[i]) self.assertEqual(8, len(group1.rankings)) self.assertEqual(4, len(group2.rankings)) self.assertEqual(4, len(group3.rankings)) rankings = [] rankings.extend(group1.rankings) rankings.extend(group2.rankings) rankings.extend(group3.rankings) table.sort_rankings(rankings, records) self.assertEqual("Team 1", records[0].team.name) self.assertEqual("Team 2", records[1].team.name) self.assertEqual("Team 4", records[2].team.name) self.assertEqual("Team 3", records[3].team.name) self.assertEqual("Team 7", records[4].team.name) self.assertEqual("Team 5", records[5].team.name) self.assertEqual("Team 6", records[6].team.name) self.assertEqual("Team 8", records[7].team.name) self.assertEqual("Team 1", group1.get_team_by_rank(1).name) self.assertEqual("Team 2", group1.get_team_by_rank(2).name) self.assertEqual("Team 4", group1.get_team_by_rank(3).name) self.assertEqual("Team 3", group1.get_team_by_rank(4).name) self.assertEqual("Team 7", group1.get_team_by_rank(5).name) self.assertEqual("Team 5", group1.get_team_by_rank(6).name) self.assertEqual("Team 6", group1.get_team_by_rank(7).name) self.assertEqual("Team 8", group1.get_team_by_rank(8).name) self.assertEqual("Team 1", group2.get_team_by_rank(1).name) self.assertEqual("Team 3", group2.get_team_by_rank(2).name) self.assertEqual("Team 7", group2.get_team_by_rank(3).name) self.assertEqual("Team 5", group2.get_team_by_rank(4).name) self.assertEqual("Team 2", group3.get_team_by_rank(1).name) self.assertEqual("Team 4", group3.get_team_by_rank(2).name) self.assertEqual("Team 6", group3.get_team_by_rank(3).name) self.assertEqual("Team 8", group3.get_team_by_rank(4).name)
def test_should_fail_no_team_configuration(self): with pytest.raises(DomainError, match="No team configuration given."): competition = create_default_competition_for_testing("My Comp") CompetitionConfigurator.process_competition_team_configuration( None, competition)