def test_mdc_CCIB_line_positive_effects(self):
"""
Test what happens to voters of the CCIB party line when it is chosen
"""
self.set_turn_line(MDCVoteOrder.CCIB, MDCVoteOrder.CCIB,
MDCVoteOrder.TRAN)
self.g.resolve_current_turn()
dso = DataStealOrder(
stealer_corporation=self.c2,
player=self.p,
target_corporation=self.c,
additional_percents=5,
)
dso.save()
# 20% malus
self.assertEqual(
dso.get_raw_probability(),
dso.additional_percents * 10 + dso.BASE_SUCCESS_PROBABILITY - 20)
# Other have no bonus
dso2 = DataStealOrder(
stealer_corporation=self.c,
player=self.p,
target_corporation=self.c3,
additional_percents=5,
)
dso2.save()
self.assertEqual(
dso2.get_raw_probability(),
dso2.additional_percents * 10 + dso2.BASE_SUCCESS_PROBABILITY)
def create_order(additional_percents):
dso = DataStealOrder(
stealer_corporation=self.c2,
player=self.p,
target_corporation=self.c,
additional_percents=additional_percents,
)
dso.save()
return dso
def setUp(self):
super(DatastealRunOrderTest, self).setUp()
self.dso = DataStealOrder(
stealer_corporation=self.c2,
player=self.p,
target_corporation=self.c,
additional_percents=0,
)
self.dso.clean()
self.dso.save()
self.set_to_zero(self.dso.target_corporation)
def test_get_raw_probability(self):
"""
Check raw probability values (without timing malus)
"""
dso = DataStealOrder(stealer_corporation=self.c2,
player=self.p,
target_corporation=self.c,
additional_percents=1,
hidden_percents=3)
self.assertEqual(
dso.get_raw_probability(), dso.additional_percents * 10 +
dso.hidden_percents * 10 + dso.BASE_SUCCESS_PROBABILITY)
def test_dinc_RSEC_good_effects(self):
"""
Test what happens when the RSEC party line is chosen
"""
self.set_turn_line(DIncVoteOrder.CONS, DIncVoteOrder.RSEC, DIncVoteOrder.RSEC)
self.g.resolve_current_turn()
dso = DataStealOrder(
stealer_corporation=self.c2,
player=self.p2,
target_corporation_market=self.c.corporation_markets.first(),
additional_percents=5,
)
dso.save()
# Reduction on first run
self.assertEqual(
dso.get_cost(), max(0, dso.LAUNCH_COST + dso.BASE_COST * dso.additional_percents - dso.INFLUENCE_BONUS)
)
dso2 = DataStealOrder(
stealer_corporation=self.c2,
player=self.p2,
target_corporation_market=self.c.corporation_markets.first(),
additional_percents=5,
)
dso2.save()
# No reduction on second run
self.assertEqual(dso2.get_cost(), max(0, dso2.LAUNCH_COST + dso2.BASE_COST * dso2.additional_percents))
def test_mdc_TRAN_line_effects(self): """ Test what happens when the TRAN party line is chosen """ self.set_turn_line(MDCVoteOrder.CCIB, MDCVoteOrder.TRAN, MDCVoteOrder.TRAN) self.g.resolve_current_turn() dso = DataStealOrder( stealer_corporation=self.c2, player=self.p, target_corporation=self.c, additional_percents=5, ) dso.save() # 20% bonus self.assertEqual(dso.get_raw_probability(), dso.additional_percents * 10 + dso.BASE_SUCCESS_PROBABILITY - 20) dso2 = DataStealOrder( stealer_corporation=self.c2, player=self.p2, target_corporation=self.c, additional_percents=5, ) dso2.save() # 20% malus self.assertEqual(dso2.get_raw_probability(), dso2.additional_percents * 10 + dso2.BASE_SUCCESS_PROBABILITY + 20)
def setUp(self):
super(SignalsTest, self).setUp()
# We disable the test that stop you from start more than one run on the same target
self.g.allow_several_runs_on_one_target = True
common_corporation_market = self.c.get_common_corporation_market(self.c2)
self.dso = DataStealOrder(
player=self.p, target_corporation_market=common_corporation_market, stealer_corporation=self.c2
)
self.dso.save()
common_corporation_market = self.c.get_common_corporation_market(self.c2)
self.eo = ExtractionOrder(
player=self.p, target_corporation_market=common_corporation_market, stealer_corporation=self.c2
)
self.eo.save()
self.so = SabotageOrder(
player=self.p, target_corporation_market=common_corporation_market, additional_percents=0
)
self.so.clean()
self.so.save()
self.po = ProtectionOrder(
player=self.p, protected_corporation_market=self.eo.target_corporation_market, hidden_percents=10
)
self.po.clean()
self.po.save()
def test_get_raw_probability(self): """ Check raw probability values """ # We disable the test that stop you from start more than one run on the same target self.g.allow_several_runs_on_one_target = True common_corporation_market = self.c.get_common_corporation_market(self.c2) dso = DataStealOrder( stealer_corporation=self.c2, player=self.p, target_corporation_market=common_corporation_market, additional_percents=1, hidden_percents=3 ) self.assertEqual(dso.get_raw_probability(), dso.additional_percents * 10 + dso.hidden_percents * 10 + dso.BASE_SUCCESS_PROBABILITY)
def test_dinc_RSEC_last_turn(self):
"""
Should not reduce price of a run
"""
while self.g.current_turn < self.g.total_turn - 1:
self.g.resolve_current_turn()
self.set_turn_line(DIncVoteOrder.CONS, DIncVoteOrder.RSEC, DIncVoteOrder.RSEC)
self.g.resolve_current_turn()
dso3 = DataStealOrder(
stealer_corporation=self.c2,
player=self.p2,
target_corporation_market=self.c.corporation_markets.first(),
additional_percents=5,
)
dso3.save()
# Reduction on first run
self.assertEqual(dso3.get_cost(), dso3.LAUNCH_COST + dso3.BASE_COST * dso3.additional_percents)
def test_datasteal_target_stealer_different(self):
"""
Target and stealer must be different for Datasteal.
"""
self.dso = DataStealOrder(player=self.p,
target_corporation=self.c,
stealer_corporation=self.c)
self.assertRaises(ValidationError, self.dso.clean)
class ModelsTest(EngineTestCase): def setUp(self): super(ModelsTest, self).setUp() # We disable the test that stop you from start more than one run on the same target self.g.allow_several_runs_on_one_target = True common_corporation_market = self.c.get_common_corporation_market(self.c2) self.dso = DataStealOrder( player=self.p, target_corporation_market=common_corporation_market, stealer_corporation=self.c2, ) self.dso.save() def test_target_corporation_property(self): """ target_corporation must return the right corporation """ self.assertEqual(self.dso.target_corporation, self.c) def test_stealer_corporation_market_property(self): """ stealer_corporation_market must return the right corporation_market """ self.assertEqual(self.dso.stealer_corporation_market, self.c2.corporationmarket_set.get(market=self.dso.target_corporation_market.market, turn=self.g.current_turn)) def test_protected_corporation_property(self): """ protected_corporation must return the right corporation """ po = ProtectionOrder( player=self.p, protected_corporation_market=self.c.get_random_corporation_market(), ) po.save() self.assertEqual(po.protected_corporation, self.c)
def test_get_protection_values(self):
"""
Protection values should include Protection runs.
"""
dso = DataStealOrder(
stealer_corporation=self.c2,
player=self.p,
target_corporation=self.c,
additional_percents=7,
)
dso.save()
self.assertEqual(dso.get_protection_values(),
[dso.target_corporation.base_corporation.datasteal])
po = ProtectionOrder(
player=self.p,
protected_corporation=self.c,
defense=ProtectionOrder.DATASTEAL,
hidden_percents=10,
)
po.save()
self.assertEqual(dso.get_protection_values(), [
po.get_success_probability(),
dso.target_corporation.base_corporation.datasteal
])
def test_dinc_RSEC_bad_effects_do_not_apply_on_RSEC(self):
"""
Test what happens when the RSEC party line is chosen
"""
self.set_turn_line(DIncVoteOrder.CPUB, DIncVoteOrder.RSEC, DIncVoteOrder.RSEC)
self.g.resolve_current_turn()
common_corporation_market = self.c.get_common_corporation_market(self.c2)
dso = DataStealOrder(
stealer_corporation=self.c2,
player=self.p2,
target_corporation_market=common_corporation_market,
additional_percents=5,
)
dso.save()
begin_assets_stealer = dso.stealer_corporation.assets
self.g.resolve_current_turn()
# Test that the run fail
self.assertNotEqual(self.reload(dso.stealer_corporation).assets, begin_assets_stealer)
def setUp(self): super(DatastealRunOrderTest, self).setUp() common_corporation_market = self.c.get_common_corporation_market(self.c2) self.dso = DataStealOrder( stealer_corporation=self.c2, player=self.p, target_corporation_market=common_corporation_market, additional_percents=0, ) self.dso.clean() self.dso.save()
def setUp(self): super(ModelsTest, self).setUp() # We disable the test that stop you from start more than one run on the same target self.g.allow_several_runs_on_one_target = True common_corporation_market = self.c.get_common_corporation_market(self.c2) self.dso = DataStealOrder( player=self.p, target_corporation_market=common_corporation_market, stealer_corporation=self.c2, ) self.dso.save()
def test_repay(self):
"""
Player gets back half the money when the run fails
"""
dso = DataStealOrder(stealer_corporation=self.c2,
player=self.p,
target_corporation=self.c,
additional_percents=1,
hidden_percents=-10)
dso.save()
dso.resolve()
self.assertEqual(
self.reload(self.p).money, self.initial_money - dso.get_cost() / 2)
def test_is_protected(self):
dso = DataStealOrder(
stealer_corporation=self.c2,
player=self.p,
target_corporation=self.c,
additional_percents=7,
)
dso.save()
dso.target_corporation.base_corporation.datasteal = 0
self.assertFalse(dso.is_protected())
dso.target_corporation.base_corporation.datasteal = 100
self.assertTrue(dso.is_protected())
def test_is_detected(self):
"""
Check detection use corporation base values
"""
dso = DataStealOrder(
stealer_corporation=self.c2,
player=self.p,
target_corporation=self.c,
additional_percents=7,
)
dso.save()
dso.target_corporation.base_corporation.detection = 0
self.assertFalse(dso.is_detected())
dso.target_corporation.base_corporation.detection = 100
self.assertTrue(dso.is_detected())
class DefensiveRunOrderTest(RunOrdersTest):
def setUp(self):
super(DefensiveRunOrderTest, self).setUp()
self.dso = DataStealOrder(
stealer_corporation=self.c2,
player=self.p,
target_corporation=self.c,
additional_percents=0,
)
self.dso.clean()
self.dso.save()
self.so = SabotageOrder(
player=self.p,
target_corporation=self.c,
additional_percents=0,
)
self.so.clean()
self.so.save()
self.set_to_zero(self.so.target_corporation)
def tearDown(self):
self.set_to_original(self.so.target_corporation)
def test_has_base_value(self):
"""
Protection has defaut protection values
"""
po = ProtectionOrder(
player=self.p,
protected_corporation=self.c,
defense=ProtectionOrder.DATASTEAL,
additional_percents=1,
)
po.save()
self.assertEqual(
po.get_success_probability(), po.additional_percents * 10 +
po.BASE_SUCCESS_PROBABILITY[po.defense])
@override_base_corporations
def test_corpo_can_protect_alone(self):
"""
Corporations can protect themselves
"""
begin_assets_stealer = self.dso.stealer_corporation.assets
begin_assets_stolen = self.dso.target_corporation.assets
self.dso.target_corporation.base_corporation.datasteal = 100
self.dso.additional_percents = 10
self.dso.save()
self.dso.resolve()
self.assertEqual(
self.reload(self.dso.stealer_corporation).assets,
begin_assets_stealer)
self.assertEqual(
self.reload(self.dso.target_corporation).assets,
begin_assets_stolen)
class SignalsTest(EngineTestCase):
def setUp(self):
super(SignalsTest, self).setUp()
# We disable the test that stop you from start more than one run on the same target
self.g.allow_several_runs_on_one_target = True
common_corporation_market = self.c.get_common_corporation_market(self.c2)
self.dso = DataStealOrder(
player=self.p, target_corporation_market=common_corporation_market, stealer_corporation=self.c2
)
self.dso.save()
common_corporation_market = self.c.get_common_corporation_market(self.c2)
self.eo = ExtractionOrder(
player=self.p, target_corporation_market=common_corporation_market, stealer_corporation=self.c2
)
self.eo.save()
self.so = SabotageOrder(
player=self.p, target_corporation_market=common_corporation_market, additional_percents=0
)
self.so.clean()
self.so.save()
self.po = ProtectionOrder(
player=self.p, protected_corporation_market=self.eo.target_corporation_market, hidden_percents=10
)
self.po.clean()
self.po.save()
def get_unique_market_for_corporation(self, corporation):
return corporation.corporationmarket_set.get(
market__name=corporation.base_corporation.markets.keys()[-1], turn=self.g.current_turn
)
def test_datasteal_target_stealer_different(self):
"""
Target and stealer must be different for Datasteal.
"""
self.dso.stealer_corporation = self.c
self.assertRaises(OrderNotAvailable, self.dso.clean)
def test_extraction_target_stealer_different(self):
"""
Target and stealer must be different for Extraction.
"""
self.eo.stealer_corporation = self.c
self.assertRaises(OrderNotAvailable, self.eo.clean)
def test_datasteal_unavailable_market_for_stealer(self):
"""
Datasteal should not be able to target a corporation that doesn't
have assets in the target market
"""
self.dso.target_corporation_market = self.get_unique_market_for_corporation(self.c)
self.assertRaises(ValidationError, self.dso.clean)
def test_datasteal_unavailable_market_for_target(self):
"""
Datasteal should not be able to target a corporation that doesn't
have assets in the target market
"""
self.dso.target_corporation_market = self.get_unique_market_for_corporation(self.c2)
self.assertRaises(ValidationError, self.dso.clean)
def test_extraction_unavailable_market(self):
"""
Extraction should not be able to target a corporation that doesn't
have assets in the target market
"""
self.eo.target_corporation_market = self.get_unique_market_for_corporation(self.c)
self.assertRaises(ValidationError, self.eo.clean)
def test_datasteal_stealer_above_target(self):
"""
A datasteal cannot be launched against a corporation that is
(strictly) below the stealer on the target market
"""
self.dso.target_corporation_market.value = 0
self.dso.target_corporation_market.save()
self.assertRaises(ValidationError, self.dso.clean)
def test_extraction_stealer_above_target(self):
"""
An extraction cannot be launched against a corporation that is
(strictly) below the stealer on the target market
"""
self.eo.target_corporation_market.value = 0
self.eo.target_corporation_market.save()
self.assertRaises(ValidationError, self.eo.clean)
def test_datasteal_negative_market(self):
"""
Target market must have positive assets
"""
target_corporation_market = self.dso.target_corporation_market
target_corporation_market.value = -1
target_corporation_market.save()
# Stealer must have market assets lower than target
stealer_corporation_market = self.dso.stealer_corporation.corporationmarket_set.get(
market=target_corporation_market.market, turn=self.g.current_turn
)
stealer_corporation_market.value = -2
stealer_corporation_market.save()
self.assertRaises(OrderNotAvailable, self.dso.clean)
def test_extraction_negative_market(self):
"""
Target market must have positive assets
"""
target_corporation_market = self.eo.target_corporation_market
target_corporation_market.value = -1
target_corporation_market.save()
# Stealer must have market assets lower than target
stealer_corporation_market = self.eo.stealer_corporation.corporationmarket_set.get(
market=target_corporation_market.market, turn=self.g.current_turn
)
stealer_corporation_market.value = -2
stealer_corporation_market.save()
self.assertRaises(OrderNotAvailable, self.eo.clean)
def test_sabotage_negative_market(self):
"""
Target market must have positive assets
"""
target_corporation_market = self.so.target_corporation_market
target_corporation_market.value = -1
target_corporation_market.save()
self.assertRaises(OrderNotAvailable, self.so.clean)
def test_protection_negative_market(self):
"""
Target market must have positive assets
"""
target_corporation_market = self.po.protected_corporation_market
target_corporation_market.value = -1
target_corporation_market.save()
self.assertRaises(OrderNotAvailable, self.po.clean)
def test_several_run_on_same_target_fail(self):
"""
Only one run is allowed by target. allow_several_runs_on_one_target is set on True on the test_models.py of corporation_run
We used this variable because there are a lot of randoms corporations in the targets for testing
"""
self.p.game.allow_several_runs_on_one_target = False
common_corporation_market = self.c.get_common_corporation_market(self.c2)
self.so2 = SabotageOrder(
player=self.p, target_corporation_market=common_corporation_market, additional_percents=0
)
self.so2.save()
self.assertRaises(OrderNotAvailable, self.po.clean)
class DatastealRunOrderTest(EngineTestCase): def setUp(self): super(DatastealRunOrderTest, self).setUp() common_corporation_market = self.c.get_common_corporation_market(self.c2) self.dso = DataStealOrder( stealer_corporation=self.c2, player=self.p, target_corporation_market=common_corporation_market, additional_percents=0, ) self.dso.clean() self.dso.save() def test_datasteal_success(self): """ Datasteal benefits the stealer 1 asset without costing the stolen The 2 corporations must have a common market """ begin_assets_stealer = self.dso.stealer_corporation.assets self.dso.additional_percents = 10 self.dso.save() self.dso.resolve() self.assertEqual(self.reload(self.dso.stealer_corporation).assets, begin_assets_stealer + 1) def test_datasteal_failure(self): """ Failed datasteal should not change corporation assets. """ begin_assets_stealer = self.dso.stealer_corporation.assets self.dso.additional_percents = 0 self.dso.hidden_percents = -10 self.dso.save() self.dso.resolve() self.assertEqual(self.reload(self.dso.stealer_corporation).assets, begin_assets_stealer) @override_max_protection def test_datasteal_interception(self): """ Intercepted datasteal should not change corporation assets. """ begin_assets_stealer = self.dso.stealer_corporation.assets po = ProtectionOrder( player=self.p, protected_corporation_market=self.dso.target_corporation_market, ) po.clean() po.save() po.additional_percents = 10 po.save() self.dso.additional_percents = 10 self.dso.save() self.dso.resolve() self.assertEqual(self.reload(self.dso.stealer_corporation).assets, begin_assets_stealer)
class DatastealRunOrderTest(RunOrdersTest):
def setUp(self):
super(DatastealRunOrderTest, self).setUp()
self.dso = DataStealOrder(
stealer_corporation=self.c2,
player=self.p,
target_corporation=self.c,
additional_percents=0,
)
self.dso.clean()
self.dso.save()
self.set_to_zero(self.dso.target_corporation)
def tearDown(self):
self.set_to_original(self.dso.target_corporation)
def test_datasteal_success(self):
"""
Datasteal benefits the stealer 1 asset without costing the stolen
"""
begin_assets_stealer = self.dso.stealer_corporation.assets
self.dso.additional_percents = 10
self.dso.save()
self.dso.resolve()
self.assertEqual(
self.reload(self.dso.stealer_corporation).assets,
begin_assets_stealer + 1)
def test_datasteal_failure(self):
"""
Failed datasteal should not change corporation assets.
"""
begin_assets_stealer = self.dso.stealer_corporation.assets
self.dso.additional_percents = 0
self.dso.hidden_percents = -10
self.dso.save()
self.dso.resolve()
self.assertEqual(
self.reload(self.dso.stealer_corporation).assets,
begin_assets_stealer)
def test_datasteal_interception(self):
"""
Intercepted datasteal should not change corporation assets.
"""
begin_assets_stealer = self.dso.stealer_corporation.assets
po = ProtectionOrder(player=self.p,
protected_corporation=self.c,
defense=ProtectionOrder.DATASTEAL)
po.clean()
po.save()
po.additional_percents = 10
po.save()
self.dso.additional_percents = 10
self.dso.save()
self.dso.resolve()
self.assertEqual(
self.reload(self.dso.stealer_corporation).assets,
begin_assets_stealer)
