async def test_play_sniper_rifle_zombie_in_city_and_shelter(gs, zombie, big_zombie):
gs.active_player = PlayerShelter(print_foo=dumper_factory(), input_foo=helper_factory(['y']))
shelter = gs.active_player
shelter.zombies = [big_zombie, zombie]
gs.city_deck = [zombie, CityCard()]
shelter.supplies = [Supply.SNIPER]
await weapons.play_sniper_rifle(gs)
assert len(gs.city_deck) == 1
assert len(shelter.zombies) == 2
assert zombie not in gs.city_deck
assert len(shelter.supplies) == 0
assert len(gs.supply_graveyard) == 1
assert len(gs.city_graveyard) == 1
assert len(tests.common.outputs) == 3
gs.active_player = PlayerShelter(print_foo=dumper_factory(), input_foo=helper_factory(['n', '0']))
shelter = gs.active_player
shelter.zombies = [big_zombie, zombie]
gs.city_deck = [zombie, CityCard()]
shelter.supplies = [Supply.SNIPER]
await weapons.play_sniper_rifle(gs)
assert len(gs.city_deck) == 2
assert len(shelter.zombies) == 1
assert big_zombie not in shelter.zombies
assert zombie in gs.city_deck
assert len(shelter.supplies) == 0
assert len(gs.supply_graveyard) == 2
assert len(gs.city_graveyard) == 2
assert len(tests.common.outputs) == 2
async def test_play_round_end_round_one_shelter_destroyed(zombie):
gs = GameState()
gs.players = [PlayerShelter('0'), PlayerShelter('1'), PlayerShelter('2')]
gs.supply_deck = [
Supply.AXE, Supply.AXE, Supply.AXE, Supply.AXE, Supply.AXE, Supply.AXE
]
for player in gs.players:
player.survivors = [CityCard()]
gs.players[0].zombies = [zombie]
gs.active_player = gs.players[0]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['3', '3'])
shelter.survivors = [CityCard()]
shelter.supplies = [Supply.AXE, Supply.BARRICADES, Supply.ALARM]
await gs.play_round()
assert len(shelter.supplies) == 0
assert shelter.defeated
assert gs.active_player != shelter
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['3', '3'])
await gs.play_round()
assert len(shelter.supplies) == 3
assert not shelter.defeated
assert gs.active_player != shelter
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['3', '3'])
await gs.play_round()
assert len(shelter.supplies) == 3
assert not shelter.defeated
assert gs.active_player != shelter
async def test_play_flare_gun(gs):
shelter = gs.active_player
gs.city_deck = [CityCard()]
shelter.supplies = [Supply.FLARE_GUN]
await summons.play_flare_gun(gs)
assert len(shelter.survivors) == 1
assert len(shelter.supplies) == 0
assert len(gs.city_deck) == 0
assert len(gs.supply_graveyard) == 1
assert len(tests.common.outputs) == 5
gs.active_player = PlayerShelter(print_foo=dumper_factory())
shelter = gs.active_player
gs.city_deck = [CityCard(), CityCard()]
shelter.supplies = [Supply.FLARE_GUN]
await summons.play_flare_gun(gs)
assert len(shelter.survivors) == 2
assert len(shelter.supplies) == 0
assert len(gs.city_deck) == 0
assert len(gs.supply_graveyard) == 2
assert len(tests.common.outputs) == 5
gs.active_player = PlayerShelter(print_foo=dumper_factory())
shelter = gs.active_player
gs.city_deck = []
shelter.supplies = [Supply.FLARE_GUN]
await summons.play_flare_gun(gs)
assert len(shelter.survivors) == 0
assert len(shelter.supplies) == 0
assert len(gs.city_deck) == 0
assert len(gs.supply_graveyard) == 3
assert len(tests.common.outputs) == 4
async def test_play_game(zombie):
gs = GameState()
gs.setup_game(['First', 'Second'], 1)
gs.players[0].print = dumper_factory()
gs.players[0].input = helper_factory(['3', '3'])
gs.players[0].zombies = [zombie]
gs.players[1].print = dumper_factory()
winners = await gs.play_game()
assert len(winners) == 1
assert winners[0] == 'Second'
def test_watch_game(server):
assert server is None
input_data = ['2', '3', 'CPU_A', 'CPU_Z', '']
try:
client.create_game(address, helper_factory(input_data),
dumper_factory())
except IndexError as ex:
assert 'list index out of range' == str(ex)
assert 'Game created. Game ID: 1' in common.outputs
client.watch_game(address, helper_factory(['1']), dumper_factory())
assert 'Watching existing game!' in common.outputs
assert 'Game ID correct. Game events will appear below:' in common.outputs
assert 'Game won by' in common.outputs[-1]
async def test_defend_with_mine_field(gs, fast_zombie, zombie, big_zombie):
shelter = gs.active_player
shelter.zombies = [zombie, big_zombie]
shelter.obstacles = [Supply.MINE_FILED]
await defences.defend_with_mine_field(gs)
assert len(shelter.zombies) == 0
assert len(shelter.obstacles) == 0
assert len(gs.supply_graveyard) == 1
assert len(gs.city_graveyard) == 2
assert len(tests.common.outputs) == 5
gs.active_player = PlayerShelter(print_foo=dumper_factory(), input_foo=helper_factory(['0']))
shelter = gs.active_player
shelter.zombies = [zombie, big_zombie, fast_zombie]
shelter.obstacles = [Supply.MINE_FILED]
await defences.defend_with_mine_field(gs)
assert len(shelter.zombies) == 1
assert fast_zombie in shelter.zombies
assert len(shelter.obstacles) == 0
assert len(gs.supply_graveyard) == 2
assert len(gs.city_graveyard) == 4
assert len(tests.common.outputs) == 5
gs.active_player = PlayerShelter(print_foo=dumper_factory(),
input_foo=helper_factory(['1', '1']))
shelter = gs.active_player
shelter.zombies = [zombie, big_zombie, fast_zombie]
shelter.obstacles = [Supply.MINE_FILED]
await defences.defend_with_mine_field(gs)
assert len(shelter.zombies) == 1
assert big_zombie in shelter.zombies
assert len(shelter.obstacles) == 0
assert len(gs.supply_graveyard) == 3
assert len(gs.city_graveyard) == 6
assert len(tests.common.outputs) == 5
gs.active_player = PlayerShelter(print_foo=dumper_factory(),
input_foo=helper_factory(['1', '0']))
shelter = gs.active_player
shelter.zombies = [zombie, big_zombie, fast_zombie]
shelter.obstacles = [Supply.MINE_FILED]
await defences.defend_with_mine_field(gs)
assert len(shelter.zombies) == 1
assert fast_zombie in shelter.zombies
assert len(shelter.obstacles) == 0
assert len(gs.supply_graveyard) == 4
assert len(gs.city_graveyard) == 8
assert len(tests.common.outputs) == 5
async def test_discard_supplies_move():
gs = GameState()
gs.players = [PlayerShelter('0'), PlayerShelter('1')]
gs.active_player = gs.players[0]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['3'])
shelter.survivors = [CityCard()]
shelter.supplies = [Supply.AXE, Supply.BARRICADES, Supply.ALARM]
turn_end = await gs.discard_supplies_move(False)
assert turn_end
assert len(shelter.supplies) == 0
gs.active_player = shelter
shelter.input = helper_factory(['1'])
shelter.supplies = [Supply.AXE, Supply.BARRICADES, Supply.ALARM]
turn_end = await gs.discard_supplies_move(False)
assert not turn_end
assert len(shelter.supplies) == 2
assert Supply.BARRICADES not in shelter.supplies
gs.active_player = shelter
shelter.input = helper_factory(['2'])
turn_end = await gs.discard_supplies_move(False)
assert turn_end
assert len(shelter.supplies) == 2
def test_gui_default(fast_zombie, zombie, big_zombie):
gs = GameState()
gs.players = [
PlayerShelter('Name_1'),
PlayerShelter('Name_2'),
PlayerShelter('Name_3')
]
gs.players[1].zombies = [
zombie, fast_zombie, fast_zombie, big_zombie, zombie
]
gs.players[1].obstacles = [Supply.BARRICADES, Supply.ALARM]
gs.players[1].survivors = [CityCard(), CityCard()]
gs.players[2].zombies = [big_zombie, big_zombie]
gs.players[2].obstacles = [Supply.MINE_FILED]
gs.players[2].survivors = [CityCard(), CityCard(), CityCard()]
gs.active_player = gs.players[0]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.zombies = [zombie]
shelter.supplies = [Supply.AXE, Supply.MINE_FILED, Supply.LURE_OUT]
shelter.obstacles = [Supply.MINE_FILED, Supply.ALARM]
shelter.survivors = [CityCard(), CityCard(), CityCard(), CityCard()]
shelter.gui_default(gs)
assert len(tests.common.outputs) == 1
assert len(tests.common.outputs[0]) == 684
gs.city_deck = [zombie, CityCard()]
shelter.gui_default(gs)
assert len(tests.common.outputs) == 2
assert len(tests.common.outputs[1]) == 706
def test_find_game(server):
assert server is None
game_id, status_code = \
client.find_game(address, helper_factory(['255', '0']), dumper_factory())
assert game_id == 0
assert status_code == 200
assert common.outputs[-1] == 'Game ID not valid.'
async def test_play_game_cpu(number_of_cpus):
names = [f'CPU{index}' for index in range(number_of_cpus)]
for index in range(10):
gs = GameState()
gs.setup_game(names, 2)
for player in gs.players:
player.print = dumper_factory()
await gs.play_game()
def test_main_create_option(server):
assert server is None
try:
client.main(helper_factory(['c']), dumper_factory())
except IndexError as ex:
assert 'list index out of range' == str(ex)
assert "Creating new Zombreak Game!" in common.outputs
def test_main_watch_option(server):
assert server is None
try:
client.main(helper_factory(['w']), dumper_factory())
except IndexError as ex:
assert 'list index out of range' == str(ex)
assert "Watching existing game!" in common.outputs
def test_create_game_too_few_survivors(server):
assert server is None
input_data = ['2', '0']
try:
client.create_game(address, helper_factory(input_data),
dumper_factory())
except Exception as ex:
assert 'Wrong number of survivors entered!' == str(ex)
def test_create_game(server):
assert server is None
input_data = ['2', '3', 'John', 'CPU_test']
try:
client.create_game(address, helper_factory(input_data),
dumper_factory())
except IndexError as ex:
assert 'list index out of range' == str(ex)
assert common.outputs[-1] == 'Game created. Game ID: 0'
async def test_main_exceptions():
try:
await main(dumper_factory(), helper_factory(['1']))
except Exception as ex:
assert str(ex) == 'Wrong number of players!'
try:
await main(dumper_factory(), helper_factory(['7']))
except Exception as ex:
assert str(ex) == 'Wrong number of players!'
try:
await main(dumper_factory(), helper_factory(['6', '6']))
except Exception as ex:
assert str(ex) == 'Wrong number of initial survivors!'
try:
await main(dumper_factory(), helper_factory(['6', '0']))
except Exception as ex:
assert str(ex) == 'Wrong number of initial survivors!'
def test_join_game(server):
assert server is None
try:
client.join_game(address, helper_factory(['0', 'John', '']),
dumper_factory())
except IndexError as ex:
assert 'list index out of range' == str(ex)
assert 'Joining existing game!' in common.outputs
assert 'Game ID correct.' in common.outputs
assert 'User John correctly logged. Wait for your move...' in common.outputs
assert 'No such action as !' in common.outputs
async def test_play_shotgun_many_lesser_one_big_wrong_input(gs, fast_zombie, zombie, big_zombie):
gs.active_player = PlayerShelter(print_foo=dumper_factory(), input_foo=helper_factory(['6', 'rgdfrbw', '0']))
shelter = gs.active_player
shelter.zombies = [fast_zombie, zombie, fast_zombie, big_zombie, fast_zombie, zombie, zombie]
shelter.supplies = [Supply.SHOTGUN]
await weapons.play_shotgun(gs)
assert len(shelter.zombies) == 6
assert big_zombie not in shelter.zombies
assert len(shelter.supplies) == 0
assert len(gs.supply_graveyard) == 1
assert len(gs.city_graveyard) == 1
assert len(tests.common.outputs) == 5
async def test_play_shotgun_one_lesser_one_big(gs, zombie, big_zombie):
gs.active_player = PlayerShelter(print_foo=dumper_factory(), input_foo=helper_factory(['1']))
shelter = gs.active_player
shelter.zombies = [big_zombie, zombie]
shelter.supplies = [Supply.SHOTGUN]
await weapons.play_shotgun(gs)
assert len(shelter.zombies) == 1
assert zombie not in shelter.zombies
assert len(shelter.supplies) == 0
assert len(gs.supply_graveyard) == 1
assert len(gs.city_graveyard) == 1
assert len(tests.common.outputs) == 3
async def test_play_round_end_round():
gs = GameState()
gs.players = [PlayerShelter('0'), PlayerShelter('1')]
gs.players[1].survivors = [CityCard()]
gs.active_player = gs.players[0]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['3', '3'])
shelter.survivors = [CityCard()]
shelter.supplies = [Supply.AXE, Supply.BARRICADES, Supply.ALARM]
await gs.play_round()
assert len(shelter.supplies) == 3
assert gs.active_player != shelter
async def test_play_chainsaw_no_one_has_defence(gs):
gs.players = [
PlayerShelter('ZERO'),
PlayerShelter('FIRST'),
PlayerShelter('SECOND')
]
gs.active_player = gs.players[0]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.supplies = [Supply.CHAINSAW]
await counters.play_chainsaw(gs)
assert len(shelter.supplies) == 0
assert len(gs.supply_graveyard) == 1
assert len(tests.common.outputs) == 2
async def test_play_sniper_rifle_lesser_and_big_zombies(gs, fast_zombie, big_zombie):
gs.active_player = PlayerShelter(print_foo=dumper_factory(), input_foo=helper_factory(['0']))
shelter = gs.active_player
shelter.zombies = [fast_zombie, big_zombie]
shelter.supplies = [Supply.SNIPER]
await weapons.play_sniper_rifle(gs)
assert len(shelter.zombies) == 1
assert big_zombie not in shelter.zombies
assert len(shelter.supplies) == 0
assert len(gs.supply_graveyard) == 1
assert len(gs.city_graveyard) == 1
assert len(tests.common.outputs) == 2
gs.active_player = PlayerShelter(print_foo=dumper_factory(), input_foo=helper_factory(['1']))
shelter = gs.active_player
shelter.zombies = [fast_zombie, big_zombie]
shelter.supplies = [Supply.SNIPER]
await weapons.play_sniper_rifle(gs)
assert len(shelter.zombies) == 1
assert fast_zombie not in shelter.zombies
assert len(shelter.supplies) == 0
assert len(gs.supply_graveyard) == 2
assert len(gs.city_graveyard) == 2
assert len(tests.common.outputs) == 2
async def test_play_round_win_by_takeover(zombie):
gs = GameState()
gs.players = [PlayerShelter('0'), PlayerShelter('1')]
gs.players[1].survivors = [CityCard()]
gs.active_player = gs.players[0]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['0'])
shelter.zombies = [zombie]
shelter.survivors = [CityCard()]
shelter.supplies = [Supply.TAKEOVER, Supply.BARRICADES, Supply.ALARM]
await gs.play_round()
assert not shelter.defeated
assert gs.players[1].defeated
assert gs.finished
async def test_play_round_use_loud_tool(zombie):
gs = GameState()
gs.players = [PlayerShelter('0'), PlayerShelter('1')]
gs.players[1].survivors = [CityCard()]
gs.players[1].zombies = [zombie]
gs.active_player = gs.players[0]
gs.city_deck = [CityCard()]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['0', '2'])
shelter.survivors = [CityCard()]
shelter.supplies = [Supply.GUN, Supply.BARRICADES, Supply.ALARM]
await gs.play_round()
assert len(shelter.supplies) == 3
assert gs.city_deck[0].top == ZombieType.ZOMBIE
assert gs.active_player != shelter
async def test_play_drone_for_nothing(gs):
gs.players = [
PlayerShelter('ZERO'),
PlayerShelter('FIRST'),
PlayerShelter('SECOND')
]
gs.active_player = gs.players[0]
gs.players[1].defeated = True
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.zombies = []
shelter.supplies = [Supply.DRONE]
await counters.play_drone(gs)
assert len(shelter.zombies) == 0
assert len(shelter.supplies) == 1
assert len(gs.supply_graveyard) == 0
assert len(tests.common.outputs) == 1
async def test_play_round_play_axe_barricades_and_end_round(
zombie, fast_zombie):
gs = GameState()
gs.players = [PlayerShelter('0'), PlayerShelter('1')]
gs.players[1].survivors = [CityCard()]
gs.active_player = gs.players[0]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['0', '0', '1', 'y'])
shelter.zombies = [zombie, fast_zombie]
shelter.survivors = [CityCard()]
shelter.supplies = [Supply.AXE, Supply.BARRICADES, Supply.ALARM]
await gs.play_round()
assert len(shelter.supplies) == 3
assert len(shelter.zombies) == 1
assert len(shelter.survivors) == 1
assert gs.active_player != shelter
async def test_end_active_player_turn_zombies_no_obstacles():
gs = GameState()
gs.players = [PlayerShelter(), PlayerShelter(), PlayerShelter()]
survivor_card = CityCard(ZombieType.ZOMBIE)
survivor_card.flip()
for player in gs.players:
player.survivors.append(survivor_card)
gs.active_player = gs.players[2]
gs.active_player.print = dumper_factory()
gs.active_player.supplies = [Supply.AXE, Supply.ALARM]
zombie_card = CityCard(ZombieType.ZOMBIE)
zombie_card.flip()
gs.active_player.zombies = [zombie_card]
gs.supply_deck = [Supply.AXE, Supply.ALARM, Supply.AXE, Supply.GUN]
await gs.end_active_player_turn()
assert gs.active_player == gs.players[0]
assert len(gs.players[2].supplies) == 0
assert len(tests.common.outputs) == 2
async def test_play_round_last_supplies(zombie):
gs = GameState()
gs.players = [PlayerShelter('0'), PlayerShelter('1')]
gs.supply_deck = [Supply.SACRIFICE, Supply.DRONE, Supply.GUN]
gs.city_deck = [CityCard()]
gs.players[1].survivors = [CityCard()]
gs.active_player = gs.players[0]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['0', '0', '0', 'y'])
shelter.survivors = [CityCard()]
shelter.zombies = [zombie]
shelter.supplies = [Supply.RADIO, Supply.BARRICADES, Supply.ALARM]
await gs.play_round()
assert len(shelter.supplies) == 3
assert gs.final_attack
assert gs.last_supplies_taken
assert gs.active_player != shelter
async def test_play_drone_only_big(gs, big_zombie):
gs.players = [
PlayerShelter('ZERO'),
PlayerShelter('FIRST'),
PlayerShelter('SECOND')
]
gs.active_player = gs.players[0]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['0'])
shelter.zombies = [big_zombie, big_zombie, big_zombie]
shelter.supplies = [Supply.DRONE]
await counters.play_drone(gs)
assert len(shelter.zombies) == 2
assert len(shelter.supplies) == 0
assert len(gs.players[1].zombies) == 1
assert len(gs.players[2].zombies) == 0
assert len(gs.supply_graveyard) == 1
assert len(tests.common.outputs) == 3
async def test_play_swap(gs, fast_zombie, zombie, big_zombie):
gs.players = [
PlayerShelter('ZERO'),
PlayerShelter('FIRST'),
PlayerShelter('SECOND')
]
gs.active_player = gs.players[0]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['0'])
shelter.supplies = [Supply.SWAP]
shelter.zombies = [fast_zombie, big_zombie, fast_zombie, zombie]
gs.players[1].obstacles = [Supply.BARRICADES, Supply.ALARM]
await counters.play_swap(gs)
assert len(shelter.zombies) == 0
assert len(shelter.obstacles) == 2
assert len(gs.players[1].zombies) == 4
assert len(gs.players[1].obstacles) == 0
assert len(tests.common.outputs) == 3
async def test_play_lure_for_nothing(gs):
gs.players = [
PlayerShelter('ZERO'),
PlayerShelter('FIRST'),
PlayerShelter('SECOND')
]
gs.active_player = gs.players[0]
shelter = gs.active_player
shelter.print = dumper_factory()
shelter.input = helper_factory(['y', '1', '0', '0'])
shelter.supplies = [Supply.LURE_OUT]
shelter.zombies = []
gs.city_deck = [CityCard()]
await counters.play_lure_out(gs)
assert len(shelter.zombies) == 0
assert len(shelter.supplies) == 1
assert len(gs.city_deck) == 1
assert len(gs.supply_graveyard) == 0
assert len(tests.common.outputs) == 1
