def test_registerPlayer(self):
"""
Test backend.registerPlayer
"""
vbar()
print("test backend.registerPlayer")
vbar()
# initiate a backend
backend = self.setUp()
# register reference players
vprint("Initiate a backend and register reference players:")
for pp in refPlayers(True):
result = backend.registerPlayer(pp['nickname'], pp['passwordHash'])
self.assertEqual(result['status'], "ok")
vprint(" - register " + pp['nickname'] + ": " + str(result['playerID']))
pp_db = getPlayersColl().find_one({'nickname': pp['nickname']})
self.assertEqual(result['playerID'], str(pp_db['_id']))
# re-register the same players => should fail
vprint("Re-register the same players: it should fail")
for pp in refPlayers(True):
result = backend.registerPlayer(pp['nickname'], pp['passwordHash'])
vprint(" - register " + pp['nickname'] + ": " + result['status'] +
" - " + result['reason'])
self.assertEqual(result['status'], "ko")
self.assertEqual(result['reason'], "invalid nickname")
def test_getPlayerLoginDetail(self):
"""
Test backend.getPlayerLoginDetail
"""
vbar()
print("test backend.getPlayerLoginDetail")
vbar()
# initiate a backend
backend = self.setUp()
# There is no player registered yet: test that it is impossible to
# retrieve the players' details.
vprint("Initiate a backend with no players registered: check that we cant retrieve")
vprint("the players' details:")
for pp in refPlayers(True):
# try to retrieve the player's details
answer = backend.getPlayerLoginDetails(pp['nickname'])
self.assertEqual(answer['status'], "ko")
self.assertEqual(answer['reason'], "unknown nickname")
vprint(" > " + pp['nickname'] + ": unknown nickname")
# register the reference players and then retrieve their details
vprint("Register the reference test players, and retrieve their details:")
backend.ForTestOnly_RegisterRefPlayers()
for pp in refPlayers(True):
# try to retrieve the player's details
answer = backend.getPlayerLoginDetails(pp['nickname'])
self.assertEqual(answer['status'], "ok")
self.assertEqual(answer['playerID'], str(pp['playerID']))
self.assertEqual(answer['nickname'], str(pp['nickname']))
self.assertEqual(answer['passwordHash'], str(pp['passwordHash']))
vprint(" > " + pp['nickname'] + ": player is recognized and compliant")
def gameSetup(test_data_index):
"""
Initialize a game from test data: the 'test_data_index' (0 or 1) points
at the data set to be used from 'test_utilities' for:
- players
- cardset
We then use the reference 'set proposal history' (in 'test_utilities' in
order to go through the game and compare the progress against reference
data available from 'refSteps'.
"""
# Connection to the MongoDB server
# read the players, register them and initiate a game.
players = refPlayers(True)
temp_players = Players()
for pp in players:
temp_players.register(pp['nickname'], pp['passwordHash'])
partie = Game(players)
# overwrite the gameID with the reference test data
partie.gameID = ObjectId(refGameHeader_start()[test_data_index]['gameID'])
# Overwrite the cardset with reference test data
cards_dict = refGames_Dict()[test_data_index]['cardset']
partie.cards.deserialize(cards_dict)
# Force 'Steps' to take into account this new cardset.
partie.steps[0].start(partie.cards)
# The game is ready to start.
return partie
def test_delistPlayer(self):
"""
Test game.getPoints
"""
vbar()
print("Test game.delistPlayer")
vbar()
# load the reference data
Donald = refPlayers()[0]
for test_data_index in range(0, 2):
# load the reference game
partie = self.setup(test_data_index)
vprint("We load the reference game " + str(test_data_index) +
": Donald is enlisted")
# delist Donad and check the result
answer = partie.delistPlayer(Donald['playerID'])
self.assertEqual(answer['status'], "ok")
vprint(" > we delist Donald")
for pp in partie.players:
self.assertFalse(pp['playerID'] == Donald['playerID'])
vprint(" > Donald is not in the players' list anymore")
# we try delisting an unknown player
answer = partie.delistPlayer(ObjectId())
self.assertEqual(answer['status'], "ko")
vprint(" > we delist an unkown player: it fails")
def setUp(self, gameIDNone=True):
# Connection to the MongoDB server / players collection
playersColl = getPlayersColl()
# populate db with test data about players
playersColl.drop()
for pp in refPlayers():
if gameIDNone:
playersColl.insert_one({
'_id': pp['playerID'],
'nickname': pp['nickname'],
#'password': pp['password'],
'passwordHash': pp['passwordHash'],
'totalScore': pp['totalScore'],
'gameID': None
})
else:
playersColl.insert_one({
'_id': pp['playerID'],
'nickname': pp['nickname'],
#'password': pp['password'],
'passwordHash': pp['passwordHash'],
'totalScore': pp['totalScore'],
'gameID': pp['gameID']
})
return playersColl
def test_delistPlayer(self):
"""
Test backend.delistPlayer
"""
vbar()
print("test backend.delistPlayer")
vbar()
# initiate a backend and register reference players
backend = self.setUp()
vprint("We register the reference test players:")
backend.ForTestOnly_RegisterRefPlayers()
pp_test = refPlayers(True)
# enlist a team of 5 players: it should succeed
list_pid = [{'playerID': pp_test[0]['playerID']},
{'playerID': pp_test[1]['playerID']},
{'playerID': pp_test[2]['playerID']},
{'playerID': pp_test[3]['playerID']},
{'playerID': pp_test[4]['playerID']}]
result = backend.enlistTeam(list_pid)
vprint("Enlist 5 players: " + str(result['status'])
+ " (" + str(result['gameID']) + ")")
# delist all players one after the other
playersColl = getPlayersColl()
vprint("Now, we delist the players one after the other:")
for pp in pp_test:
backend.delistPlayer(pp['playerID'])
# check that the player is still registered in the database
result = playersColl.find_one({'_id': pp['playerID']})
self.assertEqual(pp['playerID'], result['_id'])
self.assertEqual(pp['nickname'], result['nickname'])
# check that the player is not anymore listed in the game
result = backend.games[0].getPlayer(pp['playerID'])
self.assertEqual(result['status'], "ko")
vprint(" > " + pp['nickname'] + ": was delisted but is still registered")
def test_isPlayerIDValid(self):
"""
Test shared.isPlayerIDValid
"""
# setup the test data
players = self.setUp()
vbar()
print("Test shared.isPlayerIDValid")
vbar()
vprint("We test the validity of several playerIDs and compare the result with")
vprint("the reference test data:")
# test with the valid IDs in the DB
for pp in refPlayers():
playerID_ref = pp['playerID']
# test if the 'reference' playerID are recognized
result = isPlayerIDValid(playerID_ref)
vprint(" " + pp['nickname'] + ": playerID = " + str(playerID_ref)
+ " is considered valid : " + str(result))
self.assertTrue(result)
# now test with wrong IDs
invalid_IDs = [
{'playerID': '57b9a303124e9b13e6759bda'}, {'playerID': '57b9a003124e9b13e6751bdb'},
{'playerID': '57b9a003124e9b13e6757bdc'}, {'playerID': '57b9fffb124e9b2e056a765c'},
{'playerID': '57b9bffb124e9b2eb56a765d'}, {'playerID': '5748529a124e9b6187cf6c2a'} ]
for pID in invalid_IDs:
result = isPlayerIDValid(pID['playerID'])
vprint(" playerID " + str(pID['playerID']) +
" is considered invalid : " + str(result))
self.assertFalse(result)
# end of the test
self.teardown(players)
def test_oidIsValid(self):
"""
This method will test that the reference playerID and gameID are
recognized as valid ObjectIds, and that other strings are not.
"""
vbar()
print("Test constants.oidIsValid")
vbar()
# check that playerIDs are tested ok (in both formats)
vprint(
"We check that playerIDs for all reference test players are recognized:"
)
for pp in refPlayers():
self.assertTrue(oidIsValid(pp['playerID']))
vprint(" > " + pp['nickname'] + "'s playerID is recognized ok.")
for pp in refPlayers_Dict():
self.assertTrue(oidIsValid(pp['playerID']))
vprint(" > " + pp['nickname'] +
"'s stringified playerID is recognized ok.")
vprint("We check that the reference game's GameID are recognized:")
for i in range(0, 2):
gameID = refGames_Dict()[i]['gameID']
self.assertTrue(oidIsValid(gameID))
vprint(" > game " + str(i) +
" stringified gameID is recognized ok.")
# We now test that random strings are not recognized as valid ObjectIds.
vprint("We test that 'false' ObjectIds are not recognized:")
wrong_list = ["REzcozienz34", "d*zdojEZFFE", "#`{#]^rdgrgre"]
for pp in wrong_list:
self.assertFalse(oidIsValid(pp))
vprint(" > " + pp + " is not recognized")
def test_getPlayerID(self):
"""
Test players.getPlayerID
"""
# setup the test data
self.setUp()
players = Players()
vbar()
print("Test players.getPlayerID")
vbar()
vprint(
"We collect the playerID of the players in the DB and compare with"
)
vprint("the reference test data:")
# test valid players
for pp in refPlayers():
playerID_ref = pp['playerID']
result = players.getPlayerID(pp['nickname'])
valid = (result['status'] == "ok") and (result['playerID']
== playerID_ref)
vprint(" " + pp['nickname'] + ": result = " + str(result))
self.assertTrue(valid)
# test invalid players
nickname = "inexistantplayer"
result = players.getPlayerID(nickname)
valid = (result['status'] == "ko") and (result['reason']
== "unknown nickname")
vprint(" " + nickname + ": result = " + str(result))
self.assertTrue(valid)
# end of the test
self.teardown(players)
def test_getPlayers(self):
"""
Test players.getPlayers
"""
# setup the test data
self.setUp()
players = Players()
vbar()
print("Test players.getPlayers")
vbar()
vprint(
"We collect the players from the DB structure, and compare with the"
)
vprint("reference test data:")
test_players = players.getPlayers()
ref_players = refPlayers(True)
# check that there are the same number of players on DB and reference
lref = len(ref_players)
ltest = len(test_players)
result = (lref == ltest)
vprint(" - there are " + str(ltest) + " players in the DB: " +
str(result))
self.assertTrue(result)
# check that the DB is the same as the reference
for pp_ref in ref_players:
result = (pp_ref in test_players)
vprint(" " + pp_ref['nickname'] + ": " + str(result))
self.assertTrue(result)
# end of the test
self.teardown(players)
def test_getHash(self):
"""
Test players.getHash
"""
# setup the test data
self.setUp()
players = Players()
vbar()
print("Test players.getHash")
vbar()
vprint("We collect the hash of the players in the DB and compare with")
vprint("the reference test data:")
# test valid players
for pp in refPlayers():
playerID = pp['playerID']
hash_ref = pp['passwordHash']
result = players.getHash(playerID)
valid = (result['status'] == "ok") and (result['passwordHash']
== hash_ref)
vprint(" " + pp['nickname'] + ": result = " + str(result))
self.assertTrue(valid)
# test unknown player
result = players.getHash(ObjectId())
valid = (result['status'] == "ko") and (result['reason']
== "unknown playerID")
vprint(" Unknown player: result = " + str(result))
self.assertTrue(valid)
# test invalid playerID
result = players.getHash("invalid")
valid = (result['status'] == "ko") and (result['reason']
== "invalid playerID")
vprint(" Invalid playerID: result = " + str(result))
self.assertTrue(valid)
# end of the test
self.teardown(players)
def test_getHistory(self):
"""
Test backend.getHistory
"""
vbar()
print("Test backend.getHistory")
vbar()
# initialize test data, launch a game with 5 players
backend = self.setUp()
vprint("We register the reference test players:")
backend.ForTestOnly_RegisterRefPlayers()
pp_test = refPlayers(True)
list_pid = [{'playerID': pp_test[0]['playerID']},
{'playerID': pp_test[1]['playerID']},
{'playerID': pp_test[2]['playerID']},
{'playerID': pp_test[3]['playerID']},
{'playerID': pp_test[4]['playerID']}]
result = backend.enlistTeam(list_pid)
gID = result['gameID']
# identify the right game and overwrite it with a reference game
# (cardset 0, refGame 0, finished, 25 turns)
vprint("We load the reference game 0 (full and finished).")
for j in range(0, len(backend.games)):
if str(backend.games[j].getGameID()) == str(gID):
i = j
break
backend.games[i].deserialize(refGames_Dict()[0])
# First we collect the history of the full game
vprint("We ask for the full history:")
result = backend.getHistory(ObjectId('57b9bec5124e9b2d2503b72b'))
status = result['status']
vprint(" - status: " + status)
valid = gameRef_compliant(backend.games[i], 0, " ")
vprint(" - game compliant: " + str(valid))
def test_isNicknameAvailable(self):
"""
Test players.isNicknameAvailable
"""
# test that the new player is actually added both in memory and in DB
vbar()
print("Test players.isNicknameAvailable")
vbar()
vprint(
"We register players and check that their nickname are not available anymore."
)
# empty the database
playersColl = getPlayersColl()
playersColl.drop()
# setup the test data
players = Players()
for pp in refPlayers():
# test that the nickname is available
vprint(" > " + pp['nickname'] + ":")
answer = players.isNicknameAvailable(pp['nickname'])
self.assertEqual(answer['status'], "ok")
vprint(" * nickname is available")
# register the player and test that the nickname is not available anymore.
players.register(pp['nickname'], pp['passwordHash'])
vprint(" * register " + pp['nickname'])
answer = players.isNicknameAvailable(pp['nickname'])
self.assertEqual(answer['status'], "ko")
vprint(" * nickname is not available anymore")
def test_enlist(self):
"""
Test players.enlist
"""
# setup the test data
self.setUp()
players = Players()
ref_players = []
for pp in refPlayers():
ref_players.append(player_format_DB(pp))
gameID1 = ref_players[0]['gameID']
gameID2 = ref_players[2]['gameID']
print("Bogus: ", ref_players[0])
print("Bogus: ", ref_players[2])
# modifies few gameID values
vbar()
print("Test players.enlist")
vbar()
vprint("Test registering several players on two games:")
vprint(" - Riri, Fifi and Loulou are part of a first game.")
vprint(" - Daisy and Donald are part of another game.")
vprint(" - Mickey does not play a game.")
vprint(" Here are the players:")
playerID = players.getPlayerID("Daisy")['playerID']
result = players.enlist(playerID, gameID1)
self.assertEqual(result['status'], "ok")
playerID = players.getPlayerID("Donald")['playerID']
result = players.enlist(playerID, gameID1)
self.assertEqual(result['status'], "ok")
playerID = players.getPlayerID("Riri")['playerID']
result = players.enlist(playerID, gameID2)
self.assertEqual(result['status'], "ok")
playerID = players.getPlayerID("Fifi")['playerID']
result = players.enlist(playerID, gameID2)
self.assertEqual(result['status'], "ok")
playerID = players.getPlayerID("Loulou")['playerID']
result = players.enlist(playerID, gameID2)
self.assertEqual(result['status'], "ok")
# self.list_test_players(players.playersColl)
pp = []
for p in players.playersColl.find({'gameID': gameID1}):
pp.append(p)
result = (ref_players[0] in pp) and (ref_players[5] in pp) and (len(pp)
== 2)
self.assertTrue(result)
pp = []
for p in players.playersColl.find({'gameID': gameID2}):
pp.append(p)
result = (ref_players[2] in pp) and (ref_players[3] in pp) and (
ref_players[4] in pp) and (len(pp) == 3)
self.assertTrue(result)
for pp in players.playersColl.find({}):
vprint(" " + pp['nickname'] + " - gameID: " +
str(pp['gameID']))
# end of the test
self.teardown(players)
def test_enlistTeam(self):
"""
Test backend.enlistTeam
"""
vbar()
print("test backend.enlistTeam")
vbar()
# initiate a backend and register reference players
backend = self.setUp()
vprint("We register the reference test players:")
backend.ForTestOnly_RegisterRefPlayers()
pp_test = refPlayers(True)
# enlist a team of 3 players: it should fail
list_pid = [{'playerID': pp_test[0]['playerID']},
{'playerID': pp_test[1]['playerID']},
{'playerID': pp_test[2]['playerID']}]
result = backend.enlistTeam(list_pid)
vprint("Enlist 3 valid players: " + str(result['status']))
self.assertEqual(result['status'], "ko")
# enlist a team of 5 players out of which 2 are duplicates: it should fail
list_pid = [{'playerID': pp_test[0]['playerID']},
{'playerID': pp_test[1]['playerID']},
{'playerID': pp_test[2]['playerID']},
{'playerID': pp_test[1]['playerID']},
{'playerID': pp_test[0]['playerID']}]
result = backend.enlistTeam(list_pid)
vprint("Enlist 5 players (with 2 duplicates): " + str(result['status']))
self.assertEqual(result['status'], "ko")
# enlist a team of 7 players out of which 2 unknown and 2 duplicate: it should fail
list_pid.append({'playerID': str(ObjectId())})
list_pid.append({'playerID': str(ObjectId())})
result = backend.enlistTeam(list_pid)
vprint("Enlist 3 valid + 2 unknown + 2 duplicate players: " + str(result['status']))
self.assertEqual(result['status'], "ko")
# enlist a team of 6 players (in which 1 duplicate): it should succeed
list_pid = [{'playerID': pp_test[0]['playerID']},
{'playerID': pp_test[1]['playerID']},
{'playerID': pp_test[2]['playerID']},
{'playerID': pp_test[3]['playerID']},
{'playerID': pp_test[2]['playerID']},
{'playerID': pp_test[4]['playerID']}]
result = backend.enlistTeam(list_pid)
vprint("Enlist 6 players (including 1 duplicate): " + str(result['status'])
+ " (" + str(result['gameID']) + ")")
self.assertEqual(result['status'], "ok")
gid_db = backend.players.getGameID(ObjectId(list_pid[0]['playerID']))['gameID']
self.assertEqual(result['gameID'], gid_db)
# enlist another team of 4 players, out of which 3 are already playing
# it should fail
list_pid = [{'playerID': pp_test[0]['playerID']},
{'playerID': pp_test[2]['playerID']},
{'playerID': pp_test[3]['playerID']},
{'playerID': pp_test[5]['playerID']}]
result = backend.enlistTeam(list_pid)
vprint("Enlist 4 valid, only 1 available: " + str(result['status']))
self.assertEqual(result['status'], "ko")
def ForTestOnly_EnlistRefPlayers(self):
"""
FOR TEST PURPOSE ONLY.
This method enlist 6 reference test players. It assumes that these
reference players were already registered.
"""
# enlist a team of 6 players (in which 1 duplicate): it should succeed
list_pid = []
for pp in refPlayers(True):
list_pid.append({'playerID': pp['playerID']})
result = self.enlistTeam(list_pid)
return result
def test_getPlayer(self):
"""
Test players.getPlayer
"""
# setup the test data
self.setUp()
players = Players()
vbar()
print("Test players.getPlayer")
vbar()
vprint(
"We collect several players from the DB structure, and compare with the"
)
vprint("reference test data:")
# collect Donald and Daisy and check results
ref_players = refPlayers(True)
idDonald = players.getPlayerID("Donald")['playerID']
print("BOGUS: ", idDonald)
test_player = players.getPlayer(idDonald)
vprint(" Donald: " + str(test_player))
self.assertEqual(test_player['status'], "ok")
self.assertEqual(test_player['playerID'], ref_players[0]['playerID'])
self.assertEqual(test_player['nickname'], ref_players[0]['nickname'])
self.assertEqual(test_player['passwordHash'],
ref_players[0]['passwordHash'])
self.assertEqual(test_player['totalScore'],
ref_players[0]['totalScore'])
self.assertEqual(test_player['gameID'], ref_players[0]['gameID'])
idDaisy = players.getPlayerID("Daisy")['playerID']
test_player = players.getPlayer(idDaisy)
vprint(" Daisy: " + str(test_player))
self.assertEqual(test_player['status'], "ok")
self.assertEqual(test_player['playerID'], ref_players[5]['playerID'])
self.assertEqual(test_player['nickname'], ref_players[5]['nickname'])
self.assertEqual(test_player['passwordHash'],
ref_players[5]['passwordHash'])
self.assertEqual(test_player['totalScore'],
ref_players[5]['totalScore'])
self.assertEqual(test_player['gameID'], ref_players[5]['gameID'])
# try to get invalid and unknown playerIDs
idUnknown = ObjectId()
test_player = players.getPlayer(idUnknown)
vprint(" Unkown playerID: " + str(test_player))
self.assertEqual(test_player['status'], "ko")
self.assertEqual(test_player['reason'], "unknown playerID")
idInvalid = "invalid"
test_player = players.getPlayer(idInvalid)
vprint(" Invalid playerID: " + str(test_player))
self.assertEqual(test_player['status'], "ko")
self.assertEqual(test_player['reason'], "invalid playerID")
def test_checkPassword(self):
vbar()
print("Test shared_crypto.checkPassword")
vbar()
vprint("We check that all reference test player's (password + hash) is ok")
for pp in refPlayers_Dict():
self.assertTrue(checkPassword(pp['password'], pp['passwordHash']))
vprint(" > " + pp['nickname'] + ": couple (password + hash) is ok")
vprint("We now check that other couples are not ok:")
for pp in refPlayers_Dict():
for yy in refPlayers():
if pp['nickname'] != yy['nickname']:
self.assertFalse(checkPassword(pp['password'], yy['passwordHash']))
vprint(" > " + pp['nickname']+ "'s password and " + yy['nickname'] + "'s hash do not correspond")
def test_delistPlayer(self):
"""
Test players.delistPlayer
"""
# setup the test data
self.setUp()
players = Players()
ref_players = []
for pp in refPlayers():
ref_players.append(player_format_DB(pp))
gameID1 = ref_players[0]['gameID']
gameID2 = ref_players[2]['gameID']
players.enlist(players.getPlayerID("Daisy")['playerID'], gameID1)
players.enlist(players.getPlayerID("Donald")['playerID'], gameID1)
players.enlist(players.getPlayerID("Riri")['playerID'], gameID2)
players.enlist(players.getPlayerID("Fifi")['playerID'], gameID2)
players.enlist(players.getPlayerID("Loulou")['playerID'], gameID2)
donald = players.playersColl.find_one({'nickname': "Donald"})
riri = players.playersColl.find_one({'nickname': "Riri"})
fifi = players.playersColl.find_one({'nickname': "Fifi"})
loulou = players.playersColl.find_one({'nickname': "Loulou"})
daisy = players.playersColl.find_one({'nickname': "Daisy"})
# will deregister few players
vbar()
print("Test players.delistPlayer")
vbar()
vprint("Test registering several players on two games:")
vprint(" - Riri, Fifi and Loulou are part of a first game.")
vprint(" - Daisy and Donald are part of another game.")
vprint(" - Mickey does not play a game.")
vprint(" Here are the players after we deregister them:")
DonaldID = players.getPlayerID("Donald")['playerID']
players.delist(DonaldID)
DaisyID = players.getPlayerID("Daisy")['playerID']
players.delist(DaisyID)
donald_gid = players.getGameID(donald['_id'])['gameID']
daisy_gid = players.getGameID(daisy['_id'])['gameID']
self.assertTrue(donald_gid == daisy_gid == None)
players.delist(players.getPlayerID("Riri")['playerID'])
players.delist(players.getPlayerID("Fifi")['playerID'])
players.delist(players.getPlayerID("Loulou")['playerID'])
riri_gid = players.getGameID(riri['_id'])['gameID']
fifi_gid = players.getGameID(fifi['_id'])['gameID']
loulou_gid = players.getGameID(loulou['_id'])['gameID']
self.assertTrue(riri_gid == fifi_gid == loulou_gid == None)
for pp in players.playersColl.find({}):
vprint(" " + pp['nickname'] + " - gameID: " +
str(pp['gameID']))
# end of the test
self.teardown(players)
def test_getNicknames(self):
"""
Test backend.getNicknames
"""
vbar()
print("test backend.getNicknames")
vbar()
# initiate a backend and register reference players
backend = self.setUp()
vprint("We register the reference test players:")
backend.ForTestOnly_RegisterRefPlayers()
pp_test = refPlayers(True)
list_nicknames_ref = []
for pp in pp_test:
list_nicknames_ref.append(pp['nickname'])
list_nicknames_ref.remove('Daisy')
# enlist a team of 5 players
list_pid = [{'playerID': pp_test[0]['playerID']},
{'playerID': pp_test[1]['playerID']},
{'playerID': pp_test[2]['playerID']},
{'playerID': pp_test[3]['playerID']},
{'playerID': pp_test[4]['playerID']}]
result = backend.enlistTeam(list_pid)
vprint("Enlist a team of 5 player: " + str(result['status'])
+ " (" + str(result['gameID']) + ")")
# ask for the nicknames of the players
ppID = pp_test[0]['playerID']
result = backend.getNicknames(ppID)
# build the test list of nicknames
vprint("Ask for the nickname of Donald's team:")
list_nicknames_test = []
for pp in result:
list_nicknames_test.append(pp['nickname'])
vprint(" Collect the nicknames (" + str(len(list_nicknames_test)) + "):")
for nn in list_nicknames_test:
vprint(" - " + nn)
valid = (list_nicknames_test == list_nicknames_ref)
# all nicknames should appear in the list
vprint(" All names are returned: " + str(valid))
self.assertTrue(valid)
# Do the same request with Daisy who is not enlisted
vprint("Ask for the nickname of Daisy's team:")
pid_str = pp_test[5]['playerID']
result = backend.getNicknames(pid_str)
empty = (result == [])
vprint(" Collect the nicknames (0): " + str(empty))
self.assertTrue(empty)
def test_getGameID(self):
"""
Test backend.getGameID
"""
vbar()
print("test backend.getGameID")
vbar()
# initiate a backend and register reference players
backend = self.setUp()
vprint("We register the reference test players:")
backend.ForTestOnly_RegisterRefPlayers()
pp_test = refPlayers(True)
playersColl = getPlayersColl()
# enlist a team of 6 players (in which 1 duplicate): it should succeed
vprint("We enlist 5 players.")
list_pid = [{'playerID': pp_test[0]['playerID']},
{'playerID': pp_test[1]['playerID']},
{'playerID': pp_test[2]['playerID']},
{'playerID': pp_test[3]['playerID']},
{'playerID': pp_test[4]['playerID']}]
result = backend.enlistTeam(list_pid)
# check the gameID for all players
vprint("We now check that their gameID is compliant:")
for i in range(0,5):
playerID = pp_test[i]['playerID']
pp_db = playersColl.find_one({'_id': playerID})
gameID_db = pp_db['gameID']
result = backend.getGameID(playerID)
self.assertEqual(result['status'], "ok")
self.assertEqual(result['gameID'], gameID_db)
vprint(" > " + pp_test[i]['nickname'] + ": compliant")
result = backend.getGameID(pp_test[5]['playerID'])
self.assertEqual(result['status'], "ok")
self.assertEqual(result['gameID'], None)
vprint(" > Daisy: compliant")
# check the gameID for an unknown playerID
result = backend.getGameID(ObjectId())
self.assertEqual(result['status'], "ko")
self.assertEqual(result['reason'], "unknown playerID")
vprint(" > unknown playerID: compliant")
# check the gameID for an invalid playerID
result = backend.getGameID("invalidplayerID")
self.assertEqual(result['status'], "ko")
self.assertEqual(result['reason'], "invalid playerID")
vprint(" > invalid playerID: compliant")
def test_deRegisterPlayer(self):
"""
Test backend.deRegisterPlayer
"""
vbar()
print("test backend.deRegisterPlayer")
vbar()
# initiate a backend and register reference players
backend = self.setUp()
vprint("We register the reference test players:")
backend.ForTestOnly_RegisterRefPlayers()
pp_test = refPlayers(True)
playersColl = getPlayersColl()
# enlist a team of 5 players: it should succeed
list_pid = [{'playerID': pp_test[0]['playerID']},
{'playerID': pp_test[1]['playerID']},
{'playerID': pp_test[2]['playerID']},
{'playerID': pp_test[3]['playerID']},
{'playerID': pp_test[4]['playerID']}]
result = backend.enlistTeam(list_pid)
vprint("Enlist 5 players: " + str(result['status'])
+ " (" + str(result['gameID']) + ")")
# deregister an invalid playerID
vprint("Try de-registering an invalid playerID:")
result = backend.deRegisterPlayer("thisisnotavalidobjectid")
self.assertEqual(result['status'], "ko")
self.assertEqual(result['reason'], "invalid playerID")
vprint(" > could not de-register: " + result['reason'])
# deregister an unknown playerID
vprint("Try de-registering an unknown playerID:")
result = backend.deRegisterPlayer(ObjectId())
self.assertEqual(result['status'], "ko")
self.assertEqual(result['reason'], "unknown playerID")
vprint(" > could not de-register: " + result['reason'])
# deregister all players one after the other
vprint("Now, we de-register the players one after the other:")
for pp in pp_test:
backend.deRegisterPlayer(pp['playerID'])
# check that the player is not anymore listed n the database
result = playersColl.find_one({'_id': pp['playerID']})
self.assertEqual(result, None)
# check that the player is not anymore listed in the game
result = backend.games[0].getPlayer(pp['playerID'])
self.assertEqual(result['status'], "ko")
vprint(" > " + pp['nickname'] + ": was de-registered")
def ForTestOnly_RegisterRefPlayers(self):
"""
FOR TEST PURPOSE ONLY.
This method register 6 reference test players.
"""
# connects straight to the Mongo database
playersColl = getPlayersColl()
playersColl.drop()
# now register the reference players straight to the DB (bypassing the
# normal process = call to the setserver 'register' API)
for pp in refPlayers(True):
playersColl.insert_one( {
'_id': pp['playerID'],
'nickname': pp['nickname'],
'passwordHash': pp['passwordHash'],
'totalScore': 0,
'gameID': None } )
return {'status': "ok"}
def test_delistGame(self):
"""
Test players.delistGame
"""
# setup the test data
self.setUp()
players = Players()
ref_players = []
for pp in refPlayers():
ref_players.append(player_format_DB(pp))
gameID1 = ref_players[0]['gameID']
gameID2 = ref_players[2]['gameID']
players.enlist(players.getPlayerID("Daisy")['playerID'], gameID1)
players.enlist(players.getPlayerID("Donald")['playerID'], gameID1)
players.enlist(players.getPlayerID("Riri")['playerID'], gameID2)
players.enlist(players.getPlayerID("Fifi")['playerID'], gameID2)
players.enlist(players.getPlayerID("Loulou")['playerID'], gameID2)
# will delist few players
vbar()
print("Test players.delistGame")
vbar()
vprint("Test registering several players on two games:")
vprint(" - Riri, Fifi and Loulou are part of a first game.")
vprint(" - Daisy and Donald are part of another game.")
vprint(" - Mickey does not play a game.")
vprint(" Here are the players after we deregister the second game:")
gid = players.getGameID(
players.getPlayerID("Riri")['playerID'])['gameID']
players.delistGame(gid)
riri_gid = players.getGameID(
players.getPlayerID("Riri")['playerID'])['gameID']
fifi_gid = players.getGameID(
players.getPlayerID("Fifi")['playerID'])['gameID']
loulou_gid = players.getGameID(
players.getPlayerID("Loulou")['playerID'])['gameID']
self.assertTrue(riri_gid == fifi_gid == loulou_gid == None)
for pp in players.playersColl.find({}):
vprint(" " + pp['nickname'] + " - gameID: " +
str(pp['gameID']))
# end of the test
self.teardown(players)
def test_ForTestOnly_RegisterRefPlayers(self):
"""
Test backend.ForTestOnly_RegisterRefPlayers
"""
vbar()
print("Test backend.ForTestOnly_RegisterRefPlayers")
vbar()
# initiate a backend
backend = self.setUp()
# register reference players
vprint("Initiate a backend and register reference players:")
backend.ForTestOnly_RegisterRefPlayers()
# compare the registered players with the reference test data
for pp_ref in refPlayers(True):
pp_test = backend.players.getPlayer(pp_ref['playerID'])
self.assertEqual(pp_test['status'], "ok")
self.assertEqual(pp_test['playerID'], pp_ref['playerID'])
self.assertEqual(pp_test['nickname'], pp_ref['nickname'])
self.assertEqual(pp_test['passwordHash'], pp_ref['passwordHash'])
self.assertEqual(pp_test['totalScore'], 0)
self.assertEqual(pp_test['gameID'], None)
vprint(" - registered successfully " + pp_ref['nickname'])
def ForTestOnly_LoadRefGame(self, test_data_index):
"""
FOR TEST PURPOSE ONLY.
This method initiate the reference test game corresponding to the index
passed as argument. The game is fully played and is finished.
"""
# cleans the DB and registers the reference players
if test_data_index in (0,1):
# initiate a new game and overwrite it with reference test data
self.reset()
self.ForTestOnly_RegisterRefPlayers()
# initialize a game (just to have a game object available
self.games.append(Game(refPlayers(True)))
# override this game with the reference test data
self.games[0].deserialize(refGames_Dict()[test_data_index])
gID = self.games[0].getGameID()
for pp in self.players.getPlayers():
self.players.delist(pp['playerID'])
self.players.enlist(pp['playerID'], gID)
result = {'status': "ok", 'gameID': gID}
else:
result = {'status': "ko", 'reason': "wrong test_data_index"}
return result
def test_changeHash(self):
"""
Test players.changeHash
"""
# setup the test data
vbar()
print("Test players.changeHash")
vbar()
vprint(
"We change the hash of the players in the DB and compare the result with"
)
vprint("the expected test data:")
# test valid players
self.setUp()
players = Players()
new_hash = "lEyycZ2UYZV0bX6ChdtSA5MGCmN3BrF1xoZG4TMRzEmwmpp"
for pp in refPlayers():
playerID = pp['playerID']
result = players.changeHash(playerID, new_hash)
valid = (result['status'] == "ok") and (result['passwordHash']
== new_hash)
vprint(" " + pp['nickname'] + ": result = " + str(result))
self.assertTrue(valid)
# test unknown player
result = players.getHash(ObjectId())
valid = (result['status'] == "ko") and (result['reason']
== "unknown playerID")
vprint(" Unknown player: result = " + str(result))
self.assertTrue(valid)
# test invalid playerID
result = players.getHash("invalid")
valid = (result['status'] == "ko") and (result['reason']
== "invalid playerID")
vprint(" Invalid playerID: result = " + str(result))
self.assertTrue(valid)
# end of the test
self.teardown(players)
def test_isNicknameAvailable(self):
"""
Test backend.isNicknameAvailable
"""
vbar()
print("test backend.isNicknameAvailable")
vbar()
# initiate a backend
backend = self.setUp()
# check availability of nicknames before and after registering players
vprint("Initiate a backend with no players registered, and check nickname availaiblity")
vprint("before and after registering reference players:")
for pp in refPlayers(True):
# check the nickname is available before the player is registered
answer = backend.isNicknameAvailable(pp['nickname'])
self.assertEqual(answer['status'], "ok")
vprint(" > " + pp['nickname'] + " is available")
# register the player
result = backend.registerPlayer(pp['nickname'], pp['passwordHash'])
vprint(" - register " + pp['nickname'] + ": " + str(result['playerID']))
# check the nickname is not available after the player is registered
answer = backend.isNicknameAvailable(pp['nickname'])
self.assertEqual(answer['status'], "ko")
vprint(" > " + pp['nickname'] + " is not available anymore")
def test_getDetails(self):
"""
tests backend.getDetails
"""
vbar()
print("Test backend.getDetails")
vbar()
# initialize test data, launch a game with 5 players
backend = self.setUp()
vprint("We register the reference test players:")
backend.ForTestOnly_RegisterRefPlayers()
pp_test = refPlayers(True)
list_pid = [{'playerID': pp_test[0]['playerID']},
{'playerID': pp_test[1]['playerID']},
{'playerID': pp_test[2]['playerID']},
{'playerID': pp_test[3]['playerID']},
{'playerID': pp_test[4]['playerID']}]
# we enlist 5 players => succeed and return the gameID
enlisted = backend.enlistTeam(list_pid)
# build the target against which the test data will be compared
gID = enlisted['gameID']
target_cardset = refGames_Dict()[0]['cardset']
target = {
'__class__': 'SetGameDetails',
'gameFinished': 'False',
'turnCounter': '0',
'players': [],
'cardset': target_cardset,
'gameID': str(gID)
}
for pp in refPlayers():
if pp['nickname'] != "Daisy":
target['players'].append({
'playerID': str(pp['playerID']),
'nickname': pp['nickname'],
'passwordHash': pp['passwordHash'],
'points': '0'
})
# override the newly created game with the reference test data
backend.games[0].cards.deserialize(target_cardset)
backend.games[0].gameID = gID
vprint("Enlist a team of 5 player: " + str(enlisted['status'])
+ " (" + str(gID) + ")")
# request the details of the game
result = backend.getDetails(gID)
# check that the result is compliant
valid = True
valid1 = (target['gameID'] == result['gameID'])
vprint(" - 'gameID' are similar: " + str(valid))
valid2 = (target['turnCounter'] == result['turnCounter'])
vprint(" - 'turnCounters' are similar: " + str(valid))
valid3 = (target['gameFinished'] == result['gameFinished'])
vprint(" - 'gameFinished' are similar: " + str(valid))
valid4 = (len(target['players']) == len(result['players']))
valid5 = True
for pp in target['players']:
valid5 = valid5 and (pp in result['players'])
vprint(" - 'players' are similar: " + str(valid5))
valid6 = cardsetDict_equality(target['cardset'], result['cardset'])
vprint(" - 'cardset' are similar: " + str(valid6))
valid = valid1 and valid2 and valid3 and valid4 and valid5 and valid6
vprint(" -> the result is compliant: " + str(valid))
self.assertTrue(valid)
def test_getStep(self):
"""
Test backend.getStep
"""
vbar()
print("Test backend.getStep")
vbar()
# initialize reference test data, launch a game with 5 players
backend = self.setUp()
vprint("We register the reference test players:")
backend.ForTestOnly_RegisterRefPlayers()
pp_test = refPlayers(True)
list_pid = [{'playerID': pp_test[0]['playerID']},
{'playerID': pp_test[1]['playerID']},
{'playerID': pp_test[2]['playerID']},
{'playerID': pp_test[3]['playerID']},
{'playerID': pp_test[4]['playerID']}]
result = backend.enlistTeam(list_pid)
gID = result['gameID']
# identify the right game and overwrite it with a reference game
# (cardset 0, refGame 0, finished, 25 turns)
vprint("We reconstitute the reference game 0 at turn 9.")
for j in range(0, len(backend.games)):
if str(backend.games[j].getGameID()) == str(gID):
i = j
break
backend.games[i].deserialize(refGames_Dict()[0])
# rewind the game back to turn 9
backend.games[i].turnCounter = 9
j = 25
while j > 9:
del(backend.games[i].steps[j])
j -= 1
backend.games[i].steps[9].set = []
target = refGames_Dict()[0]['steps'][9]
target['set'] = []
# the game is now ready for the test case
vprint("We ask for the Step 9:")
result = backend.getStep(ObjectId('57b9bec5124e9b2d2503b72b'))
status = result['status']
step_dict = result['step']
vprint(" - status: " + status)
vprint(" - step 9: " + str(step_dict))
valid = (status == "ok") and stepDict_equality(step_dict, target)
vprint(" Result compliant: " + str(valid))
self.assertTrue(valid)
# We check that invalid gameID are discarded
vprint("We ask for the Step 9 of an invalid gameID:")
result = backend.getStep('tzagb9b2d2503b72b')
valid = (result['status'] == "ko")
vprint(" - status: " + result['status'])
vprint(" - reason: " + result['reason'])
valid = valid and (result['reason'] == "invalid gameID")
vprint(" Result compliant: " + str(valid))
self.assertTrue(valid)
vprint("We ask for the Step 9 of an unkown gameID:")
result = backend.getStep(ObjectId())
valid = (result['status'] == "ko")
vprint(" - status: " + result['status'])
vprint(" - reason: " + result['reason'])
valid = valid and (result['reason'] == "game does not exist")
vprint(" Result compliant: " + str(valid))
self.assertTrue(valid)
