def test_add_new_team(self):
session = self.setup_basic_test()
team_id = IDHelper.get_new_id()
team = Team("Record Add For New Team", 5, True, team_id)
record = Record(1, team, 1, 2, 3, 4, 5, 6, 7, IDHelper.get_new_id())
self.get_repo().add(record, session)
session.commit()
result = self.get_repo().get_by_oid(record.oid, session)
self.assertEqual(result.oid, record.oid)
self.assertEqual(result.team.oid, record.team.oid)
def __init__(self, team, competition_configuration, group_configuration, first_year, last_year, oid=None):
self.team = team
self.competition_configuration = competition_configuration
self.group_configuration = group_configuration
self.oid = IDHelper.get_id(oid)
YearRestricted.__init__(self, first_year, last_year)
def __init__(self, name, sub_competition_configs, team_configs, order, first_year, last_year, oid=None):
self.name = name
self.order = order
self.sub_competitions = sub_competition_configs
self.teams = team_configs
self.oid = IDHelper.get_id(oid)
YearRestricted.__init__(self, first_year, last_year)
def test_get_all(self):
session = self.setup_basic_test()
team_names = ["Team A1", "Team A2", "Team A5"]
[
self.get_team_repo().add(Team(t, 0, True, IDHelper.get_new_id()),
session) for t in team_names
]
session.commit()
[
self.get_repo().add(
Record(1, team, 1, 2, 3, 4, 5, 6, 7, IDHelper.get_new_id()),
session) for team in self.get_team_repo().get_all(session)
]
session.commit()
self.assertEqual(3, len(self.get_repo().get_all(session)))
def setup_record_query_data(self, session):
team_list = []
for i in range(10):
new_id = IDHelper.get_new_id()
team_list.append(Team("GBYN " + str(i), i, True, new_id))
[self.get_team_repo().add(t, session) for t in team_list]
# need them to be DTOs!
team_list = self.get_team_repo().get_all(session)
record_year_30 = [
self.get_repo().add(
Record(1, team_list[0], 30, 0, 0, 0, 0, 0, 0, self.get_id()),
session),
self.get_repo().add(
Record(2, team_list[1], 30, 0, 0, 0, 0, 0, 0, self.get_id()),
session),
self.get_repo().add(
Record(3, team_list[2], 30, 0, 0, 0, 0, 0, 0, self.get_id()),
session),
]
record_year_31 = [
self.get_repo().add(
Record(1, team_list[2], 31, 0, 0, 0, 0, 0, 0, self.get_id()),
session),
self.get_repo().add(
Record(1, team_list[4], 31, 0, 0, 0, 0, 0, 0, self.get_id()),
session),
self.get_repo().add(
Record(1, team_list[6], 31, 0, 0, 0, 0, 0, 0, self.get_id()),
session),
self.get_repo().add(
Record(1, team_list[8], 31, 0, 0, 0, 0, 0, 0, self.get_id()),
session),
self.get_repo().add(
Record(1, team_list[9], 31, 0, 0, 0, 0, 0, 0, self.get_id()),
session),
]
record_year_32 = [
self.get_repo().add(
Record(1, team_list[5], 32, 0, 0, 0, 0, 0, 0, self.get_id()),
session),
self.get_repo().add(
Record(1, team_list[3], 32, 0, 0, 0, 0, 0, 0, self.get_id()),
session),
]
record_year_33 = [
self.get_repo().add(
Record(1, team_list[1], 33, 0, 0, 0, 0, 0, 0, self.get_id()),
session),
]
session.commit()
def __init__(self, name, competition_configuration, competition_group_configs, competition_team_configs, order, sub_competition_type, first_year, last_year, oid=None):
self.name = name
self.competition_configuration = competition_configuration
self.competition_groups = competition_group_configs
self.order = order
self.sub_competition_type = sub_competition_type
self.competition_teams = competition_team_configs
self.oid = IDHelper.get_id(oid)
YearRestricted.__init__(self, first_year, last_year)
def __init__(self, year, day, home_team, away_team, home_score, away_score, complete, processed, rules, oid=None):
self.year = year
self.day = day
self.home_team = home_team
self.away_team = away_team
self.home_score = home_score
self.away_score = away_score
self.complete = complete
self.oid = IDHelper.get_id(oid)
self.rules = rules
self.processed = processed
def __init__(self, name, sub_competition_configuration, parent_group_configuration, group_level, group_type,
first_year, last_year, oid=None):
self.name = name
if sub_competition_configuration is None:
raise DomainError("CompetitionGroupConfiguration must be part of a sub competition.")
self.sub_competition_configuration = sub_competition_configuration
self.parent_group_configuration = parent_group_configuration
self.group_level = group_level
self.group_type = group_type
self.oid = IDHelper.get_id(oid)
YearRestricted.__init__(self, first_year, last_year)
def __init__(self,
name,
parent_group,
sub_competition,
level,
rankings,
group_type,
oid=None):
self.name = name
self.parent_group = parent_group
self.sub_competition = sub_competition
self.group_type = group_type
self.level = level
self.rankings = rankings
self.oid = IDHelper.get_id(oid)
def should_get_by_status(self):
session = self.setup_basic_test()
for i in range(5):
oid = IDHelper.get_new_id()
active = True
if i % 2 == 0:
active = False
self.get_repo().add(
TeamDTO(Team("team " + str(i) + " add_all", i, True, oid)),
session)
session.commit()
result = self.get_repo().get_by_active_status(True)
self.assertEqual(2, len(result))
result = self.get_repo().get_by_active_status(True)
self.assertEqual(3, len(result))
def test_get_by_oid(self):
session = self.setup_basic_test()
oid = ""
for i in range(5):
oid = IDHelper.get_new_id()
self.get_repo().add(
self.create_object(name="team " + str(i) + " add_all",
skill=i,
active=True,
id=oid), session)
session.commit()
dto = self.get_repo().get_by_oid(oid, session)
self.assertIsNotNone(dto, oid)
self.assertEqual(dto.oid, oid)
def __init__(self,
rank,
team,
year,
wins,
loses,
ties,
goals_for,
goals_against,
skill,
oid=None):
self.oid = IDHelper.get_id(oid)
self.rank = rank
self.team = team
self.year = year
self.wins = wins
self.loses = loses
self.ties = ties
self.goals_for = goals_for
self.goals_against = goals_against
self.skill = skill
def __init__(self,
name,
year,
sub_competitions,
teams,
current_round,
setup,
started,
finished,
post_processed,
oid=None):
self.name = name
self.year = year
self.setup = setup
self.started = started
self.sub_competitions = sub_competitions
self.teams = teams
self.finished = finished
self.post_processed = post_processed
self.oid = IDHelper.get_id(oid)
self.current_round = current_round
def __init__(self,
sub_competition,
name,
series_round,
home_team,
away_team,
series_type,
series_rules,
home_team_from_group,
home_team_value,
away_team_from_group,
away_team_value,
winner_to_group,
winner_rank_from,
loser_to_group,
loser_rank_from,
setup,
post_processed,
oid=None):
self.sub_competition = sub_competition
self.name = name
self.series_round = series_round
self.home_team = home_team
self.away_team = away_team
self.series_type = series_type
self.series_rules = series_rules
self.home_team_from_group = home_team_from_group
self.home_team_value = home_team_value
self.away_team_from_group = away_team_from_group
self.away_team_value = away_team_value
self.winner_to_group = winner_to_group
self.winner_rank_from = winner_rank_from
self.loser_to_group = loser_to_group
self.loser_rank_from = loser_rank_from
self.setup = setup
self.post_processed = post_processed
self.oid = IDHelper.get_id(oid)
def get_id():
return IDHelper.get_new_id()
def __init__(self, competition_group, competition_team, rank, oid=None):
self.group = competition_group
self.team = competition_team
self.rank = rank
self.oid = IDHelper.get_id(oid)
def __init__(self, name, game_rules, series_type, home_pattern, oid=None):
self.name = name
self.series_type = series_type
self.game_rules = game_rules
self.home_pattern = home_pattern
self.oid = IDHelper.get_id(oid)
def __init__(self, name, can_tie, oid=None):
self.oid = IDHelper.get_id(oid)
self.name = name
self.can_tie = can_tie
