def setUp(self):
super(TestScoreEntered, self).setUp()
self.injector.inject(self.tourn_1, num_players=5)
tourn = Tournament(self.tourn_1)
tourn.update({
'rounds': 2,
'missions': ['foo_mission_1', 'foo_mission_2']
})
tourn.make_draws()
class TournamentInProgress(AppSimulatingTest):
def setUp(self):
super(TournamentInProgress, self).setUp()
self.name = 'test_in_progress'
self.player_1 = 'p1'
self.injector.inject(self.name, num_players=0)
self.injector.add_player(self.name, self.player_1)
self.tournament = Tournament(self.name)
self.tournament.update({
'rounds': 1,
'missions': ['mission01'],
'score_categories': [score_cat_args('cat', 100, True, 1, 1, False)]
})
def test_default_state(self):
self.assertFalse(self.tournament.get_dao().in_progress)
def test_no_categories(self):
self.tournament.update({'score_categories': []})
self.assertRaises(ValueError, self.tournament.set_in_progress)
def test_no_entries(self):
self.tournament.update({'rounds': 0})
dao = self.tournament.get_dao()
Reg.query.filter_by(tournament_id=dao.id).delete()
TournamentEntry.query.filter_by(tournament_id=dao.name).delete()
self.assertRaises(ValueError, self.tournament.set_in_progress)
def test_no_missions(self):
self.tournament.update({'rounds': 0})
self.tournament.update({'rounds': 1})
self.assertRaises(ValueError, self.tournament.set_in_progress)
def test_no_rounds(self):
self.tournament.update({'rounds': 0})
self.assertRaises(ValueError, self.tournament.set_in_progress)
def test_set_in_progress(self):
self.tournament.set_in_progress()
self.assertTrue(self.tournament.get_dao().in_progress)
def test_non_finalised_only_actions(self):
self.tournament.set_in_progress()
args = score_cat_args('disallowed_cat', 100, True, 1, 1)
self.assertRaises(ValueError, self.tournament.update,
{'score_categories': [args]})
self.assertRaises(ValueError, self.tournament.update, {'rounds': 5})
rego = Reg(self.player_1, self.name)
rego.add_to_db()
self.assertRaises(ValueError, self.tournament.confirm_entries)
class TournamentMissionsTests(AppSimulatingTest):
tourn_1 = 'test_missions'
def setUp(self):
super(TournamentMissionsTests, self).setUp()
self.injector.inject(self.tourn_1)
self.tourn = Tournament(self.tourn_1)
self.tourn.update({'rounds': 2})
# pylint: disable=protected-access
def test_add_missions(self):
self.tourn.update({'missions': ['foo', 'bar']})
self.assertRaises(ValueError, self.tourn._set_missions, [])
self.assertRaises(ValueError, self.tourn.update, {'missions': []})
self.assertRaises(ValueError, self.tourn._set_missions, ['1'])
self.assertRaises(ValueError, self.tourn.update, {'missions': ['1']})
self.assertRaises(ValueError, self.tourn._set_missions, ['1', '2', '3'])
self.assertRaises(ValueError, self.tourn.update,
{'missions': ['1', '2', '3']})
def test_get_missions(self):
compare(self.tourn.get_missions(), ['TBA', 'TBA'])
self.tourn.update({'missions': ['foo', 'bar']})
compare(self.tourn.get_missions(), ['foo', 'bar'])
def test_round_change(self):
self.tourn.update({'rounds': 0})
self.tourn.update({'rounds': 1})
compare(self.tourn.get_round(1).get_dao().get_mission(), 'TBA')
def test_get_round(self):
"""Test the round getter"""
name = 'test_get_round'
self.injector.inject(name)
tourn = Tournament(name)
tourn.update({'rounds': 2})
self.assertTrue(tourn.get_round(1).get_dao().ordering == 1)
self.assertTrue(tourn.get_round(2).get_dao().ordering == 2)
self.assertRaises(ValueError, tourn.get_round, 3)
self.assertRaises(ValueError, tourn.get_round, -1)
self.assertRaises(ValueError, tourn.get_round, 'a')
self.assertRaises(ValueError, tourn.get_round, 0)
def test_tournament_round_deletion(self):
"""Check that the rounds get deleted when rounds are reduced"""
name = 'test_tournament_round_deletion'
self.injector.inject(name)
tourn = Tournament(name)
tourn.update({'rounds': 6})
compare(
len(TournamentRound.query.filter_by(tournament_name=name).all()),
6)
tourn.update({'rounds': 2})
compare(
len(TournamentRound.query.filter_by(tournament_name=name).all()),
2)
def test_get_missions(self):
"""get missions for the rounds"""
name = 'test_get_missions'
self.injector.inject(name)
tourn = Tournament(name)
tourn.update({
'rounds': 3,
'missions': ['mission_1', 'mission_2', 'mission_3']
})
tourn.update({'rounds': 4})
compare(tourn.get_round(1).get_dao().mission, 'mission_1')
compare(tourn.get_round(4).get_dao().mission, None)
compare(Tournament(name).get_missions(),
['mission_1', 'mission_2', 'mission_3', 'TBA'])
def setUp(self):
super(EnterScore, self).setUp()
self.injector.inject(self.tourn_1, num_players=5)
tourn = Tournament(self.tourn_1)
tourn.update({
'rounds': 2,
'missions': ['foo_mission_1', 'foo_mission_2']
})
self.injector.add_player(self.tourn_1, self.player)
score_args = cat('per_tournament', 50, True, 0, 100)
# per tournament category
self.cat_1 = ScoreCategory(tournament_id=self.tourn_1, **score_args)
self.db.session.add(self.cat_1)
# per round category
score_args['name'] = 'per_round'
score_args['per_tournament'] = False
self.category_2 = ScoreCategory(tournament_id=self.tourn_1,
**score_args)
self.db.session.add(self.category_2)
self.db.session.commit()
class ScoreCategoryTests(AppSimulatingTest):
tourn_1 = 'test_score_categories'
def setUp(self):
super(ScoreCategoryTests, self).setUp()
self.injector.inject(self.tourn_1)
self.db.session.flush()
self.db.session.commit()
# Some default categories
self.cat_1 = cat('painting', 10, False, 1, 20)
self.cat_2 = cat('cat_battle', 80, True, 1, 20)
self.cat_3 = cat('cat_sports', 10, True, 1, 5)
self.tournament = Tournament(self.tourn_1)
def test_categories_created(self):
# Enter a cat
self.tournament.update({'score_categories': [self.cat_1]})
c_1 = ScoreCategory.query.\
filter_by(name=self.cat_1['name']).first()
compare(c_1.percentage, self.cat_1['percentage'])
compare(c_1.per_tournament, self.cat_1['per_tournament'])
compare(c_1.min_val, self.cat_1['min_val'])
compare(c_1.max_val, self.cat_1['max_val'])
# Enter multiple cats
self.tournament.update({'score_categories': [self.cat_2, self.cat_3]})
c_2 = ScoreCategory.query.\
filter_by(name=self.cat_2['name']).first()
compare(c_2.percentage, self.cat_2['percentage'])
compare(c_2.per_tournament, self.cat_2['per_tournament'])
compare(c_2.min_val, self.cat_2['min_val'])
compare(c_2.max_val, self.cat_2['max_val'])
c_3 = ScoreCategory.query.\
filter_by(name=self.cat_3['name']).first()
compare(c_3.percentage, self.cat_3['percentage'])
compare(c_3.per_tournament, self.cat_3['per_tournament'])
compare(c_3.min_val, self.cat_3['min_val'])
compare(c_3.max_val, self.cat_3['max_val'])
def test_old_categories_deleted(self):
self.tournament.update({'score_categories': [self.cat_1]})
self.tournament.update({'score_categories': [self.cat_2, self.cat_3]})
# Double check cat 1 is deleted.
compare(0, ScoreCategory.query.filter_by(name=self.cat_1['name']).\
count())
# pylint: disable=unused-variable
def test_broken_min_max(self):
neg_min = cat('painting', 10, False, -1, 20)
neg_max = cat('painting', 10, False, 1, -1)
zero_max = cat('painting', 10, False, 0, 0)
min_high = cat('painting', 10, False, 10, 9)
zero_min = cat('painting', 10, False, 0, 20)
equal = cat('painting', 10, False, 1, 1)
no_min = cat('painting', '10', False, '', 20)
no_max = cat('painting', '10', False, 1, '')
none_min = cat('painting', '1', False, None, 1)
none_max = cat('painting', '1', False, 1, None)
char_min = cat('painting', '1', False, 'a', 1)
char_max = cat('painting', '1', False, 1, 'a')
func = self.tournament.update
self.assertRaises(ValueError, func, {'score_categories': [neg_min]})
self.assertRaises(ValueError, func, {'score_categories': [neg_max]})
self.assertRaises(ValueError, func, {'score_categories': [zero_max]})
self.assertRaises(ValueError, func, {'score_categories': [min_high]})
self.assertRaises(ValueError, func, {'score_categories': [no_min]})
self.assertRaises(ValueError, func, {'score_categories': [no_max]})
self.assertRaises(ValueError, func, {'score_categories': [none_min]})
self.assertRaises(ValueError, func, {'score_categories': [none_max]})
self.assertRaises(ValueError, func, {'score_categories': [char_min]})
self.assertRaises(ValueError, func, {'score_categories': [char_max]})
def test_broken_categories(self):
# cat should perform input validation only
fifty_one = cat('painting', 51, False, 1, 20)
neg_pct = cat('painting', -1, False, 1, 20)
zero_pct = cat('painting', 0, False, 1, 20)
lge_pct = cat('painting', 101, False, 1, 20)
char_pct = cat('painting', 'a', False, 1, 20)
no_name = cat('', 10, False, 1, 20)
none_name = cat(None, 10, False, 1, 20)
func = self.tournament.update
self.assertRaises(ValueError, func, {'score_categories': [neg_pct]})
self.assertRaises(ValueError, func, {'score_categories': [zero_pct]})
self.assertRaises(ValueError, func, {'score_categories': [lge_pct]})
self.assertRaises(ValueError, func, {'score_categories': [char_pct]})
self.assertRaises(ValueError, func, {'score_categories': [no_name]})
self.assertRaises(ValueError, func, {'score_categories': [none_name]})
self.assertRaises(ValueError, func,
{'score_categories': [fifty_one, fifty_one]})
