def test_cards_on_table_stay(self):
try:
players = buildPlayers(1)
table = datalayer.findATableForPlayer(players[0])
table.dealToTable(3)
datalayer.updateTable(table)
cardsInDeck = table.deck
originalTableId = table.tableId
players = buildPlayers(4)
for player in players:
table = datalayer.findATableForPlayer(player)
self.assertEqual(len(cardsInDeck.cards), len(table.deck.cards),
"Deck should be the same length")
self.assertEqual(originalTableId, table.tableId,
"And it should be the same table")
count = 5
self.assertEqual(count, len(table.players))
for player in table.players:
count = count - 1
table.removePlayer(player)
self.assertEqual(count, len(table.players))
datalayer.deletePlayer(player)
finally:
datalayer.deleteTable(table)
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 checkForAndRemoveMissingPlayers(table):
for player in table.players:
if player.turn:
startTime = datetime.strptime(player.turnStartTime,
table.TIME_FORMAT)
timeLimit = startTime + timedelta(seconds=table.PLAYER_TURN_LIMIT)
logger.info("checking player " + player.name + " start time " +
str(startTime) + " time limit " + str(timeLimit))
now = datetime.now()
if now > timeLimit:
logger.info("player removed from table after timeout")
table.removePlayer(player)
datalayer.updateTable(table)
else:
logger.info("player kept")
def makePlay(player, table, playerAction, actionAmount, currentStatus):
try:
if playerAction.lower() == "fold":
logger.info("Player will fold.")
table.playerFold(player)
else:
actionAmount = int(actionAmount)
currentTableBet = table.currentBet
playerCurrentBet = player.currentBet
logger.info("Making play ")
if ((actionAmount + playerCurrentBet) < currentTableBet):
logger.warn(
"Player must call or bet more than current table bet.")
raise ValueError(
"Player must call or bet more than current table bet.")
if actionAmount > 0:
logger.info("Player will call or bet")
table.playerBetOrCall(player, actionAmount)
else:
logger.info("Player will check")
table.playerCheck(player)
if not table.haveAllButOnePlayerFolded():
logger.info(
"checking to see if round is complete (not everyone has folded)"
)
if (table.isRoundComplete()):
logger.info("round is complete, now processing")
if len(table.cards) == 0:
table.dealToTable(3)
table.prepareForNextRound()
elif len(table.cards) < 5:
table.dealToTable(1)
table.prepareForNextRound()
else:
processWinners(table)
else:
logger.info("Every one has folded, processing winners")
processWinners(table)
#
datalayer.updateTable(table)
logger.info("make Play - table updated and returning.")
return table
except Exception as error:
logger.exception("Failure making play for player.", error)
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 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 checkForUpdates(table, player, currentStatus):
checkForAndRemoveMissingPlayers(table)
if len(table.players) == 1:
logger.info("only one player at table")
for player in table.players:
player.currentBet = 0
player.currentAction = PlayerAction.NONE
player.hand.cards = []
player.folded = False
player.dealer = False
player.isInformedHandComplete = False
if table.pot > 0:
player.chips + table.pot
table.pot = 0
table.currentBet = 0
table.winners = []
table.cards = []
datalayer.updateTable(table)
if len(table.players) > 1:
if not table.hasDealer():
table.setDealerAtRandom()
datalayer.updateTable(table)
while not table.doAllPlayersHaveTwoCards():
table.dealRound()
datalayer.updateTable(table)
logger.info("check to see if hand is complete")
if table.isHandComplete():
if table.allPlayersKnowHandIsComplete():
table.prepareForNextHand()
while not table.doAllPlayersHaveTwoCards():
table.dealRound()
logger.info(
"hand is complete, now adding player to list that knows it is complete"
)
player.isInformedHandComplete = True
datalayer.updateTable(table)
return table