class TestTable:
'''Tests that InvalidBet Exception is thrown when table enters invalid state.
Invalid states are when:
1. Sum of bets exceeds table limit.
2. Bet amount is below table minimum.
'''
def setup_method(self, method):
wheel = Wheel()
self.table = Table(100, wheel)
def test_invalid_bet(self):
with pytest.raises(InvalidBet):
self.table.place_bet(Bet(105, Outcome("0", 35)))
table2 = Table(100, self.table.wheel)
table2.place_bet(Bet(60, Outcome("0", 35)))
with pytest.raises(InvalidBet):
self.table.place_bet(Bet(50, Outcome("0", 35)))
def test_add_bet(self):
bet = Bet(60, Outcome("0", 35))
self.table.place_bet(bet)
assert bet == next(iter(self.table))
def test_table_clear_bet(self):
self.table.place_bet(Bet(60, Outcome("0", 35)))
assert len(self.table.bets) == 1
self.table.clear_bets()
assert len(self.table.bets) == 0
def test_simulator_session(self):
simulation_wheel = Wheel(1)
simulation_table = Table(100,simulation_wheel)
simulation_player = Martingale(simulation_table)
simulation_player.set_rounds(self.simulator.init_duration)
simulation_player.set_stake(self.simulator.init_stake)
black = simulation_player.black #Martingale always bets on black
simulated_stakes = [simulation_player.stake]
while simulation_player.playing():
simulation_player.place_bets()
outcome = simulation_wheel.next()
if black in outcome:
simulation_player.win(simulation_table.bets[0])
else:
simulation_player.lose(simulation_table.bets[0])
simulation_table.clear_bets()
simulated_stakes.append(simulation_player.stake)
stakes = self.simulator.session()
assert type(stakes) == list
assert stakes == simulated_stakes
def test_invalid_bet(self):
with pytest.raises(InvalidBet):
self.table.place_bet(Bet(105, Outcome("0", 35)))
table2 = Table(100, self.table.wheel)
table2.place_bet(Bet(60, Outcome("0", 35)))
with pytest.raises(InvalidBet):
self.table.place_bet(Bet(50, Outcome("0", 35)))
def test_Table(self):
tbl = Table(limit=30)
bet1 = Bet(10, Outcome("Red", 1))
bet2 = Bet(20, Outcome("Corner", 2))
bet3 = Bet(30, Outcome("Black", 3))
bet4 = Bet(40, Outcome("Street", 4))
self.assertTrue(tbl.is_valid(bet1))
self.assertTrue(tbl.is_valid(
bet3)) # a bet of 30 should be acceptable even with a limit of 30
self.assertFalse(tbl.is_valid(bet4)) # 40 should not be valid
tbl.place_bet(bet1)
tbl.place_bet(bet2)
self.assertFalse(tbl.is_valid(bet1))
"""
Test that exception will raise if a bet causes bets to exceed the table limit
http://www.lengrand.fr/2011/12/pythonunittest-assertraises-raises-error/
"""
self.assertRaises(
InvalidBet,
lambda: tbl.place_bet(bet2)) # this should raise an exception
# test that Table object is iterable
self.assertTrue(isinstance(tbl, collections.Iterable))
def setUp(self):
self.nonrandom = NonRandom()
self.nonrandom.set_seed(1) # red
wheel = Wheel(self.nonrandom)
self.table = Table(limit=100)
bin_builder = BinBuilder()
bin_builder.build_bins(wheel)
self.game = RouletteGame(wheel, self.table)
def setUp(self):
# wheel -- returns bin 2
self.nonrandom = NonRandom()
self.nonrandom.set_seed(2) # black
wheel = Wheel(self.nonrandom)
self.table = Table(limit=100)
bin_builder = BinBuilder()
bin_builder.build_bins(wheel)
self.game = RouletteGame(wheel, self.table)
def setup_method(self):
wheel = Wheel(1)
table = Table(100,wheel)
martingale = Martingale(table)
game = Game(table)
assert martingale.rounds == None
assert martingale.stake == None
self.simulator = Simulator(game, martingale)
def test_table_iter_bets():
tt = Table(100, 5)
test_bets = []
wh = Wheel()
bt = Bet(10, wh.get_outcome('Even'))
test_bets.append(bt)
bt = Bet(5, wh.get_outcome('Even'))
test_bets.append(bt)
for test_bt, bt in zip(test_bets, tt):
assert test_bt == bt
def test_game(self):
log = logging.getLogger("GameTestCase.test_game")
# make wheel
self.nonrandom = NonRandom()
self.nonrandom.set_seed(2)
self.wheel = Wheel(self.nonrandom)
# make BinBuilder and build bins for wheel
bin_builder = BinBuilder()
bin_builder.build_bins(self.wheel)
# make table
table = Table(limit=100)
# make player
_p57 = Passenger57(table=table, stake=100, rounds_to_go=100)
# make game
self.game = RouletteGame(self.wheel, table)
# Test NonRandom
self.assertEqual(id(self.wheel.next()), id(self.wheel.next()))
# test game cycle with Passenger57
for i in range(4):
self.game.cycle(_p57)
def test_Table(self):
tbl = Table(limit=30)
bet1 = Bet(10, Outcome("Red", 1))
bet2 = Bet(20, Outcome("Corner", 2))
bet3 = Bet(30, Outcome("Black", 3))
bet4 = Bet(40, Outcome("Street", 4))
self.assertTrue(tbl.is_valid(bet1))
self.assertTrue(tbl.is_valid(bet3)) # a bet of 30 should be acceptable even with a limit of 30
self.assertFalse(tbl.is_valid(bet4)) # 40 should not be valid
tbl.place_bet(bet1)
tbl.place_bet(bet2)
self.assertFalse(tbl.is_valid(bet1))
"""
Test that exception will raise if a bet causes bets to exceed the table limit
http://www.lengrand.fr/2011/12/pythonunittest-assertraises-raises-error/
"""
self.assertRaises(InvalidBet, lambda: tbl.place_bet(bet2)) # this should raise an exception
# test that Table object is iterable
self.assertTrue(isinstance(tbl, collections.Iterable))
def test_TableStr(self):
tbl = Table(limit=30)
tbl.place_bet(Bet(10, Outcome("Red", 1)))
self.assertEquals(str(tbl), "['amount on Red (1:1)']")
def setup_method(self, method):
wheel = Wheel()
self.table = Table(100, wheel)
def test_TableStr(self):
tbl = Table(limit=30)
tbl.place_bet(Bet(10, Outcome("Red", 1)))
self.assertEquals(str(tbl), "['amount on Red (1:1)']")
def test_table_place_bet():
tt = Table(100, 5)
wh = Wheel()
bt = Bet(10, wh.get_outcome('Even'))
assert True == tt.place_bet(bt)
def test_table_is_valid():
wh = Wheel()
with pytest.raises(InvalidBetException) as e_info:
tt = Table(100, 5)
# should violate the min bet amount and throw exception
bt = Bet(1, wh.get_outcome('Even'))
tt.place_bet(bt)
with pytest.raises(InvalidBetException) as e_info:
tt = Table(10, 5)
bt = Bet(5, wh.get_outcome('Even'))
tt.place_bet(bt)
bt = Bet(5, wh.get_outcome('Even'))
tt.place_bet(bt)
# should exceed table limit and throw exception
bt = Bet(5, wh.get_outcome('Even'))
tt.place_bet(bt)
# def test_table_iter():
# tt = Table(100, 5)
# print(tt.__iter__().isinstance(Iterator))
from roulette import Game, Passenger57, PlayerEven, Table, Wheel, BinBuilder
if __name__ == '__main__':
TABLE_MIN = 10
table = Table(500, TABLE_MIN)
wheel = Wheel()
BinBuilder().build_bins(wheel)
game = Game(wheel, table)
playr = PlayerEven()
playr.wallet = 10000
round = 1
while playr.is_playing() and playr.get_wallet() > TABLE_MIN:
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
print(f'Round {round}: player wallet is {playr.get_wallet()}')
game.cycle(playr)
round += 1
table.clear_bets()
if playr.is_playing() is False:
print(f"Thanks for playing: player final wallet is {playr.get_wallet()} {playr.is_playing()}")
else:
print(f"GAME OVER: player final wallet is {playr.get_wallet()} {playr.is_playing()}")