def test_move_from_liverpool_to_london(self):
piece = models.Piece.objects.create(
game=self.game,
type=PieceType.ARMY,
nation=self.england,
)
liverpool = models.Territory.objects.get(id='standard-liverpool')
london = models.Territory.objects.get(id='standard-london')
models.PieceState.objects.create(
piece=piece,
territory=liverpool,
turn=self.turn,
)
order = models.Order.objects.create(
nation=self.england,
source=liverpool,
target=london,
turn=self.turn,
type=OrderType.MOVE,
)
process_turn(self.turn)
order.refresh_from_db()
self.assertTrue(order.illegal)
self.assertEqual(order.illegal_code,
ArmyMovesToAdjacentTerritoryNotConvoy.code)
self.assertEqual(order.illegal_verbose,
ArmyMovesToAdjacentTerritoryNotConvoy.message)
def update(self, instance, validated_data):
"""
Set nation's `orders_finalized` field. Process game if turn is ready.
"""
instance.orders_finalized = not (instance.orders_finalized)
instance.save()
if instance.turn.ready_to_process:
process_turn(instance.turn)
return instance
def handle(self, *args, **options):
slug = options['game']
self.noinput = options['no_input']
dry_run = options['dry_run']
try:
game = models.Game.objects.get(slug=slug)
except models.Game.DoesNotExist:
raise CommandError(
'Could not find a game with the slug "{}"'.format(slug))
if game.status != GameStatus.ACTIVE:
raise CommandError('Cannot advance turn on an inactive game')
turn = game.get_current_turn()
if turn.game.status != GameStatus.ACTIVE:
raise CommandError('Cannot restore turn if game is not active.')
if not turn.ready_to_process:
self.stdout.write('Not all nations have finalized their orders\n')
self.prompt()
result = process_turn(turn, dry_run)
if dry_run:
pretty_output = json.dumps(result, sort_keys=True, indent=4)
self.stdout.write(pretty_output)
def test_disband(self):
self.turn.phase = Phase.BUILD
self.turn.save()
piece = models.Piece.objects.create(
game=self.game,
type=PieceType.ARMY,
nation=self.russia,
)
piece_state = models.PieceState.objects.create(
piece=piece,
territory=self.st_petersburg,
turn=self.turn,
must_retreat=True,
)
order_st_petersburg = models.Order.objects.create(
nation=self.russia,
source=self.st_petersburg,
turn=self.turn,
type=OrderType.DISBAND,
)
new_turn = process_turn(self.turn)
order_st_petersburg.refresh_from_db()
piece.refresh_from_db()
piece_state.refresh_from_db()
self.assertEqual(order_st_petersburg.outcome, OutcomeType.SUCCEEDS)
self.assertTrue(piece.turn_disbanded, self.turn)
self.assertEqual(new_turn.piecestates.count(), 0)
def test_no_order_removes_piece(self):
self.turn.phase = Phase.RETREAT
self.turn.save()
st_petersburg_state = models.TerritoryState.objects.get(
territory=self.st_petersburg)
st_petersburg_state.contested = True
st_petersburg_state.save()
piece = models.Piece.objects.create(
game=self.game,
type=PieceType.ARMY,
nation=self.russia,
)
piece_state = models.PieceState.objects.create(
piece=piece,
territory=self.norway,
turn=self.turn,
must_retreat=True,
)
new_turn = process_turn(self.turn)
piece.refresh_from_db()
piece_state.refresh_from_db()
self.assertTrue(piece_state.destroyed)
self.assertTrue(piece.turn_destroyed, self.turn)
self.assertEqual(new_turn.piecestates.count(), 0)
def test_contested_retreat_removes_piece(self):
self.turn.phase = Phase.RETREAT
self.turn.save()
st_petersburg_state = models.TerritoryState.objects.get(
territory=self.st_petersburg)
st_petersburg_state.contested = True
st_petersburg_state.save()
piece = models.Piece.objects.create(
game=self.game,
type=PieceType.ARMY,
nation=self.russia,
)
piece_state = models.PieceState.objects.create(
piece=piece,
territory=self.norway,
turn=self.turn,
must_retreat=True,
)
order = models.Order.objects.create(
nation=self.russia,
source=self.norway,
target=self.st_petersburg,
turn=self.turn,
type=OrderType.RETREAT,
)
new_turn = process_turn(self.turn)
order.refresh_from_db()
piece.refresh_from_db()
piece_state.refresh_from_db()
self.assertTrue(order.illegal)
self.assertEqual(order.outcome, OutcomeType.FAILS)
self.assertTrue(piece_state.destroyed)
self.assertTrue(piece.turn_destroyed, self.turn)
self.assertEqual(new_turn.piecestates.count(), 0)
def test_turkey_does_not_take_bulgaria(self):
self.turn.season = Season.FALL
self.turn.save()
piece = models.Piece.objects.create(
game=self.game,
type=PieceType.ARMY,
nation=self.turkey,
)
bulgaria = models.Territory.objects.get(id='standard-bulgaria')
greece = models.Territory.objects.get(id='standard-greece')
models.PieceState.objects.create(
piece=piece,
territory=bulgaria,
turn=self.turn,
)
order = models.Order.objects.create(
nation=self.turkey,
source=bulgaria,
target=greece,
turn=self.turn,
type=OrderType.MOVE,
)
new_turn = process_turn(self.turn)
order.refresh_from_db()
self.assertFalse(order.illegal)
old_bulgaria_state = self.turn.territorystates.get(territory=bulgaria)
new_bulgaria_state = new_turn.territorystates.get(territory=bulgaria)
self.assertIsNone(old_bulgaria_state.captured_by)
self.assertIsNone(new_bulgaria_state.controlled_by)
def test_basic_move(self):
turn = models.Turn.objects.create(
game=self.game,
season=Season.SPRING,
phase=Phase.ORDER,
year=1900,
)
france = models.Nation.objects.create(
variant=self.variant,
name='France',
)
self.create_test_nation_state(nation=france, turn=turn, user=self.user)
paris = models.Territory.objects.create(
variant=self.variant,
name='Paris',
nationality=france,
supply_center=True,
type=TerritoryType.INLAND,
)
models.TerritoryState.objects.create(
territory=paris,
turn=turn,
controlled_by=france,
)
picardy = models.Territory.objects.create(
variant=self.variant,
name='Picardy',
nationality=france,
type=TerritoryType.COASTAL,
)
models.TerritoryState.objects.create(
territory=picardy,
turn=turn,
controlled_by=france,
)
army_paris = models.Piece.objects.create(
game=self.game,
nation=france,
)
models.PieceState.objects.create(
piece=army_paris,
turn=turn,
territory=paris,
)
paris.neighbours.add(picardy)
models.Order.objects.create(
turn=turn,
nation=france,
type=OrderType.MOVE,
source=paris,
target=picardy,
)
new_turn = process_turn(turn)
self.assertEqual(new_turn.year, 1900)
self.assertEqual(new_turn.phase, Phase.ORDER)
self.assertEqual(new_turn.season, Season.FALL)
piece_state = new_turn.piecestates.get()
self.assertEqual(piece_state.territory, picardy)
def test_move_st_petersburg_north_coast_to_norway(self):
piece = models.Piece.objects.create(
game=self.game,
type=PieceType.FLEET,
nation=self.russia,
)
models.PieceState.objects.create(
named_coast=self.st_petersburg_north_coast,
piece=piece,
territory=self.st_petersburg,
turn=self.turn,
)
order = models.Order.objects.create(
nation=self.russia,
source=self.st_petersburg,
target=self.norway,
turn=self.turn,
type=OrderType.MOVE,
)
process_turn(self.turn)
order.refresh_from_db()
self.assertFalse(order.illegal)
def test_move_st_petersburg_south_coast_to_gulf_of_bothnia(self):
piece = models.Piece.objects.create(
game=self.game,
type=PieceType.FLEET,
nation=self.russia,
)
gulf_of_bothnia = models.Territory.objects.get(
id='standard-gulf-of-bothnia')
models.PieceState.objects.create(
named_coast=self.st_petersburg_south_coast,
piece=piece,
territory=self.st_petersburg,
turn=self.turn,
)
order = models.Order.objects.create(
nation=self.russia,
source=self.st_petersburg,
target=gulf_of_bothnia,
turn=self.turn,
type=OrderType.MOVE,
)
process_turn(self.turn)
order.refresh_from_db()
self.assertFalse(order.illegal)
def test_processed(self):
new_turn = process_turn(self.turn)
# Test turn
self.assertEqual(new_turn.season, Season.FALL)
self.assertEqual(new_turn.phase, Phase.ORDER)
self.assertEqual(new_turn.year, 1901)
self.assertEqual(new_turn.processed, False)
self.assertEqual(new_turn.processed_at, None)
self.assertEqual(new_turn.current_turn, True)
# Test nation states
for nation_state in new_turn.nationstates.all():
old_nation_state = self.turn.nationstates.get(
nation=nation_state.nation)
# All users have been copied over correctly
self.assertEqual(nation_state.user, old_nation_state.user)
# orders_finailzed set to False
self.assertFalse(nation_state.orders_finalized)
def test_build_fleet_st_petersburg_north_coast(self):
self.turn.season = Season.FALL
self.turn.phase = Phase.BUILD
self.turn.save()
models.TerritoryState.objects.create(
controlled_by=self.russia,
territory=self.st_petersburg,
turn=self.turn,
)
order = models.Order.objects.create(
nation=self.russia,
source=self.st_petersburg,
piece_type=PieceType.FLEET,
target_coast=self.st_petersburg_north_coast,
turn=self.turn,
type=OrderType.BUILD,
)
new_turn = process_turn(self.turn)
order.refresh_from_db()
self.assertFalse(order.illegal)
new_turn.piecestates.get(territory=self.st_petersburg,
named_coast=self.st_petersburg_north_coast,
piece__nation=self.russia)
def test_bounce_occured(self):
user = User.objects.create(username='******')
variant = models.Variant.objects.create(name='standard')
game = models.Game.objects.create(
variant=variant,
name='Test Game',
description='Test Description',
status=GameStatus.ACTIVE,
num_players=7,
created_by=user,
)
turn = models.Turn.objects.create(
game=game,
season=Season.SPRING,
phase=Phase.ORDER,
year=1900,
)
france = models.Nation.objects.create(
variant=variant,
name='France',
)
self.create_test_nation_state(nation=france, turn=turn, user=user)
paris = models.Territory.objects.create(
variant=variant,
name='Paris',
nationality=france,
supply_center=True,
type=TerritoryType.INLAND,
)
models.TerritoryState.objects.create(
territory=paris,
turn=turn,
controlled_by=france,
)
picardy = models.Territory.objects.create(
variant=variant,
name='Picardy',
nationality=france,
supply_center=False,
type=TerritoryType.COASTAL,
)
models.TerritoryState.objects.create(
territory=picardy,
turn=turn,
controlled_by=france,
)
burgundy = models.Territory.objects.create(
variant=variant,
name='Burgundy',
nationality=france,
supply_center=False,
type=TerritoryType.COASTAL,
)
burgundy_state = models.TerritoryState.objects.create(
territory=burgundy,
turn=turn,
controlled_by=france,
)
army_paris = models.Piece.objects.create(
game=game,
nation=france,
)
models.PieceState.objects.create(
piece=army_paris,
turn=turn,
territory=paris,
)
army_picardy = models.Piece.objects.create(
game=game,
nation=france,
)
models.PieceState.objects.create(
piece=army_picardy,
turn=turn,
territory=picardy,
)
paris_order = models.Order.objects.create(
turn=turn,
nation=france,
type=OrderType.MOVE,
source=paris,
target=burgundy,
)
picardy_order = models.Order.objects.create(
turn=turn,
nation=france,
type=OrderType.MOVE,
source=picardy,
target=burgundy,
)
paris.neighbours.add(picardy)
picardy.neighbours.add(burgundy)
paris.neighbours.add(burgundy)
process_turn(turn)
burgundy_state.refresh_from_db()
paris_order.refresh_from_db()
picardy_order.refresh_from_db()
turn.refresh_from_db()
self.assertTrue(turn.processed)
self.assertTrue(burgundy_state.bounce_occurred)
self.assertEqual(paris_order.outcome, OutcomeType.FAILS)
self.assertEqual(picardy_order.outcome, OutcomeType.FAILS)
def test_process_turn(self):
user = User.objects.create(username='******')
variant = models.Variant.objects.create(name='standard')
game = models.Game.objects.create(
variant=variant,
name='Test Game',
description='Test Description',
status=GameStatus.ACTIVE,
num_players=7,
created_by=user,
)
turn = models.Turn.objects.create(
game=game,
season=Season.SPRING,
phase=Phase.ORDER,
year=1900,
)
france = models.Nation.objects.create(
variant=variant,
name='France',
)
self.create_test_nation_state(nation=france, turn=turn, user=user)
paris = models.Territory.objects.create(
variant=variant,
name='Paris',
nationality=france,
supply_center=True,
type=TerritoryType.INLAND,
)
models.TerritoryState.objects.create(
territory=paris,
turn=turn,
controlled_by=france,
)
picardy = models.Territory.objects.create(
variant=variant,
name='Picardy',
nationality=france,
type=TerritoryType.COASTAL,
)
models.TerritoryState.objects.create(
territory=picardy,
turn=turn,
controlled_by=france,
)
army_paris = models.Piece.objects.create(
game=game,
nation=france,
)
models.PieceState.objects.create(
piece=army_paris,
turn=turn,
territory=paris,
)
paris.neighbours.add(picardy)
order = models.Order.objects.create(
turn=turn,
nation=france,
type=OrderType.MOVE,
source=paris,
target=picardy,
)
from core.serializers import TurnSerializer
game_state_dict = TurnSerializer(turn).data
expected_keys = [
'orders', 'territories', 'named_coasts', 'pieces', 'phase',
'variant'
]
self.assertTrue(
all([e in game_state_dict.keys() for e in expected_keys]))
self.assertEqual(len(game_state_dict['territories']), 2)
self.assertEqual(len(game_state_dict['pieces']), 1)
self.assertEqual(len(game_state_dict['named_coasts']), 0)
self.assertEqual(game_state_dict['variant'], 'standard')
process_turn(turn)
turn.refresh_from_db()
self.assertTrue(turn.processed)
order.refresh_from_db()
self.assertEqual(order.outcome, OutcomeType.SUCCEEDS)
def test_retreat_rome_not_auto_destroy(self):
self.turn.phase = Phase.ORDER
self.turn.save()
army_rome = self.turn.piecestates.create(
piece=models.Piece.objects.create(game=self.game,
nation=self.austria,
type=PieceType.ARMY),
territory=self.rome,
)
self.turn.piecestates.create(
piece=models.Piece.objects.create(game=self.game,
nation=self.italy,
type=PieceType.ARMY),
territory=self.naples,
)
self.turn.piecestates.create(
piece=models.Piece.objects.create(game=self.game,
nation=self.italy,
type=PieceType.FLEET),
territory=self.tyrrhenian_sea,
)
self.turn.piecestates.create(
piece=models.Piece.objects.create(game=self.game,
nation=self.austria,
type=PieceType.ARMY),
territory=self.tuscany,
)
self.turn.piecestates.create(
piece=models.Piece.objects.create(game=self.game,
nation=self.austria,
type=PieceType.FLEET),
territory=self.apulia,
)
self.turn.piecestates.create(
piece=models.Piece.objects.create(game=self.game,
nation=self.austria,
type=PieceType.FLEET),
territory=self.venice,
)
self.turn.orders.create(
nation=self.austria,
source=self.apulia,
target=self.adriatic_sea,
type=OrderType.MOVE,
)
self.turn.orders.create(
nation=self.austria,
source=self.rome,
type=OrderType.HOLD,
)
self.turn.orders.create(
nation=self.austria,
source=self.venice,
type=OrderType.HOLD,
)
self.turn.orders.create(
nation=self.italy,
source=self.tuscany,
target=self.piedmont,
type=OrderType.MOVE,
)
self.turn.orders.create(
nation=self.italy,
source=self.apulia,
target=self.rome,
type=OrderType.MOVE,
)
self.turn.orders.create(
nation=self.italy,
source=self.tyrrhenian_sea,
target=self.rome,
aux=self.naples,
type=OrderType.SUPPORT,
)
process_turn(self.turn)
army_rome.refresh_from_db()
self.assertFalse(army_rome.destroyed)
self.assertIsNone(army_rome.destroyed_message)
