def test_all_players_in_game_give_the_same_value_to_the_table(self):
"""
Pre: Create 2 tables. 1 with players who give the same value. 2 with
with 1 player who give less than other players
Output: True if all players 'in game' give the same value to the pool.
"""
# Arrange
player1 = Player(name=User(username='******'),
state='start',
round_money=10)
player2 = Player(name=User(username='******'),
state='start',
round_money=10)
player3 = Player(name=User(username='******'),
state='start',
round_money=10)
player4 = Player(name=User(username='******'),
state='start',
round_money=9)
table1 = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
table2 = Table(player1=player1, player2=player2)
# Act
result1 = table1.all_players_in_game_give_the_same_value_to_the_table()
result2 = table2.all_players_in_game_give_the_same_value_to_the_table()
# Assertion
self.assertIsInstance(result1, bool)
self.assertFalse(result1)
self.assertIsInstance(result2, bool)
self.assertTrue(result2)
def test_all_players_round_money_to_zero(self):
"""Set round_money to zero for all players"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, round_money=-99)
player1.save()
player2 = Player(name=us2, round_money=0)
player2.save()
player3 = Player(name=us3, round_money=99)
player3.save()
player4 = Player(name=us4, round_money=9)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
# Act
table.all_players_round_money_to_zero()
# Assertion
self.assertEqual(table.player1.round_money, 0)
def test_all_players_in_game_make_decision(self):
"""
Pre: Create table with 2 players with 'start' and 'out' state and 2
players with 'raise' and 'check' state -> what means they made decisions.
Output: True if all players 'in game' make a decision
"""
# Arrange
player1 = Player(name=User(username='******'), state='start')
player2 = Player(name=User(username='******'), state='out')
player3 = Player(name=User(username='******'), state='raise')
player4 = Player(name=User(username='******'), state='check')
table1 = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
table2 = Table(player3=player3, player4=player4)
# Act
result1 = table1.all_players_in_game_make_decision()
result2 = table2.all_players_in_game_make_decision()
# Assertion
self.assertIsInstance(result1, bool)
self.assertFalse(result1)
self.assertIsInstance(result2, bool)
self.assertTrue(result2)
def test_next_game_state_2_players(self):
"""Change current game state to the next from the game path"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
player1 = Player(name=us1, state='check')
player1.save()
player2 = Player(name=us2, state='check')
player2.save()
table = Table(player1=player1, player2=player2)
# Act & Assertion
self.assertEqual(table.game_state, 'ready')
table.next_game_state()
self.assertEqual(table.game_state, 'small_blind')
table.next_game_state()
self.assertEqual(table.game_state, 'give_2')
table.next_game_state()
self.assertEqual(table.game_state, 'give_3')
table.next_game_state()
self.assertEqual(table.game_state, 'give_1')
table.next_game_state()
self.assertEqual(table.game_state, 'give_1_again')
table.next_game_state()
self.assertEqual(table.game_state, 'winner')
table.next_game_state()
# In this plase should be 'again' but self.start_game_again() call
# this table.next_game_state, so we jump to begin - 'ready' state
self.assertEqual(table.game_state, 'ready')
def test_start_game_again(self):
"""Reset game and start them again with the same players"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='pass', round_money=1)
player1.save()
player2 = Player(name=us2, state='out', round_money=0)
player2.save()
player3 = Player(name=us3, state='check', round_money=99)
player3.save()
player4 = Player(name=us4, state='start', round_money=7)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='again')
# Act
table.start_game_again()
# Assertion
self.assertEqual(table.game_state, 'ready')
self.assertEqual(table.player1.state, 'start')
self.assertEqual(table.player2.state, 'start')
self.assertEqual(table.player3.state, 'start')
self.assertEqual(table.player4.state, 'start')
def test_init(self):
me = Player(123, "", 0, False, [])
others = [Player(222, "", 0, False, []), Player(111, "", 0, False, [])]
game = Game(0, 0, me.id, [me] + others, None, None, [])
self.assertEqual(me, game.me)
self.assertEqual(others, game.enemies)
def test_biggest_rate(self):
"""
Should return the biggest value from all players from
player.round_money field
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, round_money=1)
player1.save()
player2 = Player(name=us2, round_money=0)
player2.save()
player3 = Player(name=us3, round_money=99)
player3.save()
player4 = Player(name=us4, round_money=7)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='again')
# Act
result = table.biggest_rate()
# Assertion
self.assertEqual(result, 99)
def test_check_players_have_cards(self):
"""Return False if at least one player have cards"""
# Arrange
cards1 = str(Card.new('As')) + ',' + str(Card.new('9s'))
cards2 = str(Card.new('Ah')) + ',' + str(Card.new('9h'))
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, cards=cards1)
player1.save()
player2 = Player(name=us2, cards=cards2)
player2.save()
player3 = Player(name=us3)
player3.save()
player4 = Player(name=us4)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
# Act
result = table.check_players_have_cards()
# Assertion
self.assertFalse(result)
table.remove_cards_from_players()
result2 = table.check_players_have_cards()
self.assertTrue(result2)
def test_init_unknown_player_id(self):
unknown_id = 42
players = [
Player(222, "", 0, False, []),
Player(111, "", 0, False, [])
]
self.assertRaises(UnknownPlayerIdException, Game, 0, 0, unknown_id,
players, None, None, [])
def test_dealer_button(self):
"""
Give dealer button to first player or next of previous gamer
Dealer is always awarded to the first player if the table.dealer field
is empty or to the next player inthe table.dealer field
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='start')
player1.save()
player2 = Player(name=us2, state='start')
player2.save()
player3 = Player(name=us3, state='start')
player3.save()
player4 = Player(name=us4, state='start')
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='start')
# Act & Assertion
table.dealer_button()
self.assertEqual(table.dealer, player1)
table.game_state = 'start'
table.dealer_button()
self.assertEqual(table.dealer, player2)
table.game_state = 'start'
table.dealer_button()
self.assertEqual(table.dealer, player3)
table.game_state = 'start'
table.dealer_button()
self.assertEqual(table.dealer, player4)
table.game_state = 'start'
table.dealer_button()
self.assertEqual(table.dealer, player1)
def test_start(self):
"""
Set 'start' state for table and available players in table
if number of players in this table is > 1
and state of game is 'ready'
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='check')
player1.save()
player2 = Player(name=us2, state='pass')
player2.save()
player3 = Player(name=us3, state='raise')
player3.save()
player4 = Player(name=us4, state='out')
player4.save()
table = Table(player1=player1)
# Assertions & Acts
# Only 1 player in table (table.start() should not working)
self.assertEqual(table.game_state, 'ready')
table.start()
self.assertNotEqual(table.game_state, 'start')
# 4 players in table (table.start() should works)
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
self.assertEqual(table.game_state, 'ready')
self.assertEqual(player1.state, 'check')
self.assertEqual(player2.state, 'pass')
self.assertEqual(player3.state, 'raise')
self.assertEqual(player4.state, 'out')
table.start()
self.assertEqual(table.game_state, 'start')
self.assertEqual(player1.state, 'start')
self.assertEqual(player2.state, 'start')
self.assertEqual(player3.state, 'start')
self.assertEqual(player4.state, 'start')
def test_add_player(self):
"""Add Player to free space in table"""
# Arrange
player1 = Player(name=User(username='******'))
player2 = Player(name=User(username='******'))
player3 = Player(name=User(username='******'))
player4 = Player(name=User(username='******'))
table = Table(player1=player1, player2=player2, player4=player4)
# Act
table.add_player(player3)
# Assertion
self.assertEqual(table.player3, player3)
def new_game(request, session_id):
form = NewGame()
# Форма по созданию игры
if request.method == 'POST':
form = NewGame(request.POST)
if form.is_valid() and form['number'].value():
if not Player.objects.filter(player_id=session_id):
Player(player_id=session_id).save()
Game(game_id=session_id, number=form['number'].value()).save()
PlayerGameInfo(player_id=Player.objects.filter(
player_id=session_id).values('id')[0]['id'],
game_id=Game.objects.order_by('-id').filter(
game_id=session_id).values('id')[0]['id'],
is_owner=True).save()
return redirect('game_created',
game_id=Game.objects.order_by('-id').filter(
game_id=session_id).values('id')[0]['id'])
return render(
request,
'new_game.html',
{
'form': form,
},
)
def game(request):
"""
receive a player name in a POST to create a new game
return the newly created game object
"""
if request.method == 'POST': #create a new game
game = Game()
code = game.new_game()
playername = request.data['player_name']
player = Player(name=playername)
player.join_game(code)
game_serializer = GameSerializer(game)
player_serializer = PlayerSerializer(player)
#return a json object containing both the game and the player's object
return Response({
'game': game_serializer.data,
'player': player_serializer.data
})
elif request.method == 'GET': #retrieve info for an existing game
if 'access_code' in request.query_params:
game = Game.objects.get(
access_code=request.query_params['access_code'])
serializer = GameSerializer(game)
return Response(serializer.data)
else:
return Response()
def test_update_game_calls_send_actions(self):
cells = [
Cell(0, 5, 10, Vec2(0, 0), Vec2(1, 1)),
Cell(1, 5, 10, Vec2(0, 0), Vec2(1, 1)),
Cell(2, 5, 10, Vec2(0, 0), Vec2(1, 1))
]
player = Player(0, "", 10, True, cells)
game = Game(0, 0, 0, [player], Resources([], [], []), Map(0, 0), [])
cells[0].target = Vec2(2, 2)
cells[0].burst()
cells[1].split()
cells[1].trade(3)
class MockApi:
def send_actions(self, game_id, actions):
self.actions = actions
api = MockApi()
update_game(api, game, lambda x: None)
self.assertEqual(len(api.actions), 2)
self.assertTrue(api.actions[0].target.almost_equals(Vec2(2, 2)))
self.assertTrue(api.actions[0].burst)
self.assertTrue(api.actions[1].split)
self.assertEqual(3, api.actions[1].trade)
def register(request):
if request.method == "POST":
form = RegistrationForm(request.POST)
#?All of them seem to be connected with [email protected] why????
#*Maybe it's because no one was logged in at this point???
#!NOW I KNOW WHY. IT WAS BECAUSE I WAS LOGGED IN WITH [email protected] AND THE USER NEVER CHANGED.
#*As proof, when I register when I am logged out, I runn into an attribute error at request.user.player.add
#!SINCE THIS IS THE CASE I NEED TO CREATE THE PLAYER IN HOME PAGE
if form.is_valid():
#*I think I can just redirect to login
#!I have to differentiate between what is done at registration vs login
n = form.cleaned_data['username']
p = Player(name=n, highscore=0)
p.save()
form.save()
return redirect("/login")
#*What I need to pass in the correct variables for register
form = RegistrationForm()
if request.user.is_authenticated:
u = Player.objects.filter(name=request.user.get_username())[0]
return render(request, "register/register.html", {
"user": u,
"logged_in": True,
"form": form
})
else:
return render(request, "register/register.html", {
"logged_in": False,
"form": form,
})
def create_player(user, game, players):
"""Create and return player.
only return player if he is already created
:param user: user who will be related to player
:param game: game what will be related to player
:return: Player object
"""
players = players.order_by('in_game_order')
player = players.filter(user=user).first()
if player is None:
player = Player(user=user,
name=user.username,
game=game,
chips=GameSerializer(game).data['starting_chips'],
is_in_game=True)
else:
player.is_in_game = True
# set player in_game_order
if len(players) < 1:
player.in_game_order = 1
else:
player.in_game_order = players.reverse()[0].in_game_order + 1
# update number of connected players
game.players_connected = len(players)
game.save()
player.save()
return player.id
def find_player(request):
if request.method == 'GET':
player_name = request.GET.get('player-name')
try:
player = Player.objects.get(name=player_name)
except ObjectDoesNotExist:
player = Player(name=player_name, color='R').save()
print("Player didn't exist, was created")
return JsonResponse(player)
def test_give_2(self):
"""
Give 2 cards to each active player if:
- game state = give 2
- each player have None cards
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='start')
player1.save()
player2 = Player(name=us2, state='start')
player2.save()
player3 = Player(name=us3, state='start')
player3.save()
player4 = Player(name=us4, state='out')
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='give_2')
table.fill_deck_by_all_cards()
# Act
table.give_2()
# Assertion
self.assertNotIn(player1.cards, table.deck)
self.assertNotIn(player2.cards, table.deck)
self.assertNotIn(player3.cards, table.deck)
self.assertEqual(player4.cards, None)
self.assertIsInstance(player1.cards, str)
self.assertIsInstance(player2.cards, str)
self.assertIsInstance(player3.cards, str)
self.assertEqual(table.game_state, 'give_2')
def test_take_big_blind(self):
"""
Take small blind from the next one from 'dealer player'
Big blind is always awarded if players in table > 1
- to the next player from the table.small_blind field
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='start')
player1.save()
player2 = Player(name=us2, state='start')
player2.save()
player3 = Player(name=us3, state='start')
player3.save()
player4 = Player(name=us4, state='start')
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='small_blind',
dealer=player1,
small_blind=player2)
# Act & Assertion
table.take_big_blind()
self.assertEqual(table.big_blind, player3)
table.game_state = 'small_blind'
table.dealer = player2
table.small_blind = player3
table.take_big_blind()
self.assertEqual(table.big_blind, player4)
def test_give_1_again(self):
"""
Give 1 card to the table if:
- game state = give 1 again
- on table is only 4 cards
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1)
player1.save()
player2 = Player(name=us2)
player2.save()
player3 = Player(name=us3)
player3.save()
player4 = Player(name=us4)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
game_state='give_3')
table.fill_deck_by_all_cards()
# Act
table.give_3()
table.next_game_state()
table.give_1()
table.next_game_state()
table.give_1_again()
# Assertion
self.assertNotIn(table.cards_on_table, table.deck)
self.assertIsInstance(table.cards_on_table, str)
self.assertEqual(table.game_state, 'give_1_again')
def test_all_players_with_start_state(self):
"""
Pre: Create table with 2 players with 'start' state
and 1 player with 'out' state
Output: List with players who have 'start' status
"""
# Arrange
player1 = Player(name=User(username='******'), state='start')
player2 = Player(name=User(username='******'), state='out')
player3 = Player(name=User(username='******'), state='start')
table = Table(player1=player1, player2=player2, player3=player3)
# Act
result = table.all_players_with_start_state()
to_compare = [player1, player3]
# Assertion
self.assertIsInstance(result, list)
self.assertEqual(result, to_compare)
def test_the_winner(self):
"""Return winner in this table"""
# Arrange
cards1 = str(Card.new('2s')) + ',' + str(Card.new('3s'))
cards2 = str(Card.new('4h')) + ',' + str(Card.new('5d'))
cards3 = str(Card.new('6d')) + ',' + str(Card.new('7h'))
cards4 = str(Card.new('As')) + ',' + str(Card.new('Ks'))
cards_on_table = str(Card.new('Qs')) + ',' \
+ str(Card.new('Js')) + ','\
+ str(Card.new('Ts')) + ','\
+ str(Card.new('2d')) + ','\
+ str(Card.new('3d'))
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, cards=cards1, state='check')
player1.save()
player2 = Player(name=us2, cards=cards2, state='check')
player2.save()
player3 = Player(name=us3, cards=cards3, state='check')
player3.save()
player4 = Player(name=us4, cards=cards4, state='check')
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4,
cards_on_table=cards_on_table)
# Act
the_winner = table.the_winner()
#print(the_winner)
# Assertion
self.assertEqual(the_winner, player4)
def add_player(self, nick: str, id: str) -> Player:
existing_player: Player = self.get_player_by_nick(nick)
if existing_player:
logging.info(
f"Player '{existing_player.nick}' reconnected with id '{id}'")
existing_player.reconnect(id)
return existing_player
new_player = Player(nick, id)
self.players.append(new_player)
self.waiting_room.join(new_player)
return new_player
def create_players(self, users):
"""Create a list of Player instances from a list of User
instances for testing."""
players = []
for i, user in enumerate(users):
player = Player(user=user, nickname=f'Swindle_{i}')
player.save()
players.append(player)
return players
def _create_game(nb_player=4, game_name='test'):
game = Game(name=game_name)
game.save()
user_names = ['Clément'] + ["bot_"+str(i) for i in range(nb_player-1)]
players = []
for user_name in user_names:
user = User(username=user_name)
user.save()
player = Player(user=user, game=game)
player.save()
players.append(player)
return game, players
def populate_players(self, faker: Faker):
teams = Team.objects.all()
for team in teams:
for i in range(10):
player = Player(id=str(uuid.uuid4()),
first_name=faker.first_name(),
last_name=faker.last_name(),
date_of_birth=faker.date(),
country=faker.country(),
height=round(decimal.Decimal(random.randrange(20000)) / 100, 2),
weight=round(decimal.Decimal(random.randrange(20000)) / 100, 2),
team=team)
player.save()
msg.good("Players data successfully populated")
def test_return_next(self):
"""
Pre: List with players, and start_player
Output: Player from list, next from start_player
"""
# Arrange
player1 = Player(name=User(username='******'))
player2 = Player(name=User(username='******'))
player3 = Player(name=User(username='******'))
player4 = Player(name=User(username='******'))
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
players_list = [player1, player2, player3, player4]
# Acts & Assertions
result = table.return_next(players_list, player4)
self.assertIsInstance(result, Player)
self.assertEqual(result, player1)
result = table.return_next(players_list, player1)
self.assertIsInstance(result, Player)
self.assertEqual(result, player2)
result = table.return_next(players_list, player2)
self.assertIsInstance(result, Player)
self.assertEqual(result, player3)
result = table.return_next(players_list, player3)
self.assertIsInstance(result, Player)
self.assertEqual(result, player4)
result = table.return_next(players_list, player4)
self.assertIsInstance(result, Player)
self.assertEqual(result, player1)
def test_set_all_in_game_players_state(self):
"""
Pre: Create table with players with different states.
Output: True if players without 'pass' or 'out' state have changed to
'start' state.
"""
# Arrange
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, state='pass')
player1.save()
player2 = Player(name=us2)
player2.save()
player3 = Player(name=us3, state='check')
player3.save()
player4 = Player(name=us4, state='start')
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
# Act
table.set_all_in_game_players_state('start')
# Assertion
self.assertEqual(table.player1.state, 'pass')
self.assertEqual(table.player2.state, 'out')
self.assertEqual(table.player3.state, 'start')
self.assertEqual(table.player4.state, 'start')
def test_remove_cards_from_players(self):
"""Remove all cards from all players"""
# Arrange
cards1 = str(Card.new('As')) + ',' + str(Card.new('9s'))
cards2 = str(Card.new('Ah')) + ',' + str(Card.new('9h'))
cards3 = str(Card.new('Ad')) + ',' + str(Card.new('9d'))
cards4 = str(Card.new('Ac')) + ',' + str(Card.new('9c'))
us1 = User(username='******')
us1.save()
us2 = User(username='******')
us2.save()
us3 = User(username='******')
us3.save()
us4 = User(username='******')
us4.save()
player1 = Player(name=us1, cards=cards1)
player1.save()
player2 = Player(name=us2, cards=cards2)
player2.save()
player3 = Player(name=us3, cards=cards3)
player3.save()
player4 = Player(name=us4, cards=cards4)
player4.save()
table = Table(player1=player1,
player2=player2,
player3=player3,
player4=player4)
# Act
table.remove_cards_from_players()
# Assertion
self.assertEqual(table.player1.cards, None)
self.assertEqual(table.player2.cards, None)
self.assertEqual(table.player3.cards, None)
self.assertEqual(table.player4.cards, None)
