def test_no_rsource(self):
brick = Resource.objects.filter(id=1)
brick.get().delete()
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
"type": "bank_trade",
"payload": {
"give": "brick",
"receive": "wool"
}
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_game_info(1)
response_player = self.get_player_info(1)
assert len(response_player.data['resources']) < 4
assert response_game.data['players'][0]['resources_cards'] < 4
assert response.data == {
"detail": "It does not have" + " the necessary resources"
}
assert response.status_code == 403
def test_build_road(self):
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
"type": "build_road",
"payload": [{
"level": 2,
"index": 1
}, {
"level": 2,
"index": 2
}]
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_game_info(1)
response_player = self.get_player_info(1)
assert response.status_code == 200
assert response_player.data['resources'] == []
assert response_game.data['players'][0]['resources_cards'] == 0
assert response_game.data['players'][0]['roads'][0][0]['level'] == 2
assert response_game.data['players'][0]['roads'][0][0]['index'] == 0
assert response_game.data['players'][0]['roads'][0][1]['level'] == 2
assert response_game.data['players'][0]['roads'][0][1]['index'] == 1
assert response_game.data['players'][0]['roads'][1][0]['level'] == 2
assert response_game.data['players'][0]['roads'][1][0]['index'] == 1
assert response_game.data['players'][0]['roads'][1][1]['level'] == 2
assert response_game.data['players'][0]['roads'][1][1]['index'] == 2
assert len(response_game.data['players'][0]['roads']) == 2
def test_get_robber_positions_no_card(self):
self.createGame()
current_turn = mixer.blend(Current_Turn,
user=self.user1,
game=self.game,
dices1=1,
dices2=3,
game_stage='FULL_PLAY')
Building.objects.create(game=self.game,
owner=self.player1,
name='city',
level=2,
index=5)
Building.objects.create(game=self.game,
owner=self.player2,
name='city',
level=1,
index=17)
path = reverse('PlayerActions', kwargs={'pk': 1})
request = RequestFactory().get(path)
force_authenticate(request, user=self.user1, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
assert response.data == [{"type": "end_turn"}]
assert response.status_code == 200
def test_nothing_built(self):
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
"type": "build_road",
"payload": [{
"level": 2,
"index": 1
}, {
"level": 2,
"index": 2
}]
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
self.road.delete()
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_game_info(1)
response_player = self.get_player_info(1)
assert len(response_player.data['resources']) == 2
assert response_game.data['players'][0]['roads'] == []
assert response.data == {'detail': 'You must have something built'}
assert response.status_code == 403
assert response_game.data['players'][0]['resources_cards'] == 2
def test_game_not_in_turn(self):
robber = mixer.blend('catan.Hexe', level=1, index=2)
board = Board.objects.create(name='Colonos')
game_1 = Game.objects.create(name='Juego', board=board, robber=robber)
user_2 = mixer.blend(User, username='******', password='******')
player1 = mixer.blend('catan.Player',
username=self.user,
game=game_1,
colour='yellow',
development_cards=1,
resources_cards=2,
turn=1)
player2 = mixer.blend('catan.Player',
username=user_2,
game=game_1,
colour='green',
development_cards=1,
resources_cards=2,
turn=2)
current_turn = mixer.blend('catan.Current_Turn',
game=game_1,
user=user_2)
path = reverse('PlayerActions', kwargs={'pk': 1})
request = RequestFactory().get(path)
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
assert response.data == []
assert response.status_code == 200
def test_winner_city(self):
self.resources_for_city()
build = mixer.blend('catan.Building',
game=self.game,
name='settlement',
owner=self.player,
level=2,
index=26)
self.player.gain_points(9)
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {"type": "upgrade_city", "payload": {"level": 2, "index": 26}}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_info_game(1)
response_player = self.get_info_player(1)
assert response_player.data['resources'] == ['brick', 'lumber', 'wool']
assert response_game.data['players'][0]['settlements'] == []
assert response_game.data['players'][0]['cities'] == [{
"level": 2,
"index": 26
}]
assert response_game.data['winner'] == 'test_user'
assert response_game.data['players'][0]['victory_points'] == 10
assert response.data == {'detail': 'YOU WIN!!!'}
assert response.status_code == 200
def test_road_building_card_one_road(self):
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {"type": "play_road_building_card",
"payload": [[{"level": 2, "index": 1},
{"level": 2, "index": 2}],
[{"level": 2, "index": 2},
{"level": 2, "index": 1000}]]}
request = RequestFactory().post(path, data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
path_game = reverse('GameInfo', kwargs={'pk': 1})
request_game = RequestFactory().get(path_game)
force_authenticate(request_game, user=self.user, token=self.token)
view_game = GameInfo.as_view()
response_game = view_game(request_game, pk=1)
assert len(response_game.data['players'][0]['roads']) == 1
expected_data = [
[{'level': 2, 'index': 0},
{'level': 2, 'index': 1}]
]
assert response_game.data['players'][0]['roads'] == expected_data
assert response_game.data['players'][0]['development_cards'] == 1
assert response.data == {'detail': 'Non-existent vertexs positions'}
assert response.status_code == 403
def test_no_time_for_build_city(self):
self.turn.game_stage = 'FIRST_CONSTRUCTION'
self.turn.last_action = 'BUILD_SETTLEMENT'
self.turn.save()
self.player.gain_points(1)
build = mixer.blend('catan.Building',
game=self.game,
name='settlement',
owner=self.player,
level=1,
index=16)
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {"type": "upgrade_city", "payload": {"level": 1, "index": 16}}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
self.grain.delete()
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_info_game(1)
response_player = self.get_info_player(1)
assert len(response_player.data['resources']) < 4
assert response_game.data['players'][0]['settlements'] == [{
'level': 1,
'index': 16
}]
assert response_game.data['players'][0]['victory_points'] == 1
assert response.data == {
"detail": "You cannot construct at this momment"
}
assert response.status_code == 403
def test_winner_settlement(self):
self.player.gain_points(9)
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
"type": "build_settlement",
"payload": {
"level": 2,
"index": 26
}
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_info_game(1)
response_player = self.get_info_player(1)
assert response_player.data['resources'] == []
assert response_game.data['players'][0]['settlements'][0]['level'] == 2
assert response_game.data['players'][0]['settlements'][0][
'index'] == 26
assert response_game.data['winner'] == 'test_user'
assert response_game.data['players'][0]['victory_points'] == 10
assert response.data == {'detail': 'YOU WIN!!!'}
assert response.status_code == 200
def test_no_resource_city(self):
build = mixer.blend('catan.Building',
game=self.game,
name='settlement',
owner=self.player,
level=1,
index=16)
self.player.gain_points(1)
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {"type": "upgrade_city", "payload": {"level": 1, "index": 16}}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_info_game(1)
response_player = self.get_info_player(1)
assert len(response_player.data['resources']) == 4
assert response_game.data['players'][0]['settlements'] == [{
'level': 1,
'index': 16
}]
assert response_game.data['players'][0]['cities'] == []
assert response_game.data['players'][0]['victory_points'] == 1
assert response.data == {
"detail": "It does not have" + "the necessary resources"
}
assert response.status_code == 403
def test_no_resource_settlement(self):
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
"type": "build_settlement",
"payload": {
"level": 2,
"index": 26
}
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
self.grain.delete()
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_info_game(1)
response_player = self.get_info_player(1)
assert len(response_player.data['resources']) < 4
assert response_game.data['players'][0]['settlements'] == []
assert response_game.data['players'][0]['victory_points'] == 0
assert response.data == {
"detail": "It does not have" + "the necessary resources"
}
assert response.status_code == 403
def test_busy_position(self):
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
"type": "build_settlement",
"payload": {
"level": 2,
"index": 26
}
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
build = mixer.blend('catan.Building',
game=self.game,
name='city',
owner=self.player,
level=2,
index=26)
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_info_game(1)
response_player = self.get_info_player(1)
assert len(response_player.data['resources']) == 4
assert response_game.data['players'][0]['settlements'] == []
assert response_game.data['players'][0]['victory_points'] == 0
assert response.data == {"detail": "Busy position"}
assert response.status_code == 403
def test_actions_not_in_turn(self):
self.createGame()
self.current_turn = mixer.blend(Current_Turn,
user=self.user2,
game=self.game,
dices1=4,
dices2=3)
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
'type': 'move_robber',
'payload': {
'position': {
'level': 2,
'index': 10
},
'player': ''
}
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user1, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_game_info(1)
response_player = self.get_player_info(1)
assert response_player.data['resources'] == []
assert response_player.data['cards'] == []
assert response_game.data['players'][0]['development_cards'] == 0
assert response_game.data['robber'] == {'level': 1, 'index': 0}
assert response.status_code == 403
assert response.data == {"detail": "Not in turn"}
def test_no_have_knight_cards(self):
self.createGame()
self.current_turn = mixer.blend(Current_Turn,
user=self.user1,
game=self.game)
mixer.blend('catan.Hexe',
terrain='ore',
token=2,
board=self.board,
level=2,
index=10)
building1 = Building.objects.create(name="settlement",
game=self.game,
owner=self.player2,
level=2,
index=26)
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
'type': 'play_knight_card',
'payload': {
'position': {
'level': 2,
'index': 10
},
'player': ''
}
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user1, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
assert response.status_code == 403
assert response.data == {"detail": "You have not knight cards"}
def test_no_card(self):
self.cardRoad.delete()
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {"type": "play_road_building_card",
"payload": [[{"level": 2, "index": 1},
{"level": 2, "index": 2}],
[{"level": 2, "index": 2},
{"level": 2, "index": 3}]]}
request = RequestFactory().post(path, data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
path_game = reverse('GameInfo', kwargs={'pk': 1})
request_game = RequestFactory().get(path_game)
force_authenticate(request_game, user=self.user, token=self.token)
view_game = GameInfo.as_view()
response_game = view_game(request_game, pk=1)
response_player = self.get_info_player(1)
assert response_player.data['cards'] == []
expected_data = [
[{'level': 2, 'index': 0},
{'level': 2, 'index': 1}]
]
assert response_game.data['players'][0]['roads'] == expected_data
assert response_game.data['players'][0]['development_cards'] == 0
assert response.data == {'detail': 'Missing Road Building card'}
assert response.status_code == 403
def test_not_turn(self):
user = User.objects.create_user(username='******', email='bariloche')
self.turn.user = user
self.turn.save()
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
"type": "build_road",
"payload": [{
"level": 2,
"index": 1
}, {
"level": 2,
"index": 2
}]
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_game_info(1)
response_player = self.get_player_info(1)
assert len(response_player.data['resources']) == 2
assert len(response_game.data['players'][0]['roads']) == 1
assert response.data == {"detail": "Not in turn"}
assert response.status_code == 403
def test_not_resource(self):
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
"type": "build_road",
"payload": [{
"level": 2,
"index": 1
}, {
"level": 2,
"index": 2
}]
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
self.brick.delete()
self.lumber.delete()
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_game_info(1)
response_player = self.get_player_info(1)
assert len(response_player.data['resources']) == 0
assert len(response_game.data['players'][0]['roads']) == 1
assert response.data == {'detail': "Doesn't have enough resources"}
assert response.status_code == 403
def test_actions_not_in_turn(self):
self.createGame()
self.current_turn = mixer.blend('catan.Current_Turn',
user=self.user2,
game=self.game)
card = Card.objects.create(owner=self.player1,
game=self.game,
name='knight')
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
'type': 'play_knight_card',
'payload': {
'position': {
'level': 2,
'index': 10
},
'player': ''
}
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user1, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
assert response.status_code == 403
assert response.data == {"detail": "Not in turn"}
def test_get_with_resource_1(self):
path = reverse('PlayerActions', kwargs={'pk': 1})
request = RequestFactory().get(path)
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
expected_data = {
'type':
'build_road',
'payload': [[{
'level': 2,
'index': 0
}, {
'level': 2,
'index': 29
}], [{
'level': 2,
'index': 1
}, {
'level': 1,
'index': 1
}], [{
'level': 2,
'index': 1
}, {
'level': 2,
'index': 2
}]],
}
assert expected_data in response.data
assert response.status_code == 200
def test_no_turn_city(self):
self.resources_for_city()
new_user = mixer.blend(User, username='******', email='matilde13')
build = mixer.blend('catan.Building',
game=self.game,
name='settlement',
owner=self.player,
level=1,
index=16)
self.turn.user = new_user
self.turn.save()
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {"type": "upgrade_city", "payload": {"level": 1, "index": 16}}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_info_game(1)
response_player = self.get_info_player(1)
assert len(response_player.data['resources']) == 8
assert response_game.data['players'][0]['settlements'] == [{
'level': 1,
'index': 16
}]
assert response_game.data['players'][0]['victory_points'] == 0
assert response.data == {"detail": "Not in turn"}
assert response.status_code == 403
def test_position_invalid(self):
self.createGame()
self.current_turn = mixer.blend(Current_Turn,
user=self.user1,
game=self.game,
dices1=4,
dices2=3)
card = Card.objects.create(owner=self.player1,
game=self.game,
name='knight')
mixer.blend('catan.Hexe',
terrain='ore',
token=2,
board=self.board,
level=2,
index=10)
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
'type': 'play_knight_card',
'payload': {
'position': {
'level': 6,
'index': 10
},
'player': ''
}
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user1, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
assert response.status_code == 403
assert response.data == {"detail": "There is no hexe in that position"}
def test_player_without_buildings(self):
self.createGame()
self.current_turn = mixer.blend(Current_Turn,
user=self.user1,
game=self.game)
building1 = Building.objects.create(name="settlement",
game=self.game,
owner=self.player2,
level=2,
index=26)
building2 = Building.objects.create(name="settlement",
game=self.game,
owner=self.player3,
level=1,
index=15)
Card.objects.create(owner=self.player1, game=self.game, name='knight')
mixer.blend('catan.Hexe',
terrain='ore',
token=2,
board=self.board,
level=2,
index=10)
resources = Resource.objects.create(owner=self.player2,
game=self.game,
name='ore')
resources = Resource.objects.create(owner=self.player3,
game=self.game,
name='lumber')
resources = Resource.objects.create(owner=self.player2,
game=self.game,
name='brick')
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
'type': 'play_knight_card',
'payload': {
'position': {
'level': 2,
'index': 10
},
'player': 'user4'
}
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user1, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_game_info(1)
response_player = self.get_player_info(1)
assert response_player.data['resources'] == []
assert response_player.data['cards'] == ['knight']
assert response_game.data['players'][0]['development_cards'] == 1
assert response_game.data['robber'] == {'level': 1, 'index': 0}
assert response.status_code == 403
assert response.data == {
"detail": "You have to choose a player that has buildings"
}
def test_get_bank_trade(self):
path = reverse('PlayerActions', kwargs={'pk': 1})
request = RequestFactory().get(path)
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
assert {"type": 'buy_card'} in response.data
assert response.status_code == 200
def test_move_robber_more_buildings(self):
self.createGame()
self.current_turn = mixer.blend(Current_Turn,
user=self.user1,
game=self.game,
dices1=4,
dices2=3)
building1 = Building.objects.create(name="settlement",
game=self.game,
owner=self.player2,
level=2,
index=26)
building2 = Building.objects.create(name="settlement",
game=self.game,
owner=self.player3,
level=1,
index=15)
mixer.blend('catan.Hexe',
terrain='ore',
token=2,
board=self.board,
level=2,
index=10)
resources = Resource.objects.create(owner=self.player2,
game=self.game,
name='ore')
resources = Resource.objects.create(owner=self.player3,
game=self.game,
name='lumber')
resources = Resource.objects.create(owner=self.player2,
game=self.game,
name='brick')
path = reverse('PlayerActions', kwargs={'pk': 1})
data = {
'type': 'move_robber',
'payload': {
'position': {
'level': 2,
'index': 10
},
'player': 'user2'
}
}
request = RequestFactory().post(path,
data,
content_type='application/json')
force_authenticate(request, user=self.user1, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
response_game = self.get_game_info(1)
response_player = self.get_player_info(1)
gain_ore = 'ore' in response_player.data['resources']
gain_brick = 'brick' in response_player.data['resources']
assert gain_ore or gain_brick
assert response_player.data['cards'] == []
assert response_game.data['players'][0]['development_cards'] == 0
assert response_game.data['robber'] == {'level': 2, 'index': 10}
assert response.status_code == 204
def test_get_no_card(self):
url = reverse('PlayerActions', kwargs={'pk': 1})
request = RequestFactory().get(url)
force_authenticate(request, user=self.user, token=self.token)
self.cardRoad.delete()
view = PlayerActions.as_view()
response = view(request, pk=1)
assert response.data == [{'type': 'end_turn'}]
assert response.status_code == 200
def test_get_cities_no_settl(self):
self.resources_for_city()
self.delete_resources_settl()
path = reverse('PlayerActions', kwargs={'pk': 1})
request = RequestFactory().get(path)
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
assert response.data == [{'type': 'end_turn'}]
assert response.status_code == 200
def test_get_end_turn_second_stage(self):
self.turn.game_stage = 'SECOND_CONSTRUCTION'
self.turn.last_action = 'BUILD_ROAD'
self.turn.save()
url = reverse('PlayerActions', kwargs={'pk': 1})
request = RequestFactory().get(url)
force_authenticate(request, user=self.user1, token=self.token)
view_actions = PlayerActions.as_view()
response = view_actions(request, pk=1)
assert response.status_code == 200
assert response.data == [{"type": 'end_turn'}]
def test_get_with_card_1(self):
"""
This test delete the only road existent
"""
self.road.delete()
path = reverse('PlayerActions', kwargs={'pk': 1})
request = RequestFactory().get(path)
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
assert response.data == [{'type': 'end_turn'}]
assert response.status_code == 200
def test_get_monopoly_not_card(self):
self.createGame()
self.current_turn = mixer.blend(Current_Turn,
user=self.user1,
game=self.game,
dices1=4,
dices2=1)
path = reverse('PlayerActions', kwargs={'pk': 1})
request = RequestFactory().get(path)
force_authenticate(request, user=self.user1, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
assert [{"type": 'end_turn'}] == response.data
assert response.status_code == 200
def test_get_initial_road_2(self):
self.lumber.delete()
self.brick.delete()
self.road.delete()
self.turn.game_stage = 'SECOND_CONSTRUCTION'
self.turn.last_action = 'BUILD_SETTLEMENT'
self.turn.save()
mixer.blend('catan.Building',
name='settlement',
level=1,
index=16,
owner=self.player,
game=self.game)
mixer.blend('catan.Building',
name='settlement',
level=1,
index=5,
owner=self.player,
game=self.game)
path = reverse('PlayerActions', kwargs={'pk': 1})
request = RequestFactory().get(path)
force_authenticate(request, user=self.user, token=self.token)
view = PlayerActions.as_view()
response = view(request, pk=1)
expected_data = {
'payload': [[{
'index': 5,
'level': 1
}, {
'index': 4,
'level': 1
}], [{
'index': 5,
'level': 1
}, {
'index': 6,
'level': 1
}], [{
'index': 5,
'level': 1
}, {
'index': 9,
'level': 2
}]],
'type':
'build_road'
}
assert expected_data == response.data[0]
assert response.status_code == 200
