コード例 #1
0
ファイル: test_orders.py プロジェクト: Neamar/corporate
class DefensiveRunOrderTest(EngineTestCase):
	def setUp(self):
		super(DefensiveRunOrderTest, self).setUp()

		corporationmarket = self.c.get_random_corporation_market()
		self.dso = ProtectionOrder(
			player=self.p,
			protected_corporation_market=corporationmarket,
		)
		self.dso.clean()
		self.dso.save()

		self.so = SabotageOrder(
			player=self.p,
			target_corporation_market=corporationmarket,
			additional_percents=10,
		)
		self.so.clean()
		self.so.save()

	def test_protection_stops_runs(self):
		# this test's only purpose is to test that the run is stopped when it has 100% chance of success and protection drops it to 0%
		# these parameters are defined in engine/testcases.py
		begin_assets = self.c2.assets
		self.g.resolve_current_turn()
		self.assertEqual(self.reload(self.c2).assets, begin_assets)
コード例 #2
0
    def setUp(self):
        super(SabotageRunOrderTest, self).setUp()
        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)
コード例 #3
0
ファイル: test_signals.py プロジェクト: Neamar/corporate
    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()
コード例 #4
0
    def setUp(self):

        super(OffensiveRunTaskTest, self).setUp()

        self.so = SabotageOrder(
            player=self.p,
            target_corporation=self.c,
            additional_percents=0,
        )
        self.so.clean()
        self.so.save()

        # Refill money for the player
        self.INITIAL_MONEY = 100000
        self.p.money = self.INITIAL_MONEY
        self.p.save()

        self.so_initial_extraction = self.so.target_corporation.base_corporation.sabotage
コード例 #5
0
    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)
コード例 #6
0
ファイル: test_orders.py プロジェクト: Neamar/corporate
	def setUp(self):
		super(InformationRunOrderTest, self).setUp()

		self.p2 = Player(game=self.g)
		self.p2.save()

		from engine_modules.corporation_run.models import SabotageOrder

		# Initial setup, create logs we'll use later.
		o = SabotageOrder(
			player=self.p2,
			target_corporation_market=self.c.get_random_corporation_market_among_bests()
		)
		o.save()

		self.io = InformationOrder(
			player=self.p,
		)
		self.io.clean()
		self.io.save()
コード例 #7
0
ファイル: test_signals.py プロジェクト: Neamar/corporate
    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)
コード例 #8
0
ファイル: test_orders.py プロジェクト: Neamar/corporate
	def setUp(self):

		super(SabotageRunOrderTest, self).setUp()

		common_corporation_market = self.c.get_common_corporation_market(self.c2)

		self.so = SabotageOrder(
			player=self.p,
			target_corporation_market=common_corporation_market,
			additional_percents=0,
		)
		self.so.clean()
		self.so.save()
コード例 #9
0
class OffensiveRunTaskTest(EngineTestCase):
    def setUp(self):

        super(OffensiveRunTaskTest, self).setUp()

        self.so = SabotageOrder(
            player=self.p,
            target_corporation=self.c,
            additional_percents=0,
        )
        self.so.clean()
        self.so.save()

        # Refill money for the player
        self.INITIAL_MONEY = 100000
        self.p.money = self.INITIAL_MONEY
        self.p.save()

        self.so_initial_extraction = self.so.target_corporation.base_corporation.sabotage

    def test_offensive_run_task(self):
        """
		Check the task solves the run
		"""
        begin_sabotaged_assets = self.so.target_corporation.assets
        self.so.target_corporation.base_corporation.sabotage = 0
        self.so.additional_percents = 10
        self.so.save()

        self.g.resolve_current_turn()
        self.assertEqual(
            self.reload(self.so.target_corporation).assets,
            begin_sabotaged_assets - 2)

        self.so.target_corporation.base_corporation.sabotage = self.so_initial_extraction

    def test_protection_run_task(self):
        """
		Check the task solves the run
		"""
        po = ProtectionOrder(
            player=self.p,
            protected_corporation=self.c,
            defense=ProtectionOrder.SABOTAGE,
        )
        po.clean()
        po.save()
        po.additional_percents = 10
        po.save()

        self.g.resolve_current_turn()
        self.assertEqual(
            self.reload(self.p).money, self.INITIAL_MONEY - po.get_cost())
コード例 #10
0
ファイル: test_tasks.py プロジェクト: silky/corporate
	def setUp(self):

		super(OffensiveRunTaskTest, self).setUp()

		self.so = SabotageOrder(
			player=self.p,
			target_corporation=self.c,
			additional_percents=0,
		)
		self.so.clean()
		self.so.save()

		# Refill money for the player
		self.INITIAL_MONEY = 100000
		self.p.money = self.INITIAL_MONEY
		self.p.save()

		self.so_initial_extraction = self.so.target_corporation.base_corporation.sabotage
コード例 #11
0
ファイル: test_orders.py プロジェクト: Neamar/corporate
	def setUp(self):
		super(DefensiveRunOrderTest, self).setUp()

		corporationmarket = self.c.get_random_corporation_market()
		self.dso = ProtectionOrder(
			player=self.p,
			protected_corporation_market=corporationmarket,
		)
		self.dso.clean()
		self.dso.save()

		self.so = SabotageOrder(
			player=self.p,
			target_corporation_market=corporationmarket,
			additional_percents=10,
		)
		self.so.clean()
		self.so.save()
コード例 #12
0
ファイル: test_tasks.py プロジェクト: Neamar/corporate
	def setUp(self):

		super(OffensiveRunTaskTest, 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

		self.so = SabotageOrder(
			player=self.p,
			target_corporation_market=self.c.get_random_corporation_market(),
			additional_percents=0,
		)
		self.so.clean()
		self.so.save()

		# Refill money for the player
		self.INITIAL_MONEY = 100000
		self.p.money = self.INITIAL_MONEY
		self.p.save()
コード例 #13
0
ファイル: test_tasks.py プロジェクト: silky/corporate
class OffensiveRunTaskTest(EngineTestCase):
	def setUp(self):

		super(OffensiveRunTaskTest, self).setUp()

		self.so = SabotageOrder(
			player=self.p,
			target_corporation=self.c,
			additional_percents=0,
		)
		self.so.clean()
		self.so.save()

		# Refill money for the player
		self.INITIAL_MONEY = 100000
		self.p.money = self.INITIAL_MONEY
		self.p.save()

		self.so_initial_extraction = self.so.target_corporation.base_corporation.sabotage

	def test_offensive_run_task(self):
		"""
		Check the task solves the run
		"""
		begin_sabotaged_assets = self.so.target_corporation.assets
		self.so.target_corporation.base_corporation.sabotage = 0
		self.so.additional_percents = 10
		self.so.save()

		self.g.resolve_current_turn()
		self.assertEqual(self.reload(self.so.target_corporation).assets, begin_sabotaged_assets - 2)

		self.so.target_corporation.base_corporation.sabotage = self.so_initial_extraction

	def test_protection_run_task(self):
		"""
		Check the task solves the run
		"""
		po = ProtectionOrder(
			player=self.p,
			protected_corporation=self.c,
			defense=ProtectionOrder.SABOTAGE,
		)
		po.clean()
		po.save()
		po.additional_percents = 10
		po.save()

		self.g.resolve_current_turn()
		self.assertEqual(self.reload(self.p).money, self.INITIAL_MONEY - po.get_cost())
コード例 #14
0
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)
コード例 #15
0
ファイル: test_orders.py プロジェクト: Neamar/corporate
class SabotageRunOrderTest(EngineTestCase):
	def setUp(self):

		super(SabotageRunOrderTest, self).setUp()

		common_corporation_market = self.c.get_common_corporation_market(self.c2)

		self.so = SabotageOrder(
			player=self.p,
			target_corporation_market=common_corporation_market,
			additional_percents=0,
		)
		self.so.clean()
		self.so.save()

	def test_sabotage_success(self):
		"""
		Sabotage doesn't benefit anyone, but costs the sabotaged 2 assets
		"""
		begin_assets = self.so.target_corporation.assets
		self.so.target_corporation_market.value = 8
		self.so.target_corporation_market.save()
		begin_market_value = self.reload(self.so.target_corporation_market).value

		self.so.additional_percents = 10
		self.so.save()

		self.so.resolve()

		delta = begin_market_value - self.reload(self.so.target_corporation_market).value
		self.assertEqual(delta, 2)
		self.assertEqual(self.so.target_corporation.assets, begin_assets - delta)

	def test_sabotage_failure(self):
		"""
		Failed sabotage does not change corporation assets
		"""
		begin_assets = self.so.target_corporation.assets

		self.so.additional_percents = 0
		self.so.hidden_percents = -10
		self.so.save()

		self.so.resolve()
		self.assertEqual(self.reload(self.so.target_corporation).assets, begin_assets)

	@override_max_protection
	def test_sabotage_interception(self):
		"""
		Intercepted sabotage does not change corporation assets
		"""
		begin_assets = self.so.target_corporation.assets

		po = ProtectionOrder(
			player=self.p,
			protected_corporation_market=self.so.target_corporation_market,
			hidden_percents=10,
		)
		po.clean()
		po.save()

		self.so.additional_percents = 10
		self.so.save()

		self.so.resolve()
		self.assertEqual(self.reload(self.so.target_corporation).assets, begin_assets)
コード例 #16
0
ファイル: test_signals.py プロジェクト: Neamar/corporate
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)
コード例 #17
0
class SabotageRunOrderTest(RunOrdersTest):
    def setUp(self):
        super(SabotageRunOrderTest, self).setUp()
        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_sabotage_success(self):
        """
		Sabotage doesn't benefit anyone, but costs the sabotaged 2 assets
		"""
        begin_assets = self.so.target_corporation.assets

        self.so.additional_percents = 10
        self.so.save()

        self.so.resolve()
        self.assertEqual(
            self.reload(self.so.target_corporation).assets, begin_assets - 2)

    def test_sabotage_failure(self):
        """
		Failed sabotage does not change corporation assets
		"""
        begin_assets = self.so.target_corporation.assets

        self.so.additional_percents = 0
        self.so.hidden_percents = -10
        self.so.save()

        self.so.resolve()
        self.assertEqual(
            self.reload(self.so.target_corporation).assets, begin_assets)

    def test_sabotage_interception(self):
        """
		Intercepted sabotage does not change corporation assets
		"""
        begin_assets = self.so.target_corporation.assets

        po = ProtectionOrder(
            player=self.p,
            protected_corporation=self.c,
            defense=ProtectionOrder.SABOTAGE,
            hidden_percents=10,
        )
        po.clean()
        po.save()

        self.so.additional_percents = 10
        self.so.save()

        self.so.resolve()
        self.assertEqual(
            self.reload(self.so.target_corporation).assets, begin_assets)
コード例 #18
0
ファイル: test_tasks.py プロジェクト: Neamar/corporate
class OffensiveRunTaskTest(EngineTestCase):
	def setUp(self):

		super(OffensiveRunTaskTest, 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

		self.so = SabotageOrder(
			player=self.p,
			target_corporation_market=self.c.get_random_corporation_market(),
			additional_percents=0,
		)
		self.so.clean()
		self.so.save()

		# Refill money for the player
		self.INITIAL_MONEY = 100000
		self.p.money = self.INITIAL_MONEY
		self.p.save()

	def test_offensive_run_task(self):
		"""
		Check the task solves the run
		"""
		begin_sabotaged_assets = self.so.target_corporation.assets
		self.so.target_corporation.base_corporation.sabotage = 0
		self.so.additional_percents = 10
		self.so.save()

		self.g.resolve_current_turn()
		self.assertEqual(self.reload(self.so.target_corporation).assets, begin_sabotaged_assets - 2)

	def test_offensive_resolve_order(self):
		"""
		Check that offensive runs are resolved in order of raw_probability
		And that only the first one has been resolved on the same market
		"""

		# We don't want the setUp order to interfere :
		self.so.delete()

		# We find a common corporationmarket on c with a market shared by c,c2 and c3
		c2_markets = self.c2.markets
		c3_markets = self.c3.markets
		common_corporation_markets = [cm for cm in self.c.corporation_markets if cm.market in c2_markets and cm.market in c3_markets]
		common_corporation_market = common_corporation_markets[0]

		assets_c_before = self.c.assets
		assets_c3_before = self.c3.assets
		assets_c2_before = self.c2.assets

		# We order an extraction run for c2 and c3 on this market
		so2 = ExtractionOrder(
			player=self.p,
			target_corporation_market=common_corporation_market,
			stealer_corporation=self.c2,
			additional_percents=4,
		)

		so2.clean()
		so2.save()
		
		so3 = ExtractionOrder(
			player=self.p,
			target_corporation_market=common_corporation_market,
			stealer_corporation=self.c3,
			additional_percents=8,
		)

		so3.clean()
		so3.save()
		
		self.g.resolve_current_turn()

		self.assertEqual(self.reload(self.c).assets, assets_c_before - 1)  # SabotageOrder of the setUp succeeded + 1 ExtractionOrder succeeded
		self.assertEqual(self.reload(self.c2).assets, assets_c3_before)  # ExtractionOrder failed
		self.assertEqual(self.reload(self.c3).assets, assets_c2_before + 1)  # ExtractionOrder succeeded