def test_playable(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
self.assertFalse(app.deck["110"].playable("US", app, True))
self.assertFalse(app.deck["110"].playable("Jihadist", app, False))
app.testCountry("Iraq")
app.map["Iraq"].troopCubes = 1
self.assertTrue(app.deck["110"].playable("US", app, True))
self.assertTrue(app.deck["110"].playable("Jihadist", app, False))
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
self.assertFalse(app.deck["110"].playable("US", app, True))
self.assertFalse(app.deck["110"].playable("Jihadist", app, False))
app.testCountry("Syria")
app.map["Syria"].troopCubes = 1
self.assertTrue(app.deck["110"].playable("US", app, True))
self.assertTrue(app.deck["110"].playable("Jihadist", app, False))
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
self.assertFalse(app.deck["110"].playable("US", app, True))
self.assertFalse(app.deck["110"].playable("Jihadist", app, False))
app.testCountry("Lebanon")
app.map["Lebanon"].troopCubes = 1
self.assertTrue(app.deck["110"].playable("US", app, True))
self.assertTrue(app.deck["110"].playable("Jihadist", app, False))
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
self.assertFalse(app.deck["110"].playable("US", app, True))
self.assertFalse(app.deck["110"].playable("Jihadist", app, False))
app.testCountry("Jordan")
app.map["Jordan"].troopCubes = 1
self.assertTrue(app.deck["110"].playable("US", app, True))
self.assertTrue(app.deck["110"].playable("Jihadist", app, False))
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Pakistan")
app.map["Pakistan"].sleeperCells = 2
app.map["Pakistan"].regimeChange = 1
app.deck["109"].playEvent("US", app)
self.assertCells(app, "Pakistan", 0, True)
self.assertTrue(app.prestige != 7)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Pakistan")
app.map["Pakistan"].sleeperCells = 2
app.map["Pakistan"].regimeChange = 1
app.deck["109"].playEvent("Jihadist", app)
self.assertCells(app, "Pakistan", 0, True)
self.assertTrue(app.prestige != 7)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario, ["Iraq"])
app.testCountry("Pakistan")
app.map["Pakistan"].sleeperCells = 2
app.map["Pakistan"].regimeChange = 1
app.testCountry("Iraq")
app.map["Iraq"].sleeperCells = 2
app.map["Iraq"].regimeChange = 1
print "Choose Iraq"
app.deck["109"].playEvent("US", app)
self.assertCells(app, "Iraq", 0, True)
self.assertTrue(app.prestige != 7)
def test_resolve_us_plots(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.map["United States"].plots = 1
app.map["United States"].posture = "Hard"
app.resolvePlot("United States", 1, 4, [1, 6, 1], [], [], [])
self.assertEqual(app.funding, 9)
self.assertEqual(app.map["United States"].posture, "Soft")
self.assertEqual(app.prestige, 6)
self.assertEqual(app.map["United States"].plots, 0)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.map["United States"].plots = 1
app.map["United States"].posture = "Soft"
app.resolvePlot("United States", 2, 4, [5, 6, 1], [], [], [])
self.assertEqual(app.funding, 9)
self.assertEqual(app.map["United States"].posture, "Soft")
self.assertEqual(app.prestige, 8)
self.assertEqual(app.map["United States"].plots, 0)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.map["United States"].plots = 1
app.map["United States"].posture = "Soft"
app.resolvePlot("United States", 3, 5, [5, 6, 4], [], [], [])
self.assertEqual(app.funding, 9)
self.assertEqual(app.map["United States"].posture, "Hard")
self.assertEqual(app.prestige, 11)
self.assertEqual(app.map["United States"].plots, 0)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
self.assertFalse(app.gameOver)
app.map["United States"].plots = 1
app.map["United States"].posture = "Soft"
app.resolvePlot("United States", "WMD", 0, [], [], [], [])
self.assertEqual(app.map["United States"].plots, 0)
self.assertTrue(app.gameOver)
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Iraq")
app.deck["107"].playEvent("US", app)
self.assertEqual(app.map["Iraq"].aid, 1)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["107"].playEvent("Jihadist", app)
self.assertTrue(app.map["Turkey"].is_poor())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Iraq")
app.map["Iraq"].make_good()
app.deck["107"].playEvent("Jihadist", app)
self.assertTrue(app.map["Turkey"].governance_is_worse_than(GOOD))
self.assertTrue(app.map["Iraq"].is_fair())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Iraq")
app.map["Iraq"].make_fair()
app.testCountry("Turkey")
app.map["Turkey"].make_fair()
app.map["Turkey"].aid = 1
app.deck["107"].playEvent("Jihadist", app)
self.assertTrue(app.map["Turkey"].is_poor())
self.assertTrue(app.map["Iraq"].is_fair())
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Iraq")
app.map["Iraq"].sleeperCells = 1
app.deck["103"].playEvent("US", app)
self.assertEqual(app.map["Iraq"].sleeperCells, 0)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["103"].playEvent("Jihadist", app)
self.assertTrue(app.map["Lebanon"].is_poor())
self.assertTrue(app.map["Lebanon"].is_neutral())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Lebanon")
app.map["Lebanon"].make_good()
app.map["Lebanon"].make_ally()
app.map["Jordan"].make_good()
app.map["Jordan"].make_ally()
app.deck["103"].playEvent("Jihadist", app)
self.assertTrue(app.map["Lebanon"].is_poor())
self.assertTrue(app.map["Lebanon"].is_neutral())
# no countries
app = Labyrinth(1, 1, self.set_up_blank_test_scenario, ["Iraq"])
app.deck["103"].playEvent("US", app)
# one country
app = Labyrinth(1, 1, self.set_up_blank_test_scenario, ["Iraq"])
app.testCountry("Iraq")
app.map["Iraq"].sleeperCells = 1
app.testCountry("Gulf States")
app.map["Gulf States"].sleeperCells = 1
app.deck["103"].playEvent("US", app)
self.assertEqual(app.map["Iraq"].sleeperCells, 0)
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Philippines")
app.map["Philippines"].sleeperCells = 1
app.map["Philippines"].posture = "Hard"
app.deck["115"].playEvent("US", app)
self.assertEqual(app.map["Philippines"].sleeperCells, 0)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario,
["Indonesia/Malaysia"])
app.testCountry("Indonesia/Malaysia")
app.map["Indonesia/Malaysia"].sleeperCells = 1
app.map["Indonesia/Malaysia"].make_ally()
app.testCountry("Philippines")
app.map["Philippines"].sleeperCells = 1
app.map["Philippines"].posture = "Hard"
print "Choose Indonesia/Malaysia"
app.deck["115"].playEvent("US", app)
self.assertEqual(app.map["Indonesia/Malaysia"].sleeperCells, 0)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Indonesia/Malaysia")
app.map["Indonesia/Malaysia"].sleeperCells = 1
app.map["Indonesia/Malaysia"].make_ally()
app.deck["115"].playEvent("Jihadist", app)
self.assertEqual(app.map["Indonesia/Malaysia"].plots, 1)
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["114"].playEvent("US", app)
self.assertTrue("GTMO" in app.lapsing)
self.assertTrue(app.prestige != 7)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["114"].playEvent("Jihadist", app)
self.assertTrue("GTMO" in app.lapsing)
self.assertTrue(app.prestige != 7)
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["118"].playEvent("US", app)
self.assertEqual(app.countryResources("Saudi Arabia"), 4)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario, ["y"])
app.deck["118"].playEvent("Jihadist", app)
self.assertEqual(app.countryResources("Saudi Arabia"), 4)
app.deck["118"].playEvent("US", app)
self.assertEqual(app.countryResources("Saudi Arabia"), 5)
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["101"].playEvent("US", app)
self.assertEqual(app.prestige, 8)
self.assertEqual(app.map["Serbia"].posture, "Soft")
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.map["United States"].posture = "Soft"
app.deck["101"].playEvent("Jihadist", app)
self.assertEqual(app.prestige, 8)
self.assertEqual(app.map["Serbia"].posture, "Hard")
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["102"].playEvent("US", app)
self.assertTrue(app.map["Central Asia"].is_neutral())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Central Asia")
app.map["Central Asia"].make_good()
app.map["Central Asia"].make_ally()
app.deck["102"].playEvent("Jihadist", app)
self.assertFalse(app.map["Central Asia"].is_good())
self.assertTrue(app.map["Central Asia"].is_neutral())
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Iraq")
app.map["Iraq"].troopCubes = 2
app.deck["110"].playEvent("US", app)
self.assertEqual(app.prestige, 10)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Iraq")
app.map["Iraq"].troopCubes = 2
app.deck["110"].playEvent("Jihadist", app)
self.assertEqual(app.map["Iraq"].totalCells(True), 3)
self.assertEqual(app.map["Iraq"].plots, 1)
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["112"].playEvent("US", app)
self.assertEqual(app.funding, 1)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["112"].playEvent("Jihadist", app)
self.assertEqual(app.prestige, 5)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Iraq")
app.map["Iraq"].make_islamist_rule()
app.deck["112"].playEvent("Jihadist", app)
self.assertEqual(app.prestige, 3)
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["113"].playEvent("US", app)
self.assertTrue(app.map["Sudan"].is_governed())
self.assertEqual(app.map["Sudan"].aid, 1)
self.assertTrue(app.map["Sudan"].is_ally())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Sudan")
app.map["Sudan"].make_adversary()
app.deck["113"].playEvent("US", app)
self.assertTrue(app.map["Sudan"].is_governed())
self.assertEqual(app.map["Sudan"].aid, 1)
self.assertTrue(app.map["Sudan"].is_neutral())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.prestige = 6
app.deck["113"].playEvent("US", app)
self.assertTrue(app.map["Sudan"].is_governed())
self.assertEqual(app.map["Sudan"].besieged, 1)
self.assertTrue(app.map["Sudan"].is_adversary())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.prestige = 6
app.testCountry("Sudan")
app.map["Sudan"].make_ally()
app.deck["113"].playEvent("US", app)
self.assertTrue(app.map["Sudan"].is_governed())
self.assertEqual(app.map["Sudan"].besieged, 1)
self.assertTrue(app.map["Sudan"].is_neutral())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["113"].playEvent("Jihadist", app)
self.assertTrue(app.map["Sudan"].is_governed())
self.assertEqual(app.map["Sudan"].aid, 1)
self.assertTrue(app.map["Sudan"].is_ally())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Sudan")
app.map["Sudan"].make_adversary()
app.deck["113"].playEvent("Jihadist", app)
self.assertTrue(app.map["Sudan"].is_governed())
self.assertEqual(app.map["Sudan"].aid, 1)
self.assertTrue(app.map["Sudan"].is_neutral())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.prestige = 6
app.deck["113"].playEvent("Jihadist", app)
self.assertTrue(app.map["Sudan"].is_governed())
self.assertEqual(app.map["Sudan"].besieged, 1)
self.assertTrue(app.map["Sudan"].is_adversary())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.prestige = 6
app.testCountry("Sudan")
app.map["Sudan"].make_ally()
app.deck["113"].playEvent("Jihadist", app)
self.assertTrue(app.map["Sudan"].is_governed())
self.assertEqual(app.map["Sudan"].besieged, 1)
self.assertTrue(app.map["Sudan"].is_neutral())
def test_playable(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
self.assertTrue(app.deck["116"].playable("Jihadist", app, False))
self.assertFalse(app.deck["116"].playable("US", app, True))
app.testCountry("Iraq")
app.map["Iraq"].make_ally()
app.map["Iraq"].plots = 1
self.assertTrue(app.deck["116"].playable("US", app, True))
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
self.assertTrue(app.deck["116"].playable("Jihadist", app, False))
self.assertFalse(app.deck["116"].playable("US", app, True))
app.testCountry("Canada")
app.map["Canada"].plots = 1
self.assertTrue(app.deck["116"].playable("US", app, True))
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.executeCardUSElection(5)
self.assertEqual(app.prestige, 8)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.executeCardUSElection(4)
self.assertEqual(app.prestige, 6)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["120"].playEvent("US", app)
self.assertTrue(app.prestige != 7)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["120"].playEvent("US", app)
self.assertTrue(app.prestige != 7)
def test_reassessment(self):
app = Labyrinth(1, 1, self.set_up_test_scenario)
self.assertEqual(app.map["United States"].posture, "Hard")
app.handleReassessment()
self.assertEqual(app.map["United States"].posture, "Soft")
app.handleReassessment()
self.assertEqual(app.map["United States"].posture, "Hard")
def test_prestige(self):
"""Prestige"""
app = Labyrinth(1, 1, self.set_up_test_scenario)
app.prestige = 1
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 1)
app.prestige = 2
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 1)
app.prestige = 3
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 1)
app.prestige = 4
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 2)
app.prestige = 5
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 2)
app.prestige = 6
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 2)
app.prestige = 7
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 3)
app.prestige = 8
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 3)
app.prestige = 9
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 3)
app.prestige = 10
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 4)
app.prestige = 11
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 4)
app.prestige = 12
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 4)
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario, ["Iraq"])
app.testCountry("Iraq")
app.map["Iraq"].sleeperCells = 1
app.deck["105"].playEvent("US", app)
self.assertEqual(app.map["Iraq"].sleeperCells, 0)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario, ["Yemen"])
app.testCountry("Iraq")
app.map["Iraq"].sleeperCells = 1
app.testCountry("Yemen")
app.map["Yemen"].sleeperCells = 1
app.deck["105"].playEvent("US", app)
self.assertEqual(app.map["Yemen"].sleeperCells, 0)
app.deck["105"].playEvent("Jihadist", app)
def test_is_adjacent(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
self.assertTrue(app.isAdjacent("Iran", "Iraq"))
self.assertTrue(app.isAdjacent("Germany", "Spain"))
self.assertTrue(app.isAdjacent("Libya", "Italy"))
self.assertTrue(app.isAdjacent("Benelux", "Russia"))
self.assertTrue(app.isAdjacent("Lebanon", "France"))
self.assertFalse(app.isAdjacent("United States", "Lebanon"))
def test_to_good(self):
"""Going to Good"""
app = Labyrinth(1, 1, self.set_up_test_scenario)
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 3)
app.map["Gulf States"].make_poor()
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 4)
app.map["Gulf States"].make_fair()
app.map["Gulf States"].make_neutral()
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 4)
def test_alert(self):
app = Labyrinth(1, 1, self.set_up_test_scenario)
self.assertEqual(app.map["Iraq"].plots, 2)
app.handleAlert("Iraq")
self.assertEqual(app.map["Iraq"].plots, 1)
app.handleAlert("Iraq")
self.assertEqual(app.map["Iraq"].plots, 0)
app.handleAlert("Iraq")
self.assertEqual(app.map["Iraq"].plots, 0)
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Iraq")
app.map["Iraq"].make_ally()
app.map["Iraq"].plots = 2
app.testCountry("Pakistan")
app.map["Pakistan"].make_neutral()
app.map["Pakistan"].plots = 2
app.testCountry("Canada")
app.map["Canada"].plots = 1
app.deck["116"].playEvent("US", app)
self.assertEqual(app.map["Iraq"].plots, 0)
self.assertEqual(app.map["Pakistan"].plots, 2)
self.assertEqual(app.map["Canada"].plots, 0)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Iraq")
app.map["Iraq"].sleeperCells = 1
app.deck["116"].playEvent("Jihadist", app)
self.assertEqual(app.map["Iraq"].sleeperCells, 1)
self.assertEqual(app.map["Iraq"].activeCells, 0)
self.assertEqual(app.map["Iraq"].plots, 1)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Iraq")
app.map["Iraq"].make_islamist_rule()
app.map["Iraq"].sleeperCells = 1
app.deck["116"].playEvent("Jihadist", app)
self.assertEqual(app.map["Iraq"].sleeperCells, 1)
self.assertEqual(app.map["Iraq"].activeCells, 0)
self.assertEqual(app.map["Iraq"].plots, 0)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Iraq")
app.map["Iraq"].sleeperCells = 1
app.map["United States"].sleeperCells = 1
app.deck["116"].playEvent("Jihadist", app)
self.assertEqual(app.map["Iraq"].sleeperCells, 1)
self.assertEqual(app.map["Iraq"].activeCells, 0)
self.assertEqual(app.map["Iraq"].plots, 0)
self.assertEqual(app.map["United States"].sleeperCells, 1)
self.assertEqual(app.map["United States"].activeCells, 0)
self.assertEqual(app.map["United States"].plots, 1)
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Pakistan")
app.map["Pakistan"].sleeperCells = 1
app.map["Pakistan"].make_good()
app.deck["108"].playEvent("US", app)
self.assertCells(app, "Pakistan", 0, True)
self.assertTrue(app.map["Pakistan"].is_poor())
self.assertTrue(app.map["Pakistan"].is_ally())
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.testCountry("Pakistan")
app.map["Pakistan"].sleeperCells = 3
app.map["Pakistan"].make_islamist_rule()
app.map["Pakistan"].make_adversary()
app.deck["108"].playEvent("Jihadist", app)
self.assertCells(app, "Pakistan", 2, True)
self.assertTrue(app.map["Pakistan"].is_poor())
self.assertTrue(app.map["Pakistan"].is_ally())
def test_withdraw(self):
app = Labyrinth(1, 1, self.set_up_test_scenario_2)
app.map["United States"].posture = "Soft"
self.assertTrue(app.map["Afghanistan"].is_good())
self.assertTrue(app.map["Afghanistan"].is_ally())
self.assertEqual(app.map["Afghanistan"].troops(), 6)
self.assertEqual(app.map["Afghanistan"].aid, 1)
self.assertEqual(app.map["Afghanistan"].besieged, 0)
self.assertEqual(app.map["Saudi Arabia"].troops(), 2)
self.assertEqual(app.prestige, 7)
self.assertEqual(app.troops, 3)
prestigeRolls = (5, 2, 5)
app.handleWithdraw("Afghanistan", "Saudi Arabia", 4, prestigeRolls)
self.assertTrue(app.map["Afghanistan"].is_good())
self.assertTrue(app.map["Afghanistan"].is_ally())
self.assertEqual(app.map["Afghanistan"].troops(), 2)
self.assertEqual(app.map["Afghanistan"].aid, 0)
self.assertEqual(app.map["Afghanistan"].besieged, 1)
self.assertEqual(app.map["Saudi Arabia"].troops(), 6)
self.assertEqual(app.prestige, 9)
self.assertEqual(app.troops, 3)
app = Labyrinth(1, 1, self.set_up_test_scenario_2)
app.map["United States"].posture = "Soft"
self.assertTrue(app.map["Afghanistan"].is_good())
self.assertTrue(app.map["Afghanistan"].is_ally())
self.assertEqual(app.map["Afghanistan"].troops(), 6)
self.assertEqual(app.map["Afghanistan"].aid, 1)
self.assertEqual(app.map["Afghanistan"].besieged, 0)
self.assertEqual(app.map["Saudi Arabia"].troops(), 2)
self.assertEqual(app.prestige, 7)
self.assertEqual(app.troops, 3)
prestigeRolls = (2, 3, 5)
app.handleWithdraw("Afghanistan", "track", 5, prestigeRolls)
self.assertTrue(app.map["Afghanistan"].is_good())
self.assertTrue(app.map["Afghanistan"].is_ally())
self.assertEqual(app.map["Afghanistan"].troops(), 1)
self.assertEqual(app.map["Afghanistan"].aid, 0)
self.assertEqual(app.map["Afghanistan"].besieged, 1)
self.assertEqual(app.map["Saudi Arabia"].troops(), 2)
self.assertEqual(app.prestige, 4)
self.assertEqual(app.troops, 8)
def test_playable(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
self.assertFalse(app.deck["108"].playable("US", app, True))
self.assertFalse(app.deck["108"].playable("Jihadist", app, False))
app.testCountry("Pakistan")
app.map["Pakistan"].activeCells = 1
self.assertTrue(app.deck["108"].playable("US", app, True))
self.assertTrue(app.deck["108"].playable("Jihadist", app, False))
app.markers.append("Benazir Bhutto")
self.assertFalse(app.deck["108"].playable("US", app, True))
self.assertFalse(app.deck["108"].playable("Jihadist", app, False))
def test_playable(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
self.assertFalse(app.deck["109"].playable("US", app, True))
self.assertFalse(app.deck["109"].playable("Jihadist", app, False))
app.testCountry("Pakistan")
app.map["Pakistan"].activeCells = 2
self.assertFalse(app.deck["109"].playable("US", app, True))
self.assertFalse(app.deck["109"].playable("Jihadist", app, False))
app.map["Pakistan"].regimeChange = 1
self.assertTrue(app.deck["109"].playable("US", app, True))
self.assertTrue(app.deck["109"].playable("Jihadist", app, False))
def test_event(self):
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["119"].playEvent("US", app)
self.assertTrue(app.map["Yemen"].is_governed())
self.assertTrue(app.map["Yemen"].is_ally())
self.assertEqual(app.map["Yemen"].aid, 1)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.map["Yemen"].make_islamist_rule()
app.map["Yemen"].make_neutral()
app.deck["119"].playEvent("US", app)
self.assertTrue(app.map["Yemen"].is_governed())
self.assertTrue(app.map["Yemen"].is_neutral())
self.assertEqual(app.map["Yemen"].aid, 0)
app = Labyrinth(1, 1, self.set_up_blank_test_scenario)
app.deck["119"].playEvent("Jihadist", app)
self.assertTrue(app.map["Yemen"].is_governed())
self.assertTrue(app.map["Yemen"].is_adversary())
self.assertEqual(app.map["Yemen"].besieged, 1)
def _assert_adjust_posture(self, user_input, expected_posture, expected_successful=True):
# Set up
non_muslim_country = "France" # Only these have a posture
app = Labyrinth(1, 1, self.set_up_test_scenario, test_user_input=[user_input])
self.assertEqual(app.map[non_muslim_country].posture, "") # means "Untested"
# Invoke
successful = app.adjustCountryPosture(non_muslim_country)
# Check
self.assertEqual(successful, expected_successful)
self.assertEqual(app.map[non_muslim_country].posture, expected_posture)
def test_gwot_penalty(self):
"""GWOT Penalty"""
app = Labyrinth(1, 1, self.set_up_test_scenario)
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 3)
app.map["United States"].posture = "Soft"
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 2)
app.map["Canada"].posture = "Hard"
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 1)
app.map["France"].posture = "Hard"
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 0)
app.map["Germany"].posture = "Hard"
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 0)
def test_adjacent_countries(self):
"""Adjacent countries Ally Good"""
app = Labyrinth(1, 1, self.set_up_test_scenario)
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 3)
app.map['Pakistan'].make_good()
app.map['Pakistan'].make_neutral()
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 3)
app.map['Pakistan'].make_ally()
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 4)
app.map['Iraq'].make_good()
app.map['Iraq'].make_ally()
self.assertEqual(app.modifiedWoIRoll(3, "Gulf States"), 4)