def create_role(self,role_name=None):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
role = self.tables.Role()
role.name = role_name
role.role_id = 1
return role
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
tournaments = self.create_multiple_single_div_tournaments('test_tournament',2)
self.meta_division = self.tables.MetaDivision(
meta_division_name='test_meta_division'
)
self.meta_division.divisions = [tournaments[0].divisions[0],tournaments[1].divisions[0]]
def create_token(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.token = self.tables.Token(
token_id=1,
player_id=1,
division_id=1,
team_id=1,
metadivision_id=1,
paid_for=False,
used=False
)
def create_team(self, team_name=None):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
if team_name is None:
team_name='test_test'
self.team = self.tables.Team(
team_name=team_name,
players=[self.player],
team_id=1
)
if hasattr(self,"division_machine"):
self.division_machine.team = self.team
def setUp(self):
self.app = Flask("dummy")
self.app.secret_key = 'poop'
LoginManager().init_app(self.app)
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.app.tables = self.tables
self.user_with_roles = self.tables.User()
self.role = self.tables.Role()
self.role.name = "new_role"
self.user_with_roles.roles = [self.role]
self.id = Identity('dummy')
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.user_with_roles = self.tables.User(
username='******')
self.role = self.tables.Role()
self.role.name = "new_role"
self.role.role_id = 1
self.user_with_roles.roles = [self.role]
self.user = self.tables.User(username='******')
self.user_with_roles.user_id = 1
self.user.user_id = 2
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.role = self.create_role("new_role")
self.create_single_division_tournament()
self.create_division_machine()
self.player = self.create_player(1)
def create_division_machine(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.machine = self.tables.Machine(
machine_name='test_machine',
abbreviation='AAA'
)
self.division_machine = self.tables.DivisionMachine(
division_machine_id=1,
removed=False,
machine_id=self.machine.machine_id,
division_id=self.division.division_id,
player_id=1,
team_id=1
)
self.division_machine.machine = self.machine
def setUp(self):
self.mock_app = MagicMock()
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.tables.Token.query = MagicMock()
self.tables.Team.query = MagicMock()
self.tables.Division.query = MagicMock()
self.mock_app.tables = self.tables
self.mock_app.tables.db_handle = MagicMock()
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.create_single_division_tournament()
self.create_division_machine()
self.player = self.create_player()
self.create_team()
self.create_token()
self.create_audit_log()
def create_multi_division_tournament(self, tournament_name=None):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
if tournament_name is None:
tournament_name='test_tournament'
self.multi_div_tournament = self.tables.Tournament(
tournament_id=1,
tournament_name=tournament_name,
single_division=False
)
self.multi_div_tournament_division = self.tables.Division(
division_id=1,
division_name='all',
number_of_scores_per_entry=1,
tournament_id=1,
tournament=self.multi_div_tournament,
active=True
)
self.multi_div_tournament.divisions=[self.multi_div_tournament_division]
def create_entry(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.entry = self.tables.Entry(
entry_id=1,
player_id=1,
division_id=1
)
self.score = self.tables.Score(
score_id=1,
score=12345,
entry_id=1,
division_machine_id=1
)
if hasattr(self,'division_machine'):
self.score.division_machine=self.division_machine
self.entry.scores=[self.score]
def create_db_and_tables(app, db_name, db_info, drop_tables=False):
db_url = generate_db_url(db_name, db_info)
if not database_exists(db_url):
create_database(db_url)
db_handle = create_db_handle(db_url, app)
if db_info.db_type == 'postgres':
check_if_ranking_funcs_exists(db_handle)
app.tables = ImportedTables(db_handle)
create_TD_tables(db_handle, drop_tables=drop_tables)
db_handle.engine.dispose()
class UtilAuthTD(unittest.TestCase):
def setUp(self):
self.app = Flask("dummy")
self.app.secret_key = 'poop'
LoginManager().init_app(self.app)
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.app.tables = self.tables
self.user_with_roles = self.tables.User()
self.role = self.tables.Role()
self.role.name = "new_role"
self.user_with_roles.roles = [self.role]
self.id = Identity('dummy')
def test_on_identity_loaded_callback(self):
with self.app.test_client() as c:
with self.app.test_request_context('/') as req_c:
login_user(self.user_with_roles)
self.assertIsNone(getattr(self.id, 'user', None))
on_identity_loaded_callback = auth.generate_identity_loaded(
self.app)
self.assertEqual(len(self.id.provides), 0)
on_identity_loaded_callback(None, self.id)
self.assertEqual(len(self.id.provides), 2)
def test_generate_user_loader(self):
self.app.tables = MagicMock()
self.app.tables.User.query.get.return_value = self.user_with_roles
self.app.td_config = {'PLAYER_LOGIN': 0}
with self.app.test_client() as c:
with self.app.test_request_context('/') as req_c:
user_loader = auth.generate_user_loader(self.app)
returned_user = user_loader(1)
self.assertEquals(returned_user, self.user_with_roles)
self.app.td_config = {'PLAYER_LOGIN': 1}
with self.app.test_client() as c:
with self.app.test_request_context('/') as req_c:
user_loader = auth.generate_user_loader(self.app)
returned_user = user_loader(1)
self.assertEquals(returned_user, self.user_with_roles)
class ModelMachineTD(unittest.TestCase):
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.machine = self.tables.Machine(machine_name='test_machine')
def test_to_dict_simple(self):
simple_dict = self.machine.to_dict_simple()
for value in self.machine.__table__.columns:
key = str(value)[str(value).index('.') + 1:]
self.assertTrue(key in simple_dict, "did not find %s" % key)
def create_queue(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.child_queue = self.tables.Queue(
queue_id=1,
bumped=False,
division_machine_id=1,
parent_id=1,
queue_child=[],
division_machine=self.division_machine
)
self.queue = self.tables.Queue(
queue_id=2,
bumped=False,
division_machine_id=1,
queue_child=[self.child_queue],
division_machine=self.division_machine
)
if hasattr(self,'division_machine'):
self.division_machine.queue = self.queue
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.create_single_division_tournament()
self.create_division_machine()
self.player = self.create_player(1)
self.player_two = self.create_player(2)
self.create_team()
self.create_queue()
self.queue.player_id = 1
self.queue.player = self.player
self.child_queue.player_id = 1
self.child_queue.player = self.player
class ModelUserTD(unittest.TestCase):
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.user_with_roles = self.tables.User(
username='******')
self.role = self.tables.Role()
self.role.name = "new_role"
self.role.role_id = 1
self.user_with_roles.roles = [self.role]
self.user = self.tables.User(username='******')
self.user_with_roles.user_id = 1
self.user.user_id = 2
def test_crypt_password(self):
password = self.user.crypt_password('password_test')
self.assertTrue(password != "password_test")
self.user.password = self.user.crypt_password('password_test')
self.assertTrue(self.user.verify_password('password_test'))
self.assertFalse(self.user.verify_password('password_not_test'))
def test_user_auth(self):
self.assertTrue(self.user.is_authenticated())
self.assertTrue(self.user.is_active())
self.assertFalse(self.user.is_anonymous())
def test_to_dict_simple(self):
self.user.password = self.user.crypt_password('password_two')
simple_dict_with_roles = self.user_with_roles.to_dict_simple()
for value in self.user.__table__.columns:
key = str(value)[str(value).index('.') + 1:]
if key != 'password_crypt':
self.assertTrue(key in simple_dict_with_roles,
"oops - did not find %s" % key)
self.assertTrue('password_crypt' not in simple_dict_with_roles)
self.assertTrue('roles' in simple_dict_with_roles)
self.assertEquals(len(simple_dict_with_roles['roles']), 1)
simple_dict_no_roles = self.user.to_dict_simple()
self.assertTrue('roles' not in simple_dict_no_roles)
def create_audit_log(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.create_division_machine()
self.audit_log = self.tables.AuditLog(
audit_log_id=1,
player_id=1,
entry_id=1,
token_id=1,
division_machine_id=1,
deskworker_id=1,
scorekeeper_id=1,
purchase_date=1,
game_started_date=None,
used_date=None,
voided_date=None,
voided=False,
used=False,
remaining_tokens="",
description="",
action=""
)
self.audit_log.division_machine=self.division_machine
self.audit_log.token=self.token
def get_admin_app(name):
#FIXME : this actually gets ALL config values, not just db values
db_config = td_config.get_db_config()
#secret_config,public_config = td_config.get_configs()
db_info = DbInfo(db_config)
db_url = db_util.generate_db_url(name, db_info)
if not database_exists(db_url):
return None
app = get_generic_app(name)
db_handle = db_util.create_db_handle(db_url, app)
app.tables = ImportedTables(db_handle)
app.register_blueprint(admin_login_blueprint)
app.register_blueprint(admin_manage_blueprint)
LoginManager().init_app(app)
auth.generate_user_loader(app)
auth.generate_identity_loaded(app)
for code in default_exceptions.iterkeys():
app.error_handler_spec[None][code] = make_json_error
return app
class ModelDivisionMachineTD(TdUnitTestBase):
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
tournaments = self.create_multiple_single_div_tournaments('test_tournament',2)
self.meta_division = self.tables.MetaDivision(
meta_division_name='test_meta_division'
)
self.meta_division.divisions = [tournaments[0].divisions[0],tournaments[1].divisions[0]]
def test_to_dict_simple(self):
returned_meta_division_dict = self.meta_division.to_dict_simple()
for value in self.meta_division.__table__.columns:
key = str(value)[str(value).index('.')+1:]
self.assertTrue(key in returned_meta_division_dict,"did not find %s"%key)
self.assertEquals(returned_meta_division_dict['divisions'][0]['division_id'],0)
self.assertEquals(returned_meta_division_dict['divisions'][1]['division_id'],1)
def __init__(self,*args, **kwargs):
super(TdUnitTestBase, self).__init__(*args, **kwargs)
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.create_single_division_tournament()
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.role = self.create_role('new_role')
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.division_final = self.create_division_final(
use_division_final_players=True)
self.simple_dict = self.division_final.to_dict_simple()
class TdUnitTestBase(unittest.TestCase):
def __init__(self,*args, **kwargs):
super(TdUnitTestBase, self).__init__(*args, **kwargs)
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
def create_division_final_players(self,num_final_players=2):
players=[]
division_final_players = []
for num in range(1,num_final_players+1):
players.append(self.create_player(player_id=num))
division_final_players.append(self.tables.DivisionFinalPlayer(
final_player_id=num,
division_final_id=1,
player_id=num,
adjusted_seed=num,
initial_seed=num,
overall_rank=num
))
division_final_players[num-1].player=players[num-1]
return division_final_players
def create_division_final(self,use_division_final_players=True):
tournament = self.create_single_division_tournament()
division_final = self.tables.DivisionFinal(
division_final_id=1,
division_id=1,
)
division_final.division=tournament.divisions[0]
if use_division_final_players:
division_final.qualifiers=self.create_division_final_players()
return division_final
def create_entry(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.entry = self.tables.Entry(
entry_id=1,
player_id=1,
division_id=1
)
self.score = self.tables.Score(
score_id=1,
score=12345,
entry_id=1,
division_machine_id=1
)
if hasattr(self,'division_machine'):
self.score.division_machine=self.division_machine
self.entry.scores=[self.score]
def create_queue(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.child_queue = self.tables.Queue(
queue_id=1,
bumped=False,
division_machine_id=1,
parent_id=1,
queue_child=[],
division_machine=self.division_machine
)
self.queue = self.tables.Queue(
queue_id=2,
bumped=False,
division_machine_id=1,
queue_child=[self.child_queue],
division_machine=self.division_machine
)
if hasattr(self,'division_machine'):
self.division_machine.queue = self.queue
def create_division_machine(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.machine = self.tables.Machine(
machine_name='test_machine',
abbreviation='AAA'
)
self.division_machine = self.tables.DivisionMachine(
division_machine_id=1,
removed=False,
machine_id=self.machine.machine_id,
division_id=self.division.division_id,
player_id=1,
team_id=1
)
self.division_machine.machine = self.machine
def create_player(self,player_id=1):
player = self.tables.Player(
player_id=player_id,
first_name="test",
last_name="player %s" % player_id
)
if hasattr(self,"division_machine"):
player.division_machine=self.division_machine
self.division_machine.player = player
if hasattr(self,"role"):
player.roles=[self.role]
if hasattr(self,"division"):
player.linked_division_id=self.division.division_id
player.linked_division=self.division
return player
def create_role(self,role_name=None):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
role = self.tables.Role()
role.name = role_name
role.role_id = 1
return role
def create_team(self, team_name=None):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
if team_name is None:
team_name='test_test'
self.team = self.tables.Team(
team_name=team_name,
players=[self.player],
team_id=1
)
if hasattr(self,"division_machine"):
self.division_machine.team = self.team
def create_audit_log(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.create_division_machine()
self.audit_log = self.tables.AuditLog(
audit_log_id=1,
player_id=1,
entry_id=1,
token_id=1,
division_machine_id=1,
deskworker_id=1,
scorekeeper_id=1,
purchase_date=1,
game_started_date=None,
used_date=None,
voided_date=None,
voided=False,
used=False,
remaining_tokens="",
description="",
action=""
)
self.audit_log.division_machine=self.division_machine
self.audit_log.token=self.token
def create_token(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.token = self.tables.Token(
token_id=1,
player_id=1,
division_id=1,
team_id=1,
metadivision_id=1,
paid_for=False,
used=False
)
def create_multiple_single_div_tournaments(self,tournament_name,num):
tournaments=[]
for i in range(num):
tournament = self.tables.Tournament(
tournament_id=1,
tournament_name='%s%s' % (tournament_name,num),
single_division=True
)
division = self.tables.Division(
division_id=i,
division_name='all %s' % num,
number_of_scores_per_entry=1,
tournament_id=1,
tournament=tournament,
active=True
)
tournament.divisions=[division]
tournaments.append(tournament)
return tournaments
def create_single_division_tournament(self, tournament_name=None):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
if tournament_name is None:
tournament_name='test_tournament'
self.tournament = self.tables.Tournament(
tournament_id=1,
tournament_name=tournament_name,
single_division=True
)
self.division = self.tables.Division(
division_id=1,
division_name='all',
number_of_scores_per_entry=1,
tournament_id=1,
tournament=self.tournament,
active=True
)
self.tournament.divisions=[self.division]
return self.tournament
def create_multi_division_tournament(self, tournament_name=None):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
if tournament_name is None:
tournament_name='test_tournament'
self.multi_div_tournament = self.tables.Tournament(
tournament_id=1,
tournament_name=tournament_name,
single_division=False
)
self.multi_div_tournament_division = self.tables.Division(
division_id=1,
division_name='all',
number_of_scores_per_entry=1,
tournament_id=1,
tournament=self.multi_div_tournament,
active=True
)
self.multi_div_tournament.divisions=[self.multi_div_tournament_division]
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
self.machine = self.tables.Machine(machine_name='test_machine')
def setUp(self):
self.db_handle = db_util.create_db_handle_no_app()
self.tables = ImportedTables(self.db_handle)
