def setUp(self):
"""
Sets up the test data and create a backend
"""
# reset the DB data
vprint("We clean the test databases.")
getPlayersColl().drop()
getGamesColl().drop()
# initialize a backend
return Backend()
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 __init__(self):
"""
Links with the relevant collection in the Mongo database.
"""
# initiates the players collections and the 'in memory' list
self.playersColl = getPlayersColl()
"""
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_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_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 reset(self):
"""
ths method is used for test purposes: it enables 'test_setserver' to
reset the server's variables and ensure that all tests will run in a
clean context.
It is an alternative to endlessly stopping and restarting the server.
"""
# connect to the players collection, and empty it
getPlayersColl().drop()
# connect to the games collection and empty it
getGamesColl().drop()
# voluntarily, we do NOT empty the log collection
# initialize again all generic variables
self.games = []
self.players = Players()
self.playersWaitingList = []
self.nextGameID = None
# returns status update answer
return {'status': "reset"}
def isPlayerIDValid(playerID):
"""
This method checks that the playerID is valid (ie. it is a valid
ObjectId and the corresponding player exists in the DB).
It return 'True' in this case, or 'False' in any other case.
"""
playersColl = getPlayersColl()
result = False
if oidIsValid(playerID):
pp = playersColl.find_one({'_id': playerID})
result = (pp != None)
return result
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 tearDown(self):
# reset the DB data
vprint("We clean the test databases.")
getPlayersColl().drop()
getGamesColl().drop()
def test__init__(self):
"""
Test game.__init__
"""
vbar()
print("Test game.__init__")
vbar()
# first try to initialize a game with wrong playerIDs
# populate the DB with reference players
playersColl = getPlayersColl()
playersColl.drop()
for pp in refPlayers():
playersColl.insert_one({
'_id': pp['playerID'],
'nickname': pp['nickname'],
'totalScore': pp['totalScore'],
'gameID': None
})
# try to initiate a game with different players + 1 wrong player
players = []
pp = refPlayers()[0]
players.append({
'playerID': pp['playerID'],
'nickname': pp['nickname']
})
pp = refPlayers()[2]
players.append({
'playerID': pp['playerID'],
'nickname': pp['nickname']
})
pp = refPlayers()[3]
players.append({
'playerID': pp['playerID'],
'nickname': pp['nickname']
})
pp = refPlayers()[4]
players.append({
'playerID': pp['playerID'],
'nickname': pp['nickname']
})
players.append({'playerID': ObjectId(), 'nickname': "batman"})
try:
partie = Game(players)
except invalidPlayerID:
vprint(" - could not initialize a game: playerIDs are invadid.")
# second initialize successfully a game and test various values
# build the reference starting for the game from the test data
test_data_index = 0
partie = self.setup(test_data_index)
cards_ref = refCardsets()[test_data_index]
steps_ref = refSteps()[test_data_index]
vprint(
"We start with a first iteration: we push one set and compare the")
vprint("full status of the game with target:")
# compare status with target
ref_gameID = ObjectId(refGameHeader_start()[test_data_index]['gameID'])
result = (partie.gameID == ref_gameID)
vprint(" > gameID is compliant: " + str(result))
self.assertTrue(result)
result = cardset_equality(partie.cards, cards_ref)
vprint(" > cardset is compliant: " + str(result))
self.assertTrue(result)
# we can compare with reference test data only steps which are in a
# 'definitive' status (i.e. a valid Set has been proposed, the game took
# it to build the next Step (here: Step 1) and store the Step 0 in its
# 'final' status. Our reference data enable to compare Step only in
# their 'final' status'.
# Here, we have proposed a valid set and the game built the Step 1:
# - Step 0 is in a 'final' status => we compare it with reference data
# - Step 1 is in an intermediate status: cannot be compared yet.
# We fetch from reference data the next player and the next Set:
nextset_dict = refGames_Dict()[test_data_index]['steps'][0]['set']
next_set = []
for ss in nextset_dict:
next_set.append(int(ss))
next_playerID = refGames_Dict(
)[test_data_index]['steps'][0]['playerID']
next_playerID = ObjectId(next_playerID)
# The player proposes the Set:
partie.receiveSetProposal(next_playerID, next_set)
# We now can compare Step 0 with reference test data.
result = step_equality(partie.steps[0], steps_ref[0])
vprint(" > Step[0] is compliant: " + str(result))
self.assertTrue(result)
