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)