def test_no_countries_have_plots_at_first(self): # Set up app = Labyrinth(1, 1) # Invoke plot_countries = app.get_plot_countries() # Check self.assertEqual([], plot_countries)
def test_iran_with_nothing_in_it(self): # Set up app = Labyrinth(1, 1, self.set_up_blank_test_scenario) iran = app.get_country("Iran") # Invoke summary = iran.summary() # Check self.assertEqual(summary, "Iran, Fair")
def test_reassessment(self): app = Labyrinth(1, 1, self.set_up_test_scenario) self.assertEqual(app.us_posture(), HARD) app.toggle_us_posture() self.assertEqual(app.us_posture(), SOFT) app.toggle_us_posture() self.assertEqual(app.us_posture(), HARD)
def test_country_without_nato_has_no_extra_troops(self): # Set up app = Labyrinth(1, 1, self.set_up_blank_test_scenario) iran = app.get_country("Iran") iran.change_troops(2) # Invoke troops = iran.troops() # Check self.assertEqual(2, troops)
def test_non_muslim_country_with_no_markers(self): # Set up app = Labyrinth(1, 1, self.set_up_blank_test_scenario) israel = app.get_country("Israel") israel.plots = 2 # Invoke summary = israel.summary() # Check self.assertEqual(summary, "Israel - Posture: Hard\n Plots: 2")
def test_should_have_minimal_choice_with_one_ops(self): # Set up app = Labyrinth(1, 1) # Invoke prompt = app.get_us_prompt_to_spend_ops(4) # Moro talks # Check self.assertEqual( prompt, "1 Ops available. Use one of: deploy, disrupt, reserves, war_of_ideas" )
def test_troops_disrupting_cadre_increases_prestige(self): # Set up app = Labyrinth(1, 1, test_user_input=["Egypt"]) prestige_before = app.prestige app.get_country("Egypt").cadre = 1 app.get_country("Egypt").troopCubes = 2 # Invoke app.disrupt_cells_or_cadre() # Check self.assertEqual(app.prestige, prestige_before + 1)
def test_iran_with_things_in_it(self): # Set up app = Labyrinth(1, 1, self.set_up_blank_test_scenario) iran = app.get_country("Iran") iran.plots = 3 iran.activeCells = 4 # Invoke summary = iran.summary() # Check self.assertEqual(summary, "Iran, Fair\n Active: 4, Plots: 3")
def test_scenario_1_makes_afghanistan_islamist_rule_adversary(self): # Set up app = Labyrinth(1, 1) afghanistan = app.get_country("Afghanistan") # Invoke alignment = afghanistan.alignment() governance = afghanistan.get_governance() # Check self.assertEqual(ADVERSARY, alignment) self.assertEqual(ISLAMIST_RULE, governance)
def test_should_be_able_to_do_anything_with_three_ops(self): # Set up app = Labyrinth(1, 1) # Invoke prompt = app.get_us_prompt_to_spend_ops(82) # Jihadist Videos # Check self.assertEqual( prompt, "3 Ops available. Use one of: alert, deploy, disrupt, reassessment, regime_change," " reserves, war_of_ideas, withdraw")
def test_country_with_nato_has_two_extra_troops(self): # Set up app = Labyrinth(1, 1, self.set_up_blank_test_scenario) iran = app.get_country("Iran") iran.change_troops(2) iran.markers.append("NATO") # Invoke troops = iran.troops() # Check self.assertEqual(4, troops)
def test_two_countries_have_plots(self): # Set up app = Labyrinth(1, 1) actual_plot_countries = ["China", "Italy"] for country_name in actual_plot_countries: app.get_country(country_name).plots = 2 # Invoke plot_countries = [c.name for c in app.get_plot_countries()] # Check plot_countries.sort() self.assertEqual(actual_plot_countries, plot_countries)
def test_us_hard_and_one_unmarked_schengen(self): # Set up app = Labyrinth(1, 1, self.set_up_test_scenario) app.set_posture("United States", HARD) schengen_countries = self.schengen_countries(app) for schengen_country in schengen_countries[1:]: schengen_country.make_soft() unmarked_country = schengen_countries[0] unmarked_country.remove_posture() # Invoke destinations = app.travel_destinations_schengen_visas() # Check expected_country = unmarked_country.name self.assertEqual(destinations, [expected_country, expected_country])
def test_schengen_countries(self): # Set up app = Labyrinth(1, 1, self.set_up_test_scenario) # Invoke schengen_countries = app.names_of_countries(lambda c: c.schengen) # Check expected_names = [ 'France', 'Scandinavia', 'Benelux', 'Italy', 'Germany', 'Spain', 'Eastern Europe' ] self.assertEqual(len(expected_names), len(schengen_countries)) for expected_name in expected_names: self.assertTrue(expected_name in schengen_countries, "Could not find '%s'" % expected_name)
def test_num_disruptable(self): # Set up app = Labyrinth(1, 1) app.get_country("Canada").sleeperCells = 1 app.get_country("Iraq").sleeperCells = 1 app.get_country("Iraq").make_ally() app.get_country("Jordan").sleeperCells = 1 app.get_country("Jordan").troopCubes = 2 app.get_country("Libya").sleeperCells = 1 app.get_country("Libya").troopCubes = 1 # Should not be enough # Invoke & assert self.assertEqual(app.num_disruptable(), 3)
def test_alert_reduces_plot_count_by_one(self): app = Labyrinth(1, 1, self.set_up_test_scenario) iraq = app.map.get("Iraq") self.assertEqual(iraq.plots, 2) app.alert_plot("Iraq") self.assertEqual(iraq.plots, 1) app.alert_plot("Iraq") self.assertEqual(iraq.plots, 0) with self.assertRaises(AssertionError): app.alert_plot("Iraq")
def test_summary(self): # Set up app = Labyrinth(1, 1, self.set_up_test_scenario) app.play_us_card(116) # 3 ops app.deploy_reserves() # Invoke summary = app.get_summary() # Assert self.assertEqual(summary, [ 'Jihadist Ideology: Normal', '', 'VICTORY', 'Good Resources: 0 Islamist Resources: 1', 'Fair/Good Countries: 3 Poor/Islamist Countries: 4', '', 'GWOT', 'US Posture: Hard World Posture: Hard 1', 'US Prestige: 7', '', 'TROOPS', 'War: 9 troops available', '', 'JIHADIST FUNDING', 'Funding: 5 Cells Available: 11', '', 'EVENTS', 'Markers: None', 'Lapsing: None', '', 'US Reserves: 2' ])
def test_cell_placement_removes_cadre(self): # Set up mock_randomizer = mock(Randomizer()) app = Labyrinth(1, 1, self.set_up_test_scenario, randomizer=mock_randomizer) country_name = "Iraq" when(mock_randomizer).pick_one(app.map.country_names()).thenReturn(country_name) when(mock_randomizer).roll_d6(1).thenReturn([4]) # Value doesn't matter country = app.get_country(country_name) country.cadre = 1 sleepers_before = country.sleeperCells # Invoke app.handle_radicalization(1) # Assert sleepers_after = country.sleeperCells self.assertEqual(sleepers_after, sleepers_before + 1, "Radicalization should place a sleeper") self.assertEqual(country.cadre, 0, "Cell placement should have removed the cadre")
def test_is_adjacent(self): app = Labyrinth(1, 1, self.set_up_blank_test_scenario) self.assertTrue(app.is_adjacent("Iran", "Iraq")) self.assertTrue(app.is_adjacent("Germany", "Spain")) self.assertTrue(app.is_adjacent("Libya", "Italy")) self.assertTrue(app.is_adjacent("Benelux", "Russia")) self.assertTrue(app.is_adjacent("Lebanon", "France")) self.assertFalse(app.is_adjacent("United States", "Lebanon"))
def _assert_adjust_posture(self, user_input, expected_posture, expected_successful=True): # Set up app = Labyrinth(1, 1, self.set_up_test_scenario, test_user_input=[user_input]) country = app.get_country( "France") # Only non-muslim countries have a posture self.assertEqual(country.get_posture(), None) # means "Untested" # Invoke successful = app.adjust_country_posture(country.name) # Check self.assertEqual(successful, expected_successful) self.assertEqual(country.get_posture(), expected_posture)
def _create_game(): """Factory function for a new game""" print "" scenario_number = Utils.choose_option("Choose Scenario", scenario_names()) print "" ideology_number = choose_ideology() print "" ai_rolls = Utils.getUserYesNoResponse( "Do you want the program to roll dice for you?") return Labyrinth(scenario_number, ideology_number, ai_rolls=ai_rolls)
def test_is_not_schengen(self): # Set up app = Labyrinth(1, 1, self.set_up_blank_test_scenario) iran = Iran(app) # Invoke schengen = iran.schengen # Check self.assertFalse(schengen)
def test_is_fair(self): # Set up app = Labyrinth(1, 1, self.set_up_blank_test_scenario) iran = Iran(app) # Invoke result = iran.is_fair() # Check self.assertTrue(result)
def test_is_not_good(self): # Set up app = Labyrinth(1, 1, self.set_up_blank_test_scenario) iran = Iran(app) # Invoke result = iran.is_good() # Check self.assertFalse(result)
def test_cannot_be_made_hard(self): # Set up app = Labyrinth(1, 1, self.set_up_blank_test_scenario) iran = Iran(app) # Invoke try: iran.make_hard() self.fail("Should have raised an Exception") except Exception as e: # Check self.assertEqual("Not in Iran", e.message)
def test_major_jihad_is_not_possible(self): # Set up app = Labyrinth(1, 1, self.set_up_blank_test_scenario) iran = Iran(app) iran.sleeperCells = 5 iran.change_troops(-999) # Invoke major_jihad_possible = iran.is_major_jihad_possible(3, 5, False) # Check self.assertFalse(major_jihad_possible)
def test_us_hard_and_multiple_unmarked_schengens(self): # Set up mock_randomizer = mock(Randomizer()) app = Labyrinth(1, 1, self.set_up_test_scenario, randomizer=mock_randomizer) schengen_countries = self.schengen_countries(app) schengen_country_names = [ country.name for country in schengen_countries ] chosen_countries = ['c1', 'c2'] when(mock_randomizer).pick( 2, schengen_country_names).thenReturn(chosen_countries) app.set_posture("United States", HARD) for country in schengen_countries: country.remove_posture() # Invoke destinations = app.travel_destinations_schengen_visas() # Check self.assertEqual(destinations, chosen_countries)
def test_turn_file_can_be_saved_and_loaded(self): """Tests that the game can be saved to and loaded from a turn file""" # Set up saver = Saver() game_to_save = Labyrinth(1, 1) turn_number = 9999 # so as not to overwrite a real turn file game_to_save.turn = turn_number saver.save_current_turn_file(game_to_save) # Invoke loaded_game = saver.load_turn_file(turn_number) # Check self.assertEqual(loaded_game.backlashInPlay, game_to_save.backlashInPlay) self.assertEqual(loaded_game.cells, game_to_save.cells) self.assertEqual(loaded_game.funding, game_to_save.funding) self.assertEqual(loaded_game.gameOver, game_to_save.gameOver) self.assertEqual(loaded_game.history, game_to_save.history) self.assertEqual(loaded_game.ideology, game_to_save.ideology) self.assertEqual(loaded_game.lapsing, game_to_save.lapsing) self.assertEqual(loaded_game.markers, game_to_save.markers) self.assertEqual(loaded_game.phase, game_to_save.phase) self.assertEqual(loaded_game.prestige, game_to_save.prestige) self.assertEqual(loaded_game.roll_turn, game_to_save.roll_turn) self.assertEqual(loaded_game.scenario, game_to_save.scenario) self.assertEqual(loaded_game.startYear, game_to_save.startYear) self.assertEqual(loaded_game.troops, game_to_save.troops) self.assertEqual(loaded_game.turn, game_to_save.turn) self.assertEqual(loaded_game.undo, game_to_save.undo) self.assertEqual(loaded_game.validCountryMarkers, game_to_save.validCountryMarkers) self.assertEqual(loaded_game.validGlobalMarkers, game_to_save.validGlobalMarkers) self.assertEqual(loaded_game.validLapsingMarkers, game_to_save.validLapsingMarkers)
def test_adding_three_ops_only_sets_to_two(self): # Set up app = Labyrinth(1, 1, LabyrinthTestCase.set_up_blank_test_scenario) assert app.us_reserves == 0 app.play_us_card(116) # 3 ops # Invoke app.deploy_reserves() # Check self.assertEqual(2, app.us_reserves)
class CountryDistanceTest(LabyrinthTestCase): """Test countryDistance""" __app = None def setUp(self): self.__app = Labyrinth(1, 1, self.set_up_blank_test_scenario) def assert_distance(self, from_country, to_country, expected_distance): self.assertEqual(self.__app.country_distance(from_country, to_country), expected_distance) def test_distance(self): self.assert_distance("Iran", "Iran", 0) self.assert_distance("Iran", "Iraq", 1) self.assert_distance("Iran", "Sudan", 4) self.assert_distance("Thailand", "United States", 2) self.assert_distance("Russia", "Morocco", 2)