def test_Table(self):
try:
table = datalayer.getOrCreateSavedTable('notATableId')
print(table)
tableII = datalayer.getOrCreateSavedTable(table.tableId)
print(tableII)
self.assertEqual(table.tableId, tableII.tableId)
tableII.addPlayers(buildPlayers(5))
tableII.setDealerAtRandom()
tableII.setBlinds()
tableII.prepareForNextHand()
tableII.currentBet = 500
datalayer.updateTable(tableII)
tableIII = datalayer.getOrCreateSavedTable(tableII.tableId)
self.assertEqual(tableII.tableId, tableIII.tableId)
self.assertEqual(tableII.blind, tableIII.blind)
self.assertEqual(tableII.currentBet, tableIII.currentBet)
self.assertEqual(tableII.players[0].name, tableIII.players[0].name)
self.assertEqual(tableII.players[1].name, tableIII.players[1].name)
self.assertEqual(tableII.players[2].name, tableIII.players[2].name)
self.assertEqual(tableII.players[3].name, tableIII.players[3].name)
self.assertEqual(tableII.players[4].name, tableIII.players[4].name)
self.assertEqual(tableII.statusId, tableIII.statusId)
finally:
datalayer.deleteTable(table)
datalayer.deleteTable(tableII)
datalayer.deleteTable(tableIII)
def test_player_evicted_after_timout(self):
try:
table = datalayer.getOrCreateSavedTable("x")
player1 = datalayer.getOrCreateSavedPlayer("x", "player one")
table = datalayer.findATableForPlayer(player1)
player2 = datalayer.getOrCreateSavedPlayer("x", "player two")
table = datalayer.findATableForPlayer(player2)
player3 = datalayer.getOrCreateSavedPlayer("x", "player three")
table = datalayer.findATableForPlayer(player3)
player4 = datalayer.getOrCreateSavedPlayer("x", "player four")
table = datalayer.findATableForPlayer(player4)
currentStatusId = table.statusId
self.assertEqual(4, len(table.players))
for player in table.players:
playProcessor.checkForUpdates(table, player, currentStatusId)
logging.log(
logging.INFO,
"Waiting 5 seconds to see if player is automatically evicted")
table.PLAYER_TURN_LIMIT = 5 # 5 seconds
time.sleep(6)
playProcessor.checkForUpdates(table, player, currentStatusId)
self.assertEqual(3, len(table.players))
except Exception as error:
print("Unable to test." + str(error))
print('-' * 60)
traceback.print_exc(file=sys.stdout)
print('-' * 60)
finally:
datalayer.deleteTable(table)
def makePlay(event, context):
logger.info("makePlay called " + str(event))
try:
playerId = event['playerId']
playerAction = event['playerAction']
tableId = event['tableId']
tableStatusId = event['tableStatusId']
actionAmount = event['actionAmount']
table = datalayer.getOrCreateSavedTable(tableId)
logger.info("retrieved table: " + table.tableId)
player = table.findPlayerById(playerId)
logger.info("retrieved player from table: " + player.playerId)
# if table.statusId != int(tableStatusId):
# status = 500
# body = {"message": "Play is out of turn."}
# raise ValueError ("Play is out of turn.")
# else:
table = playProcessor.makePlay(player, table, playerAction, actionAmount, tableStatusId)
status = 200
body = buildTableResult(table)
except Exception as error:
logger.exception("Unable to make play." + str(error))
status = 500
body = str(error)
return createResponse(status, body)
def test_play_a_Round_via_processor(self):
'''
Attempt to simulate several browsers asking for data and processing
'''
try:
table = datalayer.getOrCreateSavedTable("x")
player1 = datalayer.getOrCreateSavedPlayer("x", "player one")
table = datalayer.findATableForPlayer(player1)
player2 = datalayer.getOrCreateSavedPlayer("x", "player two")
table = datalayer.findATableForPlayer(player2)
player3 = datalayer.getOrCreateSavedPlayer("x", "player three")
table = datalayer.findATableForPlayer(player3)
player4 = datalayer.getOrCreateSavedPlayer("x", "player four")
table = datalayer.findATableForPlayer(player4)
currentStatusId = table.statusId
for player in table.players:
playProcessor.checkForUpdates(table, player, currentStatusId)
if table.statusId != currentStatusId:
tableCards = 0
while not tableCards == 5: #isHandComplete (processes on own)
playedCount = 0
while playedCount < len(
table.players): ## is round complete
for player in table.players:
if player.turn:
myBet = table.currentBet - player.currentBet
playProcessor.makePlay(player, table, 'bet',
myBet, table.statusId)
playedCount = playedCount + 1
# the processor will automatically reset this above, so we need to fake this out to test
if len(table.cards) > 0:
tableCards = len(table.cards)
break
self.assertEquals(len(table.cards), 5)
if (len(table.winners) == 1):
assert (table.winners[0].chips, 104)
for player in table.winners:
print(str(player) + " wins ")
self.assertTrue(len(table.winners) > 0)
table.prepareForNextHand()
playerTurnCount = 0
for player in table.players:
if player.turn:
playerTurnCount = playerTurnCount + 1
self.assertEqual(playerTurnCount, 1)
except Exception as error:
print("Unable to test." + str(error))
print('-' * 60)
traceback.print_exc(file=sys.stdout)
print('-' * 60)
finally:
datalayer.deleteTable(table)
def testResetTables(self):
try:
players = buildPlayers(1)
table = datalayer.findATableForPlayer(players[0])
firstTableId = table.tableId
table.blind = 5
table.currentBet = 1000
datalayer.updateTable(table)
table2 = datalayer.getOrCreateSavedTable(firstTableId)
self.assertEquals(table2.tableId, firstTableId)
self.assertEqual(len(table2.players), len(table.players))
datalayer.resetUnusedTables(4)
logging.log(
logging.INFO,
"Waiting 5 seconds to see if player is automatically evicted")
time.sleep(5)
table3 = datalayer.getOrCreateSavedTable(firstTableId)
self.assertEqual(1, len(table3.players))
self.assertEquals(table3.tableId, firstTableId)
finally:
datalayer.updateTable(table)
datalayer.deleteTable(table2)
def removePlayer(event, context):
logger.info("removePlayer called " + str(event))
try:
tableId = event['tableId']
playerId = event['playerId']
logger.info("tableID: {0}, playerId{1}".format(tableId, playerId))
table = datalayer.getOrCreateSavedTable(tableId)
logger.info("retrieved table: " + table.tableId)
player = table.findPlayerById(playerId)
logger.info("retrieved player from table: " + player.playerId)
table.removePlayer(player)
datalayer.deletePlayer(player)
datalayer.updateTable(table)
status = 200
body = buildTableResult(table)
except Exception as error:
logger.exception("Unable to remove player." + str(error))
status = 500
body = str(error)
return createResponse(status, body)
def checkForUpdates(event, context):
logger.info("checkForUpdates called " + str(event))
try:
tableId = event['tableId']
tableStatusId = event['tableStatusId']
playerId = event['playerId']
logger.info("tableID: {0}, tableStatusId: {1}, playerId{2}".format(tableId, tableStatusId, playerId))
table = datalayer.getOrCreateSavedTable(tableId)
logger.info("retrieved table: " + table.tableId)
player = table.findPlayerById(playerId)
if player is None:
logger.info("Player not on table raising error... " )
raise Exception("Player not found at table.")
else:
logger.info("retrieved player from table: " + player.playerId)
table = playProcessor.checkForUpdates(table, player, tableStatusId)
status = 200
body = buildTableResult(table)
except Exception as error:
logger.exception("Unable to check for updates." + str(error))
status = 500
body = str(error)
return createResponse(status, body)