class RepairBuildingTests(CardsTestMixin, testcase.TestCase):
CARD = effects.RepairBuilding
def setUp(self):
super(RepairBuildingTests, self).setUp()
self.place_1, self.place_2, self.place_3 = create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.account_2 = self.accounts_factory.create_account(is_fast=True)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.storage.load_account_data(self.account_2)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
environment.deinitialize()
environment.initialize()
self.highlevel = environment.workers.highlevel
self.highlevel.process_initialize(0, 'highlevel')
self.building_1 = places_logic.create_building(person=self.place_1.persons[0], utg_name=names.generator().get_test_name('building-1-name'))
self.building_2 = places_logic.create_building(person=self.place_2.persons[0], utg_name=names.generator().get_test_name('building-1-name'))
self.building_1.amortize(c.TURNS_IN_HOUR*24)
self.building_2.amortize(c.TURNS_IN_HOUR*24)
def test_use(self):
self.assertTrue(self.building_1.need_repair)
self.assertTrue(self.building_2.need_repair)
result, step, postsave_actions = self.card.use(**self.use_attributes(hero=self.hero, storage=self.storage, building_id=self.building_2.id))
self.assertEqual((result, step), (ComplexChangeTask.RESULT.CONTINUE, ComplexChangeTask.STEP.HIGHLEVEL))
self.assertEqual(len(postsave_actions), 1)
with mock.patch('the_tale.game.workers.highlevel.Worker.cmd_logic_task') as highlevel_logic_task_counter:
postsave_actions[0]()
self.assertEqual(highlevel_logic_task_counter.call_count, 1)
result, step, postsave_actions = self.card.use(**self.use_attributes(hero=self.hero,
step=step,
highlevel=self.highlevel,
building_id=self.building_2.id))
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ()))
self.assertTrue(self.building_1.need_repair)
self.assertFalse(self.building_2.need_repair)
def test_use_for_wrong_place_id(self):
self.assertEqual(self.card.use(**self.use_attributes(hero=self.hero, building_id=666, storage=self.storage)),
(ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR, ()))
def test_initialize_bots__second_create(self):
account_1 = self.accounts_factory.create_account()
account_2 = self.accounts_factory.create_account(is_bot=True)
storage = LogicStorage()
storage.load_account_data(account_1)
storage.load_account_data(account_2)
hero_1 = storage.accounts_to_heroes[account_1.id]
hero_2 = storage.accounts_to_heroes[account_2.id]
hero_1.level = 50
self.assertEqual(hero_2.level, 1)
self.pvp_create_battle(account_1, account_2, BATTLE_1X1_STATE.PROCESSING)
self.pvp_create_battle(account_2, account_1, BATTLE_1X1_STATE.PROCESSING)
meta_action = meta_actions.ArenaPvP1x1.create(storage, hero_1, hero_2)
meta_action.process_battle_ending()
meta_actions.ArenaPvP1x1.create(storage, hero_1, hero_2)
self.assertEqual(hero_2.level, 50)
self.assertTrue(len(hero_2.abilities.all) > 1)
self.assertEqual(hero_2.health, hero_2.max_health)
def test_process_bot__flame_ability_not_used(self):
account_1 = self.accounts_factory.create_account(is_bot=True)
account_2 = self.accounts_factory.create_account()
storage = LogicStorage()
storage.load_account_data(account_1)
storage.load_account_data(account_2)
hero_1 = storage.accounts_to_heroes[account_1.id]
hero_2 = storage.accounts_to_heroes[account_2.id]
self.meta_action_battle.bot_pvp_properties = {
'priorities': {
Flame.TYPE: 1
},
'ability_chance': 1
}
self.assertEqual(self.meta_action_battle.hero_2_pvp.energy_speed, 1)
with mock.patch('the_tale.game.pvp.abilities.Flame.use') as use:
for i in range(100):
self.meta_action_battle.process_bot(
hero_1, hero_2, self.meta_action_battle.hero_2_pvp)
self.assertEqual(use.call_count, 0)
class QuestsTestBase(testcase.TestCase):
def setUp(self):
super(QuestsTestBase, self).setUp()
self.p1, self.p2, self.p3 = create_test_map()
# add more persons, to lower conflicts
places_logic.add_person_to_place(self.p1)
places_logic.add_person_to_place(self.p1)
places_logic.add_person_to_place(self.p2)
places_logic.add_person_to_place(self.p2)
places_logic.add_person_to_place(self.p3)
places_logic.add_person_to_place(self.p3)
account = self.accounts_factory.create_account(is_fast=True)
self.storage = LogicStorage()
self.storage.load_account_data(account)
self.hero = self.storage.accounts_to_heroes[account.id]
self.action_idl = self.hero.actions.current_action
self.hero.money += 1
self.hero.preferences.set_mob(mobs_storage.all()[0])
self.hero.preferences.set_place(self.p1)
self.hero.preferences.set_friend(self.p1.persons[0])
self.hero.preferences.set_enemy(self.p2.persons[0])
self.hero.preferences.set_equipment_slot(EQUIPMENT_SLOT.PLATE)
self.hero.position.set_place(self.p3)
heroes_logic.save_hero(self.hero)
self.p2.set_modifier(places_modifiers.CITY_MODIFIERS.HOLY_CITY)
places_logic.save_place(self.p2)
self.p1.persons[0].type = PERSON_TYPE.BLACKSMITH
persons_logic.save_person(self.p1.persons[0])
class BuyRandomPremiumChestTask__EpicArtifact_Tests(
base_buy_task._BaseBuyHeroMethodPosponedTaskTests):
def setUp(self):
super(BuyRandomPremiumChestTask__EpicArtifact_Tests, self).setUp()
self.task = BuyRandomPremiumChest(account_id=self.account.id,
transaction=self.transaction)
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.cmd_update_with_account_data__call_count = 0
self.accounts_manages_worker = False
self.supervisor_worker = True
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.assertEqual(self.hero.bag.occupation, 0)
def _get_expected_arguments(self):
return {}
def _check_not_used(self):
self.assertEqual(self.hero.bag.occupation, 0)
self.assertEqual(RandomPremiumRequestPrototype._db_count(), 0)
def _check_used(self):
self.assertEqual(self.hero.bag.occupation, 1)
self.assertTrue(list(self.hero.bag.values())[0].rarity.is_EPIC)
self.assertEqual(RandomPremiumRequestPrototype._db_count(), 1)
class LevelUpTest(testcase.TestCase, CardsTestMixin):
CARD = LevelUp
def setUp(self):
super(LevelUpTest, self).setUp()
create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.abilities = self.hero.abilities
self.card = self.CARD()
def test_use(self):
self.hero.add_experience(self.hero.experience_to_next_level / 2)
self.assertTrue(self.hero.experience > 0)
self.assertEqual(self.hero.level, 1)
with self.check_not_changed(lambda: self.hero.experience):
with self.check_delta(lambda: self.hero.level, 1):
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ()))
saved_hero = heroes_logic.load_hero(hero_id=self.hero.id)
self.assertEqual(saved_hero.abilities.destiny_points, self.abilities.destiny_points)
class HelpPlaceMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(HelpPlaceMixin, self).setUp()
self.place_1, self.place_2, self.place_3 = create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
def test_use(self):
with self.check_delta(lambda: self.hero.places_history._get_places_statisitcs().get(self.place_1.id, 0), self.CARD.effect.modificator):
result, step, postsave_actions = self.CARD.effect.use(**self.use_attributes(storage=self.storage, hero=self.hero, value=self.place_1.id))
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ()))
def test_wrong_place(self):
with self.check_not_changed(lambda: self.hero.places_history._get_places_statisitcs().get(self.place_1.id, 0)):
result, step, postsave_actions = self.CARD.effect.use(**self.use_attributes(storage=self.storage, hero=self.hero, value=666))
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR, ()))
class AddGoldTestMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(AddGoldTestMixin, self).setUp()
create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
def test_use(self):
with self.check_delta(lambda: self.hero.money, self.CARD.GOLD):
with self.check_delta(
lambda: self.hero.statistics.money_earned_from_help,
self.CARD.GOLD):
with self.check_delta(
lambda: self.hero.statistics.money_earned,
self.CARD.GOLD):
result, step, postsave_actions = self.card.use(
**self.use_attributes(storage=self.storage,
hero=self.hero))
self.assertEqual((result, step, postsave_actions),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
class HeroPreferencesCompanionEmpathyTest(TestCase):
PREFERENCE_TYPE = relations.PREFERENCE_TYPE.COMPANION_EMPATHY
def setUp(self):
super(HeroPreferencesCompanionEmpathyTest, self).setUp()
create_test_map()
self.account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.hero.level = relations.PREFERENCE_TYPE.COMPANION_EMPATHY.level_required
logic.save_hero(self.hero)
self.empath = relations.COMPANION_EMPATHY.EMPATH
self.egocentric = relations.COMPANION_EMPATHY.EGOCENTRIC
def test_initialization(self):
self.assertTrue(self.hero.preferences.companion_empathy.is_ORDINAL)
def test_preferences_serialization(self):
self.hero.preferences.set(relations.PREFERENCE_TYPE.COMPANION_EMPATHY,
self.empath)
data = self.hero.preferences.serialize()
self.assertEqual(data, HeroPreferences.deserialize(data).serialize())
def test_save(self):
self.hero.preferences.set(relations.PREFERENCE_TYPE.COMPANION_EMPATHY,
self.empath)
logic.save_hero(self.hero)
self.hero = logic.load_hero(hero_id=self.hero.id)
self.assertEqual(self.hero.preferences.companion_empathy, self.empath)
class BuyRandomPremiumChestTask__EpicArtifact_Tests(base_buy_task._BaseBuyHeroMethodPosponedTaskTests):
def setUp(self):
super(BuyRandomPremiumChestTask__EpicArtifact_Tests, self).setUp()
self.task = BuyRandomPremiumChest(account_id=self.account.id,
transaction=self.transaction)
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.cmd_update_with_account_data__call_count = 0
self.accounts_manages_worker = False
self.supervisor_worker = True
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.assertEqual(self.hero.bag.occupation, 0)
def _get_expected_arguments(self):
return {}
def _check_not_used(self):
self.assertEqual(self.hero.bag.occupation, 0)
self.assertEqual(RandomPremiumRequestPrototype._db_count(), 0)
def _check_used(self):
self.assertEqual(self.hero.bag.occupation, 1)
self.assertTrue(self.hero.bag.values()[0].rarity.is_EPIC)
self.assertEqual(RandomPremiumRequestPrototype._db_count(), 1)
class AddBonusEnergyTestMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(AddBonusEnergyTestMixin, self).setUp()
create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
def test_use(self):
with self.check_delta(
lambda: tt_api_energy.energy_balance(self.account_1.id),
self.CARD.effect.modificator):
result, step, postsave_actions = self.CARD.effect.use(
**self.use_attributes(storage=self.storage, hero=self.hero))
time.sleep(0.1)
self.assertEqual((result, step, postsave_actions),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
class AddGoldTestMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(AddGoldTestMixin, self).setUp()
create_test_map()
result, account_1_id, bundle_id = register_user('test_user', '*****@*****.**', '111111')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
def test_use(self):
with self.check_delta(lambda: self.hero.money, self.CARD.GOLD):
with self.check_delta(lambda: self.hero.statistics.money_earned_from_help, self.CARD.GOLD):
with self.check_delta(lambda: self.hero.statistics.money_earned, self.CARD.GOLD):
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ()))
class BuyRandomPremiumChestTask__Energy_Tests(base_buy_task._BaseBuyHeroMethodPosponedTaskTests):
def setUp(self):
super(BuyRandomPremiumChestTask__Energy_Tests, self).setUp()
self.task = BuyRandomPremiumChest(account_id=self.account.id,
transaction=self.transaction)
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.cmd_update_with_account_data__call_count = 0
self.accounts_manages_worker = False
self.supervisor_worker = True
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.hero.energy_bonus = 0
def _get_expected_arguments(self):
return {}
def _check_not_used(self):
self.assertEqual(self.hero.energy_bonus, 0)
self.assertEqual(RandomPremiumRequestPrototype._db_count(), 0)
def _check_used(self):
self.assertEqual(self.hero.energy_bonus, relations.RANDOM_PREMIUM_CHEST_REWARD.ENERGY.arguments['energy'])
self.assertEqual(RandomPremiumRequestPrototype._db_count(), 1)
class LevelUpTest(testcase.TestCase, CardsTestMixin):
CARD = LevelUp
def setUp(self):
super(LevelUpTest, self).setUp()
create_test_map()
result, account_1_id, bundle_id = register_user(
'test_user', '*****@*****.**', '111111')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
def test_use(self):
self.hero.add_experience(self.hero.experience_to_next_level / 2)
self.assertTrue(self.hero.experience > 0)
self.assertEqual(self.hero.level, 1)
with self.check_not_changed(lambda: self.hero.experience):
with self.check_delta(lambda: self.hero.level, 1):
result, step, postsave_actions = self.card.use(
**self.use_attributes(storage=self.storage,
hero=self.hero))
self.assertEqual((result, step, postsave_actions),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
def test_initialize_bots__second_create(self):
account_1 = self.accounts_factory.create_account()
account_2 = self.accounts_factory.create_account(is_bot=True)
storage = LogicStorage()
storage.load_account_data(account_1)
storage.load_account_data(account_2)
hero_1 = storage.accounts_to_heroes[account_1.id]
hero_2 = storage.accounts_to_heroes[account_2.id]
hero_1.level = 50
self.assertEqual(hero_2.level, 1)
self.pvp_create_battle(account_1, account_2,
BATTLE_1X1_STATE.PROCESSING)
self.pvp_create_battle(account_2, account_1,
BATTLE_1X1_STATE.PROCESSING)
meta_action = meta_actions.ArenaPvP1x1.create(storage, hero_1, hero_2)
meta_action.process_battle_ending()
meta_actions.ArenaPvP1x1.create(storage, hero_1, hero_2)
self.assertEqual(hero_2.level, 50)
self.assertTrue(len(hero_2.abilities.all) > 1)
self.assertEqual(hero_2.health, hero_2.max_health)
class LevelUpTest(testcase.TestCase, CardsTestMixin):
CARD = cards.CARD.LEVEL_UP
def setUp(self):
super(LevelUpTest, self).setUp()
create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.abilities = self.hero.abilities
def test_use(self):
self.hero.add_experience(self.hero.experience_to_next_level / 2)
self.assertTrue(self.hero.experience > 0)
self.assertEqual(self.hero.level, 1)
with self.check_not_changed(lambda: self.hero.experience):
with self.check_delta(lambda: self.hero.level, 1):
result, step, postsave_actions = self.CARD.effect.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ()))
saved_hero = heroes_logic.load_hero(hero_id=self.hero.id)
self.assertEqual(saved_hero.abilities.destiny_points, self.abilities.destiny_points)
class HelpPlaceMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(HelpPlaceMixin, self).setUp()
self.place_1, self.place_2, self.place_3 = create_test_map()
result, account_1_id, bundle_id = register_user('test_user', '*****@*****.**', '111111')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
def test_use(self):
with self.check_delta(lambda: self.hero.places_history._get_places_statisitcs().get(self.place_1.id, 0), self.CARD.HELPS):
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero, place_id=self.place_1.id))
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ()))
def test_wrong_place(self):
with self.check_not_changed(lambda: self.hero.places_history._get_places_statisitcs().get(self.place_1.id, 0)):
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero, place_id=666))
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR, ()))
class QuestsTestBase(testcase.TestCase):
def setUp(self):
super(QuestsTestBase, self).setUp()
self.p1, self.p2, self.p3 = create_test_map()
# add more persons, to lower conflicts
places_logic.add_person_to_place(self.p1)
places_logic.add_person_to_place(self.p1)
places_logic.add_person_to_place(self.p2)
places_logic.add_person_to_place(self.p2)
places_logic.add_person_to_place(self.p3)
places_logic.add_person_to_place(self.p3)
account = self.accounts_factory.create_account(is_fast=True)
self.storage = LogicStorage()
self.storage.load_account_data(account)
self.hero = self.storage.accounts_to_heroes[account.id]
self.action_idl = self.hero.actions.current_action
self.hero.money += 1
self.hero.preferences.set(heroes_relations.PREFERENCE_TYPE.MOB, mobs_storage.mobs.all()[0])
self.hero.preferences.set(heroes_relations.PREFERENCE_TYPE.PLACE, self.p1)
self.hero.preferences.set(heroes_relations.PREFERENCE_TYPE.FRIEND, self.p1.persons[0])
self.hero.preferences.set(heroes_relations.PREFERENCE_TYPE.ENEMY, self.p2.persons[0])
self.hero.preferences.set(heroes_relations.PREFERENCE_TYPE.EQUIPMENT_SLOT, heroes_relations.EQUIPMENT_SLOT.PLATE)
self.hero.position.set_place(self.p3)
heroes_logic.save_hero(self.hero)
self.p2.set_modifier(places_modifiers.CITY_MODIFIERS.HOLY_CITY)
places_logic.save_place(self.p2)
self.p1.persons[0].type = PERSON_TYPE.BLACKSMITH
persons_logic.save_person(self.p1.persons[0])
class ResetPreferenceMinix(CardsTestMixin):
CARD = None
def setUp(self):
super(ResetPreferenceMinix, self).setUp()
create_test_map()
result, account_1_id, bundle_id = register_user(
'test_user', '*****@*****.**', '111111')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.hero.preferences._set(
self.CARD.PREFERENCE,
self.hero.preferences._get(self.CARD.PREFERENCE))
self.card = self.CARD()
@mock.patch(
'the_tale.game.heroes.preferences.HeroPreferences.is_available',
lambda self, preference_type, account: True)
def test_use(self):
self.assertFalse(
self.hero.preferences.can_update(self.CARD.PREFERENCE,
datetime.datetime.now()))
result, step, postsave_actions = self.card.use(
**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual((result, step, postsave_actions),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
self.assertTrue(
self.hero.preferences.can_update(self.CARD.PREFERENCE,
datetime.datetime.now()))
@mock.patch(
'the_tale.game.heroes.preferences.HeroPreferences.is_available',
lambda self, preference_type, account: False)
def test_not_available(self):
self.assertFalse(
self.hero.preferences.can_update(self.CARD.PREFERENCE,
datetime.datetime.now()))
result, step, postsave_actions = self.card.use(
**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(
(result, step, postsave_actions),
(ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR,
()))
self.assertFalse(
self.hero.preferences.can_update(self.CARD.PREFERENCE,
datetime.datetime.now()))
class LevelUpTest(testcase.TestCase, CardsTestMixin):
CARD = LevelUp
def setUp(self):
super(LevelUpTest, self).setUp()
create_test_map()
result, account_1_id, bundle_id = register_user('test_user', '*****@*****.**', '111111')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
def test_use(self):
self.hero.add_experience(self.hero.experience_to_next_level / 2)
self.assertTrue(self.hero.experience > 0)
self.assertEqual(self.hero.level, 1)
with self.check_not_changed(lambda: self.hero.experience):
with self.check_delta(lambda: self.hero.level, 1):
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ()))
class SharpAllArtifactsTests(CardsTestMixin, testcase.TestCase):
CARD = effects.SharpAllArtifacts
def setUp(self):
super(SharpAllArtifactsTests, self).setUp()
create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
def test_use(self):
with self.check_delta(lambda: self.hero.equipment.get_power().total(),
len(list(self.hero.equipment.values()))):
result, step, postsave_actions = self.card.use(
**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual((result, step, postsave_actions),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
def test_initialize_bots__second_create(self):
result, account_1_id, bundle_id = register_user("test_user_3")
result, account_2_id, bundle_id = register_user("bot", "*****@*****.**", "111111", is_bot=True)
account_1 = AccountPrototype.get_by_id(account_1_id)
account_2 = AccountPrototype.get_by_id(account_2_id)
storage = LogicStorage()
storage.load_account_data(account_1)
storage.load_account_data(account_2)
hero_1 = storage.accounts_to_heroes[account_1.id]
hero_2 = storage.accounts_to_heroes[account_2.id]
hero_1._model.level = 50
self.assertEqual(hero_2.level, 1)
self.pvp_create_battle(account_1, account_2, BATTLE_1X1_STATE.PROCESSING)
self.pvp_create_battle(account_2, account_1, BATTLE_1X1_STATE.PROCESSING)
meta_action = MetaActionArenaPvP1x1Prototype.create(storage, hero_1, hero_2, bundle_id=self.bundle_id + 1)
meta_action.process_battle_ending()
MetaActionArenaPvP1x1Prototype.create(storage, hero_1, hero_2, bundle_id=self.bundle_id + 2)
self.assertEqual(hero_2.level, 50)
self.assertTrue(len(hero_2.abilities.all) > 1)
self.assertEqual(hero_2.health, hero_2.max_health)
class HeroPreferencesCompanionDedicationTest(TestCase):
PREFERENCE_TYPE = relations.PREFERENCE_TYPE.COMPANION_DEDICATION
def setUp(self):
super(HeroPreferencesCompanionDedicationTest, self).setUp()
create_test_map()
self.account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.hero.level = relations.PREFERENCE_TYPE.COMPANION_DEDICATION.level_required
logic.save_hero(self.hero)
self.egoism = relations.COMPANION_DEDICATION.EGOISM
self.altruism = relations.COMPANION_DEDICATION.ALTRUISM
def test_initialization(self):
self.assertTrue(self.hero.preferences.companion_dedication.is_NORMAL)
def test_preferences_serialization(self):
self.hero.preferences.set(
relations.PREFERENCE_TYPE.COMPANION_DEDICATION, self.egoism)
data = self.hero.preferences.serialize()
self.assertEqual(data, HeroPreferences.deserialize(data).serialize())
def test_save(self):
self.hero.preferences.set(
relations.PREFERENCE_TYPE.COMPANION_DEDICATION, self.egoism)
logic.save_hero(self.hero)
self.hero = logic.load_hero(hero_id=self.hero.id)
self.assertEqual(self.hero.preferences.companion_dedication,
self.egoism)
def test_process_bot__flame_ability_not_used(self):
result, account_1_id, bundle_id = register_user("bot", "*****@*****.**", "111111", is_bot=True)
result, account_2_id, bundle_id = register_user("test_user_3")
account_1 = AccountPrototype.get_by_id(account_1_id)
account_2 = AccountPrototype.get_by_id(account_2_id)
storage = LogicStorage()
storage.load_account_data(account_1)
storage.load_account_data(account_2)
hero_1 = storage.accounts_to_heroes[account_1.id]
hero_2 = storage.accounts_to_heroes[account_2.id]
MetaActionArenaPvP1x1Prototype.create(storage, hero_1, hero_2, bundle_id=self.bundle_id + 1)
self.assertEqual(hero_2.pvp.energy_speed, 1)
with mock.patch(
"the_tale.game.actions.meta_actions.MetaActionArenaPvP1x1Prototype.get_bot_pvp_properties",
lambda a: {"priorities": {Flame.TYPE: 1}, "ability_chance": 1},
):
with mock.patch("the_tale.game.pvp.abilities.Flame.use") as use:
for i in xrange(100):
self.meta_action_battle.process_bot(hero_1, hero_2)
self.assertEqual(use.call_count, 0)
class ResetPreferenceAllTests(CardsTestMixin, testcase.TestCase):
CARD = effects.PreferencesCooldownsResetAll
def setUp(self):
super(ResetPreferenceAllTests, self).setUp()
create_test_map()
result, account_1_id, bundle_id = register_user("test_user", "*****@*****.**", "111111")
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
for preference in PREFERENCE_TYPE.records:
self.hero.preferences._set(preference, self.hero.preferences._get(preference))
self.card = self.CARD()
def test_use(self):
for preference in PREFERENCE_TYPE.records:
self.assertFalse(self.hero.preferences.can_update(preference, datetime.datetime.now()))
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(
(result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ())
)
for preference in PREFERENCE_TYPE.records:
self.assertTrue(self.hero.preferences.can_update(preference, datetime.datetime.now()))
def test_load_account_data(self):
self.assertEqual(len(self.storage.heroes), 2)
self.assertEqual(len(self.storage.accounts_to_heroes), 2)
self.assertEqual(
self.storage.bundles_to_accounts, {
self.hero_1.actions.current_action.bundle_id:
set([self.account_1.id]),
self.hero_2.actions.current_action.bundle_id:
set([self.account_2.id])
})
action_regenerate = actions_prototypes.ActionRegenerateEnergyPrototype.create(
hero=self.hero_1)
self.assertEqual(self.action_idl_1.storage, self.storage)
self.assertEqual(action_regenerate.storage, self.storage)
storage = LogicStorage()
storage.load_account_data(AccountPrototype.get_by_id(
self.account_1.id))
storage.load_account_data(AccountPrototype.get_by_id(
self.account_2.id))
self.assertEqual(len(storage.heroes), 2)
self.assertEqual(len(storage.accounts_to_heroes), 2)
self.assertEqual(
storage.bundles_to_accounts, {
self.hero_1.actions.current_action.bundle_id:
set([self.account_1.id]),
self.hero_2.actions.current_action.bundle_id:
set([self.account_2.id])
})
class ArenaPvP1x1AcceptBaseTests(UseAbilityTaskMixin, testcase.TestCase):
def setUp(self):
super(ArenaPvP1x1AcceptBaseTests, self).setUp()
self.p1, self.p2, self.p3 = create_test_map()
result, account_1_id, bundle_id = register_user('test_user', '*****@*****.**', '111111')
result, account_2_id, bundle_id = register_user('test_user_2', '*****@*****.**', '111111')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.account_2 = AccountPrototype.get_by_id(account_2_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.storage.load_account_data(self.account_2)
self.hero_1 = self.storage.accounts_to_heroes[self.account_1.id]
self.hero_2 = self.storage.accounts_to_heroes[self.account_2.id]
environment.deinitialize()
environment.initialize()
self.pvp_balancer = environment.workers.pvp_balancer
self.pvp_balancer.process_initialize('pvp_balancer')
self.battle = self.pvp_balancer.add_to_arena_queue(self.hero_1.id)
class ChooseRequestsTests(testcase.TestCase, QuestTestsMixin):
def setUp(self):
super(ChooseRequestsTests, self).setUp()
create_test_map()
register_user('test_user', '*****@*****.**', '111111')
account = AccountPrototype.get_by_email('*****@*****.**')
self.storage = LogicStorage()
self.storage.load_account_data(AccountPrototype.get_by_id(account.id))
self.hero =self.storage.accounts_to_heroes[account.id]
self.choice_uid = '[ns-0]choice_1'
self.option_uid = '#option<[ns-0]choice_1, [ns-0]choice_2>'
@mock.patch('questgen.quests.quests_base.QuestsBase._available_quests', lambda *argv, **kwargs: [QuestWith2ChoicePoints])
def test_choose_no_account(self):
self.turn_to_quest(self.storage, self.hero.id)
response = self.client.post(url('game:quests:api-choose', option_uid=self.option_uid, api_version='1.0', api_client=project_settings.API_CLIENT))
self.check_ajax_error(response, 'common.login_required')
@mock.patch('questgen.quests.quests_base.QuestsBase._available_quests', lambda *argv, **kwargs: [QuestWith2ChoicePoints])
def test_choose_processing(self):
self.turn_to_quest(self.storage, self.hero.id)
self.request_login('*****@*****.**')
response = self.client.post(url('game:quests:api-choose', option_uid=self.option_uid, api_version='1.0', api_client=project_settings.API_CLIENT))
task = PostponedTaskPrototype._db_get_object(0)
self.check_ajax_processing(response, task.status_url)
self.assertEqual(PostponedTask.objects.all().count(), 1)
class GetCompanionCreateTests(testcase.TestCase):
def setUp(self):
super(GetCompanionCreateTests, self).setUp()
create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.disabled_companion = companions_logic.create_random_companion_record('disbled')
self.manual_companion = companions_logic.create_random_companion_record('manual', mode=companions_relations.MODE.MANUAL)
self.effect = effects.GetCompanionCommon()
def test__no_disabled_companions(self):
for i in range(100):
card = self.effect.create_card(available_for_auction=True)
self.assertNotEqual(card.data['companion_id'], self.disabled_companion.id)
self.assertTrue(companions_storage.companions[card.data['companion_id']].state.is_ENABLED)
def test__no_manual_companions(self):
for i in range(100):
card = self.effect.create_card(available_for_auction=True)
self.assertNotEqual(card.data['companion_id'], self.manual_companion.id)
self.assertTrue(companions_storage.companions[card.data['companion_id']].mode.is_AUTOMATIC)
def test_load_account_data_with_meta_action(self):
bundle_id = 666
meta_action_battle = meta_actions.ArenaPvP1x1.create(
self.storage, self.hero_1, self.hero_2)
proxy_action_1 = actions_prototypes.ActionMetaProxyPrototype.create(
hero=self.hero_1,
_bundle_id=bundle_id,
meta_action=meta_action_battle)
proxy_action_2 = actions_prototypes.ActionMetaProxyPrototype.create(
hero=self.hero_2,
_bundle_id=bundle_id,
meta_action=meta_action_battle)
self.assertEqual(len(self.storage.meta_actions), 1)
self.assertEqual(len(self.storage.meta_actions_to_actions), 1)
self.assertEqual(
self.storage.meta_actions_to_actions[meta_action_battle.uid],
set([
LogicStorage.get_action_uid(proxy_action_1),
LogicStorage.get_action_uid(proxy_action_2)
]))
self.storage.save_changed_data()
self.assertIs(self.hero_1.actions.current_action.meta_action,
self.hero_2.actions.current_action.meta_action)
self.assertIs(self.hero_1.actions.current_action.saved_meta_action,
self.hero_2.actions.current_action.saved_meta_action)
storage = LogicStorage()
storage.load_account_data(self.account_1)
storage.load_account_data(self.account_2)
self.assertEqual(len(storage.meta_actions), 1)
self.assertEqual(len(storage.meta_actions_to_actions), 1)
self.assertEqual(
storage.meta_actions_to_actions[meta_action_battle.uid],
set([
LogicStorage.get_action_uid(proxy_action_1),
LogicStorage.get_action_uid(proxy_action_2)
]))
self.assertEqual(
storage.bundles_to_accounts, {
self.hero_1.actions.current_action.bundle_id:
set([self.account_1.id, self.account_2.id])
})
hero_1 = storage.accounts_to_heroes[self.account_1.id]
hero_2 = storage.accounts_to_heroes[self.account_2.id]
self.assertIs(hero_1.actions.current_action.meta_action,
hero_2.actions.current_action.meta_action)
self.assertIsNot(hero_1.actions.current_action.saved_meta_action,
hero_2.actions.current_action.saved_meta_action)
self.assertEqual(
hero_1.actions.current_action.saved_meta_action.serialize(),
hero_2.actions.current_action.saved_meta_action.serialize())
class PrototypesTests(TestCase):
def setUp(self):
super(PrototypesTests, self).setUp()
create_test_map()
self.account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.ability = ABILITIES[ABILITY_TYPE.HELP]()
self.task_data = {}
def test_activate__no_energy(self):
energy = tt_api_energy.energy_balance(self.account.id)
tt_api_energy.change_energy_balance(account_id=self.account.id,
type='test',
energy=-energy,
autocommit=True)
task = self.ability.activate(self.hero, self.task_data)
self.assertEqual(task, None)
def test_activate__has_energy(self):
task = self.ability.activate(self.hero, self.task_data)
self.assertNotEqual(task.internal_logic.data['transaction_id'], None)
@mock.patch('the_tale.game.abilities.relations.ABILITY_TYPE.HELP.cost', 0)
def test_activate_and_complete__zero_cost(self):
energy = tt_api_energy.energy_balance(self.account.id)
tt_api_energy.change_energy_balance(account_id=self.account.id,
type='test',
energy=-energy,
autocommit=True)
task = self.ability.activate(self.hero, self.task_data)
self.assertEqual(task.internal_logic.data['transaction_id'], None)
task.process(FakePostpondTaskPrototype(), storage=self.storage)
self.assertTrue(task.state.is_processed)
self.assertEqual(tt_api_energy.energy_balance(self.account.id), 0)
def test_activate_and_complete(self):
energy = tt_api_energy.energy_balance(self.account.id)
task = self.ability.activate(self.hero, self.task_data)
self.assertNotEqual(task.internal_logic.data['transaction_id'], None)
self.assertEqual(tt_api_energy.energy_balance(self.account.id),
energy - self.ability.TYPE.cost)
task.process(FakePostpondTaskPrototype(), storage=self.storage)
self.assertTrue(task.state.is_processed)
self.assertEqual(tt_api_energy.energy_balance(self.account.id),
energy - self.ability.TYPE.cost)
class AddBonusEnergyTestMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(AddBonusEnergyTestMixin, self).setUp()
create_test_map()
result, account_1_id, bundle_id = register_user(
'test_user', '*****@*****.**', '111111')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
def test_use(self):
with self.check_delta(lambda: self.hero.energy_bonus,
self.CARD.ENERGY):
result, step, postsave_actions = self.card.use(
**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual((result, step, postsave_actions),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
class GiveCommonCardsMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(GiveCommonCardsMixin, self).setUp()
create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
tt_api.debug_clear_service()
def prepair_data(self, available_for_auction):
card = self.CARD.effect.create_card(
type=self.CARD, available_for_auction=available_for_auction)
self.assertEqual(tt_api.load_cards(self.account_1.id), {})
return card
def check_give(self, available_for_auction):
cards = tt_api.load_cards(self.account_1.id)
self.assertEqual(len(cards), self.CARD.effect.upper_modificator)
self.assertTrue(
all(card.type.rarity.is_COMMON for card in cards.values()))
self.assertTrue(
all(card.available_for_auction == available_for_auction
for card in cards.values()))
def test_use__available_for_auction(self):
card = self.prepair_data(available_for_auction=True)
result, step, postsave_actions = self.CARD.effect.use(
**self.use_attributes(
storage=self.storage, hero=self.hero, card=card))
self.assertEqual((result, step, postsave_actions),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
self.check_give(available_for_auction=True)
def test_use__has_companion__not_available_for_auction(self):
card = self.prepair_data(available_for_auction=False)
result, step, postsave_actions = self.CARD.effect.use(
**self.use_attributes(
storage=self.storage, hero=self.hero, card=card))
self.assertEqual((result, step, postsave_actions),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
self.check_give(available_for_auction=False)
class HeroPreferencesEnergyRegenerationTypeTest(TestCase):
PREFERENCE_TYPE = relations.PREFERENCE_TYPE.ENERGY_REGENERATION_TYPE
def setUp(self):
super(HeroPreferencesEnergyRegenerationTypeTest, self).setUp()
create_test_map()
self.account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.hero.level = relations.PREFERENCE_TYPE.ENERGY_REGENERATION_TYPE.level_required
self.hero.preferences.set(
relations.PREFERENCE_TYPE.ENERGY_REGENERATION_TYPE,
relations.ENERGY_REGENERATION.SACRIFICE)
logic.save_hero(self.hero)
def test_preferences_serialization(self):
data = self.hero.preferences.serialize()
self.assertEqual(data, HeroPreferences.deserialize(data).serialize())
def test_save(self):
self.hero.preferences.set(
relations.PREFERENCE_TYPE.ENERGY_REGENERATION_TYPE,
relations.ENERGY_REGENERATION.PRAY)
logic.save_hero(self.hero)
self.hero = logic.load_hero(hero_id=self.hero.id)
self.assertEqual(self.hero.preferences.energy_regeneration_type,
relations.ENERGY_REGENERATION.PRAY)
class TestsBase(testcase.TestCase):
def setUp(self):
super(TestsBase, self).setUp()
create_test_map()
account = self.accounts_factory.create_account(is_fast=True)
self.storage = LogicStorage()
self.storage.load_account_data(account)
self.hero = self.storage.accounts_to_heroes[account.id]
def get_actors(self):
mob = mobs_storage.get_random_mob(self.hero)
actor_1 = battle.Actor(self.hero, BattleContext())
actor_2 = battle.Actor(mob, BattleContext())
return actor_1, actor_2
def set_hero_companion(self):
companion_record = next(companions_storage.companions.enabled_companions())
companion = companions_logic.create_companion(companion_record)
self.hero.set_companion(companion)
class HeroPreferencesFavoriteItemTest(TestCase):
PREFERENCE_TYPE = relations.PREFERENCE_TYPE.FAVORITE_ITEM
def setUp(self):
super(HeroPreferencesFavoriteItemTest, self).setUp()
create_test_map()
self.account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.hero.level = relations.PREFERENCE_TYPE.FAVORITE_ITEM.level_required
logic.save_hero(self.hero)
self.slot_1 = relations.EQUIPMENT_SLOT.HAND_PRIMARY
self.slot_2 = relations.EQUIPMENT_SLOT.PLATE
def test_preferences_serialization(self):
self.hero.preferences.set(relations.PREFERENCE_TYPE.FAVORITE_ITEM,
self.slot_1)
data = self.hero.preferences.serialize()
self.assertEqual(data, HeroPreferences.deserialize(data).serialize())
def test_save(self):
self.hero.preferences.set(relations.PREFERENCE_TYPE.FAVORITE_ITEM,
self.slot_1)
logic.save_hero(self.hero)
self.hero = logic.load_hero(hero_id=self.hero.id)
self.assertEqual(self.hero.preferences.favorite_item, self.slot_1)
class ArenaPvP1x1AcceptBaseTests(UseAbilityTaskMixin, testcase.TestCase):
def setUp(self):
super(ArenaPvP1x1AcceptBaseTests, self).setUp()
self.p1, self.p2, self.p3 = create_test_map()
result, account_1_id, bundle_id = register_user(
'test_user', '*****@*****.**', '111111')
result, account_2_id, bundle_id = register_user(
'test_user_2', '*****@*****.**', '111111')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.account_2 = AccountPrototype.get_by_id(account_2_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.storage.load_account_data(self.account_2)
self.hero_1 = self.storage.accounts_to_heroes[self.account_1.id]
self.hero_2 = self.storage.accounts_to_heroes[self.account_2.id]
environment.deinitialize()
environment.initialize()
self.pvp_balancer = environment.workers.pvp_balancer
self.pvp_balancer.process_initialize('pvp_balancer')
self.battle = self.pvp_balancer.add_to_arena_queue(self.hero_1.id)
class HeroPreferencesRiskLevelTest(TestCase):
PREFERENCE_TYPE = relations.PREFERENCE_TYPE.RISK_LEVEL
def setUp(self):
super(HeroPreferencesRiskLevelTest, self).setUp()
create_test_map()
self.account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.hero.level = relations.PREFERENCE_TYPE.RISK_LEVEL.level_required
logic.save_hero(self.hero)
self.risk_1 = relations.RISK_LEVEL.VERY_HIGH
self.risk_2 = relations.RISK_LEVEL.VERY_LOW
def test_preferences_serialization(self):
self.hero.preferences.set(relations.PREFERENCE_TYPE.RISK_LEVEL,
self.risk_1)
data = self.hero.preferences.serialize()
self.assertEqual(data, HeroPreferences.deserialize(data).serialize())
def test_save(self):
self.hero.preferences.set(relations.PREFERENCE_TYPE.RISK_LEVEL,
self.risk_1)
logic.save_hero(self.hero)
self.hero = logic.load_hero(hero_id=self.hero.id)
self.assertEqual(self.hero.preferences.risk_level, self.risk_1)
def test_initialize_bots__bot_is_first(self):
result, account_1_id, bundle_id = register_user('bot',
'*****@*****.**',
'111111',
is_bot=True)
result, account_2_id, bundle_id = register_user('test_user_3')
account_1 = AccountPrototype.get_by_id(account_1_id)
account_2 = AccountPrototype.get_by_id(account_2_id)
storage = LogicStorage()
storage.load_account_data(account_1)
storage.load_account_data(account_2)
hero_1 = storage.accounts_to_heroes[account_1.id]
hero_2 = storage.accounts_to_heroes[account_2.id]
hero_2._model.level = 50
self.assertEqual(hero_1.level, 1)
MetaActionArenaPvP1x1Prototype.create(storage,
hero_1,
hero_2,
bundle_id=self.bundle_id + 1)
self.assertEqual(hero_1.level, 50)
self.assertTrue(len(hero_1.abilities.all) > 1)
self.assertEqual(hero_1.health, hero_1.max_health)
class HeroPreferencesArchetypeTest(TestCase):
PREFERENCE_TYPE = relations.PREFERENCE_TYPE.ARCHETYPE
def setUp(self):
super(HeroPreferencesArchetypeTest, self).setUp()
create_test_map()
self.account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.hero.level = relations.PREFERENCE_TYPE.ARCHETYPE.level_required
logic.save_hero(self.hero)
self.mage = game_relations.ARCHETYPE.MAGICAL
self.warior = game_relations.ARCHETYPE.PHYSICAL
def test_preferences_serialization(self):
self.hero.preferences.set(relations.PREFERENCE_TYPE.ARCHETYPE,
self.mage)
data = self.hero.preferences.serialize()
self.assertEqual(data, HeroPreferences.deserialize(data).serialize())
def test_save(self):
self.hero.preferences.set(relations.PREFERENCE_TYPE.ARCHETYPE,
self.mage)
logic.save_hero(self.hero)
self.hero = logic.load_hero(hero_id=self.hero.id)
self.assertEqual(self.hero.preferences.archetype, self.mage)
def test_load_account_data_with_meta_action(self):
bundle_id = 666
meta_action_battle = meta_actions.ArenaPvP1x1.create(self.storage, self.hero_1, self.hero_2)
proxy_action_1 = actions_prototypes.ActionMetaProxyPrototype.create(hero=self.hero_1, _bundle_id=bundle_id, meta_action=meta_action_battle)
proxy_action_2 = actions_prototypes.ActionMetaProxyPrototype.create(hero=self.hero_2, _bundle_id=bundle_id, meta_action=meta_action_battle)
self.assertEqual(len(self.storage.meta_actions), 1)
self.assertEqual(len(self.storage.meta_actions_to_actions), 1)
self.assertEqual(self.storage.meta_actions_to_actions[meta_action_battle.uid], set([LogicStorage.get_action_uid(proxy_action_1),
LogicStorage.get_action_uid(proxy_action_2)]))
self.storage.save_changed_data()
self.assertIs(self.hero_1.actions.current_action.meta_action, self.hero_2.actions.current_action.meta_action)
self.assertIs(self.hero_1.actions.current_action.saved_meta_action, self.hero_2.actions.current_action.saved_meta_action)
storage = LogicStorage()
storage.load_account_data(AccountPrototype.get_by_id(self.account_1.id))
storage.load_account_data(AccountPrototype.get_by_id(self.account_2.id))
self.assertEqual(len(storage.meta_actions), 1)
self.assertEqual(len(storage.meta_actions_to_actions), 1)
self.assertEqual(storage.meta_actions_to_actions[meta_action_battle.uid], set([LogicStorage.get_action_uid(proxy_action_1),
LogicStorage.get_action_uid(proxy_action_2)]))
self.assertEqual(storage.bundles_to_accounts, {self.hero_1.actions.current_action.bundle_id: set([self.account_1.id, self.account_2.id])})
hero_1 = storage.accounts_to_heroes[self.account_1.id]
hero_2 = storage.accounts_to_heroes[self.account_2.id]
self.assertIs(hero_1.actions.current_action.meta_action, hero_2.actions.current_action.meta_action)
self.assertIsNot(hero_1.actions.current_action.saved_meta_action, hero_2.actions.current_action.saved_meta_action)
self.assertEqual(hero_1.actions.current_action.saved_meta_action.serialize(), hero_2.actions.current_action.saved_meta_action.serialize())
class BuyRandomPremiumChestTask__Energy_Tests(
base_buy_task._BaseBuyHeroMethodPosponedTaskTests):
def setUp(self):
super(BuyRandomPremiumChestTask__Energy_Tests, self).setUp()
self.task = BuyRandomPremiumChest(account_id=self.account.id,
transaction=self.transaction)
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.cmd_update_with_account_data__call_count = 0
self.accounts_manages_worker = False
self.supervisor_worker = True
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.hero.energy_bonus = 0
def _get_expected_arguments(self):
return {}
def _check_not_used(self):
self.assertEqual(self.hero.energy_bonus, 0)
self.assertEqual(RandomPremiumRequestPrototype._db_count(), 0)
def _check_used(self):
self.assertEqual(
self.hero.energy_bonus,
relations.RANDOM_PREMIUM_CHEST_REWARD.ENERGY.arguments['energy'])
self.assertEqual(RandomPremiumRequestPrototype._db_count(), 1)
class DropItemAbilityTest(UseAbilityTaskMixin, testcase.TestCase):
PROCESSOR = DropItem
def setUp(self):
super(DropItemAbilityTest, self).setUp()
create_test_map()
self.account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.ability = self.PROCESSOR()
@property
def use_attributes(self):
return super(DropItemAbilityTest,
self).use_attributes(hero=self.hero, storage=self.storage)
def test_no_items(self):
self.assertEqual(self.hero.bag.occupation, 0)
self.assertEqual(
self.ability.use(**self.use_attributes),
(ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR,
()))
def test_success(self):
self.hero.bag.put_artifact(
artifacts_storage.artifacts.generate_artifact_from_list(
artifacts_storage.artifacts.artifacts,
self.hero.level,
rarity=RARITY.NORMAL))
with self.check_delta(lambda: self.hero.bag.occupation, -1):
self.assertEqual(self.ability.use(**self.use_attributes),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
@mock.patch('the_tale.game.heroes.objects.Hero.might_crit_chance', 1)
def test_success__critical(self):
self.hero.bag.put_artifact(
artifacts_storage.artifacts.generate_artifact_from_list(
artifacts_storage.artifacts.artifacts,
self.hero.level,
rarity=RARITY.NORMAL))
old_money_stats = self.hero.statistics.money_earned_from_help
self.assertEqual(self.hero.bag.occupation, 1)
self.assertEqual(self.ability.use(**self.use_attributes),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
self.assertEqual(self.hero.bag.occupation, 0)
self.assertTrue(
old_money_stats < self.hero.statistics.money_earned_from_help)
class BaseEffectsTests(testcase.TestCase):
def setUp(self):
super(BaseEffectsTests, self).setUp()
create_test_map()
self.account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.companion_record = logic.create_companion_record(
utg_name=names.generator().get_test_name(),
description='description',
type=beings_relations.TYPE.random(),
max_health=10,
dedication=relations.DEDICATION.random(),
archetype=game_relations.ARCHETYPE.random(),
mode=relations.MODE.random(),
abilities=abilities_container.Container(),
communication_verbal=beings_relations.COMMUNICATION_VERBAL.random(
),
communication_gestures=beings_relations.COMMUNICATION_GESTURES.
random(),
communication_telepathic=beings_relations.COMMUNICATION_TELEPATHIC.
random(),
intellect_level=beings_relations.INTELLECT_LEVEL.random(),
structure=beings_relations.STRUCTURE.random(),
features=frozenset((beings_relations.FEATURE.random(),
beings_relations.FEATURE.random())),
movement=beings_relations.MOVEMENT.random(),
body=beings_relations.BODY.random(),
size=beings_relations.SIZE.random(),
orientation=beings_relations.ORIENTATION.random(),
weapons=[
artifacts_objects.Weapon(
weapon=artifacts_relations.STANDARD_WEAPON.random(),
material=tt_artifacts_relations.MATERIAL.random(),
power_type=artifacts_relations.ARTIFACT_POWER_TYPE.random(
))
],
state=relations.STATE.ENABLED)
self.hero.set_companion(logic.create_companion(self.companion_record))
def apply_ability(self, ability):
container = abilities_container.Container(common=(),
start=frozenset((ability, )),
coherence=None,
honor=None,
peacefulness=None)
self.companion_record.abilities = container
self.hero.reset_accessors_cache()
def get_ability(self, *argv):
return random.choice([
ability for ability in effects.ABILITIES.records if any(
isinstance(ability.effect, effect) for effect in argv)
])
class ChangeHabitTestMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(ChangeHabitTestMixin, self).setUp()
create_test_map()
result, account_1_id, bundle_id = register_user(
'test_user', '*****@*****.**', '111111')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
def habit_value(self):
if self.card.HABIT.is_HONOR:
return self.hero.habit_honor.raw_value
if self.card.HABIT.is_PEACEFULNESS:
return self.hero.habit_peacefulness.raw_value
def test_use(self):
self.hero.change_habits(
HABIT_TYPE.HONOR,
-c.HABITS_BORDER if self.CARD.POINTS > 0 else c.HABITS_BORDER)
self.hero.change_habits(
HABIT_TYPE.PEACEFULNESS,
-c.HABITS_BORDER if self.CARD.POINTS > 0 else c.HABITS_BORDER)
with self.check_delta(self.habit_value, self.CARD.POINTS):
result, step, postsave_actions = self.card.use(
**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual((result, step, postsave_actions),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
def test_no_effect(self):
self.hero.change_habits(
HABIT_TYPE.HONOR,
-c.HABITS_BORDER if self.CARD.POINTS < 0 else c.HABITS_BORDER)
self.hero.change_habits(
HABIT_TYPE.PEACEFULNESS,
-c.HABITS_BORDER if self.CARD.POINTS < 0 else c.HABITS_BORDER)
with self.check_not_changed(self.habit_value):
result, step, postsave_actions = self.card.use(
**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(
(result, step, postsave_actions),
(ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR,
()))
class RepairRandomArtifactTests(RepairArtifacsTestMixin, testcase.TestCase):
CARD = effects.RepairRandomArtifact
def setUp(self):
super(RepairRandomArtifactTests, self).setUp()
create_test_map()
result, account_1_id, bundle_id = register_user(
'test_user', '*****@*****.**', '111111')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
def test_all_repaired(self):
self.check_all_equipment_repaired(True)
result, step, postsave_actions = self.card.use(
**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(
(result, step, postsave_actions),
(ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR,
()))
self.check_all_equipment_repaired(True)
def test_use(self):
self.check_all_equipment_repaired(True)
items = [item for item in self.hero.equipment.values() if item]
random.shuffle(items)
items[0].integrity = 0
items[1].integrity = 0
self.check_all_equipment_repaired(False)
result, step, postsave_actions = self.card.use(
**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual((result, step, postsave_actions),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
self.check_all_equipment_repaired(False)
result, step, postsave_actions = self.card.use(
**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual((result, step, postsave_actions),
(ComplexChangeTask.RESULT.SUCCESSED,
ComplexChangeTask.STEP.SUCCESS, ()))
self.check_all_equipment_repaired(True)
class LongTeleportTests(CardsTestMixin, testcase.TestCase):
CARD = effects.LongTeleport
def setUp(self):
super(LongTeleportTests, self).setUp()
self.place_1, self.place_2, self.place_3 = create_test_map()
result, account_1_id, bundle_id = register_user("test_user", "*****@*****.**", "111111")
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.hero.position.set_place(self.place_1)
self.card = self.CARD()
@mock.patch("the_tale.game.heroes.objects.Hero.is_battle_start_needed", lambda self: False)
def test_moving(self):
self.assertFalse(self.hero.actions.current_action.TYPE.is_MOVE_TO)
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(
(result, step, postsave_actions), (ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR, ())
)
@mock.patch("the_tale.game.heroes.objects.Hero.is_battle_start_needed", lambda self: False)
def test_use(self):
actions_prototypes.ActionMoveToPrototype.create(hero=self.hero, destination=self.place_3)
self.storage.process_turn(continue_steps_if_needed=False)
self.assertTrue(self.hero.actions.current_action.state == actions_prototypes.ActionMoveToPrototype.STATE.MOVING)
self.assertTrue(self.hero.position.percents < 1)
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(
(result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ())
)
self.assertTrue(self.hero.position.place.id, self.place_3.id)
@mock.patch("the_tale.game.heroes.objects.Hero.is_battle_start_needed", lambda self: False)
def test_use__wrong_state(self):
actions_prototypes.ActionMoveToPrototype.create(hero=self.hero, destination=self.place_3)
self.assertTrue(self.hero.actions.current_action.state != actions_prototypes.ActionMoveToPrototype.STATE.MOVING)
with self.check_not_changed(lambda: self.hero.actions.current_action.percents):
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(
(result, step, postsave_actions), (ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR, ())
)
self.assertTrue(self.hero.position.place.id, self.place_1.id)
class InPlaceActionCompanionDrinkArtifactTests(testcase.TestCase):
def setUp(self):
super(InPlaceActionCompanionDrinkArtifactTests, self).setUp()
self.place_1, self.place_2, self.place_3 = create_test_map()
self.account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.action_idl = self.hero.actions.current_action
self.companion_record = companions_logic.create_random_companion_record('thief', state=companions_relations.STATE.ENABLED)
self.hero.set_companion(companions_logic.create_companion(self.companion_record))
self.hero.money = f.expected_gold_in_day(self.hero.level)
self.hero.position.set_place(self.place_1)
self.hero.position.update_previous_place()
self.hero.position.set_place(self.place_2)
self.artifact = artifacts_storage.generate_artifact_from_list(artifacts_storage.loot, 1, rarity=RARITY.NORMAL)
self.hero.put_loot(self.artifact)
self.assertEqual(self.hero.bag.occupation, 1)
self.hero.position.move_out_place()
@mock.patch('the_tale.game.heroes.objects.Hero.can_companion_drink_artifact', lambda hero: True)
def test_dring_artifact(self):
with self.check_decreased(lambda: self.hero.bag.occupation):
prototypes.ActionInPlacePrototype.create(hero=self.hero)
self.assertTrue(self.hero.journal.messages[-1].key.is_ACTION_INPLACE_COMPANION_DRINK_ARTIFACT)
def check_not_used(self):
with self.check_not_changed(lambda: self.hero.bag.occupation):
prototypes.ActionInPlacePrototype.create(hero=self.hero)
@mock.patch('the_tale.game.heroes.objects.Hero.can_companion_drink_artifact', lambda hero: True)
def test_previouse_place_is_equal(self):
self.hero.position.update_previous_place()
self.check_not_used()
@mock.patch('the_tale.game.heroes.objects.Hero.can_companion_drink_artifact', lambda hero: True)
def test_no_items(self):
self.hero.pop_loot(self.artifact)
self.check_not_used()
@mock.patch('the_tale.game.heroes.objects.Hero.can_companion_drink_artifact', lambda hero: False)
def test_companion_does_not_eat(self):
self.check_not_used()
class ChangeHeroTest(TestCase):
def setUp(self):
super(ChangeHeroTest, self).setUp()
place_1, place_2, place_3 = create_test_map()
result, account_id, bundle_id = register_user("test_user", "*****@*****.**", "111111")
self.account = AccountPrototype.get_by_id(account_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[account_id]
self.hero.utg_name.properties = self.hero.utg_name.properties.clone(self.hero.gender.utg_id)
self.noun = names.generator.get_test_name(name="test_name", gender=GENDER.NEUTER)
self.race = RACE.ELF if RACE.ELF != self.hero.race else RACE.HUMAN
self.gender = GENDER.NEUTER if not self.hero.gender.is_NEUTER else GENDER.FEMININE
def tearDown(self):
pass
def test_create(self):
task = ChangeHeroTask(self.hero.id, name=self.noun, race=self.race, gender=self.gender)
self.assertEqual(task.state, CHANGE_HERO_TASK_STATE.UNPROCESSED)
self.assertEqual(self.hero.preferences.place, None)
self.assertEqual(task.name, self.noun)
self.assertEqual(task.race, self.race)
self.assertEqual(task.gender, self.gender)
def test_serialization(self):
task = ChangeHeroTask(self.hero.id, name=self.noun, race=self.race, gender=self.gender)
self.assertEqual(task.serialize(), ChangeHeroTask.deserialize(task.serialize()).serialize())
def test_check_change(self):
task = ChangeHeroTask(self.hero.id, name=self.noun, race=self.race, gender=self.gender)
self.assertNotEqual(self.hero.utg_name, self.noun)
self.assertNotEqual(self.hero.gender, self.gender)
self.assertNotEqual(self.hero.race, self.race)
self.assertFalse(self.hero.settings_approved)
with mock.patch("the_tale.game.heroes.objects.Hero.reset_accessors_cache") as reset_accessors_cache:
self.assertEqual(
task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS
)
self.assertEqual(reset_accessors_cache.call_count, 1)
self.assertEqual(task.state, CHANGE_HERO_TASK_STATE.PROCESSED)
self.assertEqual(self.hero.utg_name.forms, self.noun.forms)
self.assertEqual(self.hero.utg_name.properties.get(utg_relations.GENDER), self.gender.utg_id)
self.assertEqual(self.hero.name, self.noun.normal_form())
self.assertEqual(self.hero.race, self.race)
self.assertEqual(self.hero.gender, self.gender)
self.assertTrue(self.hero.settings_approved)
class PersonPowerBonusMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(PersonPowerBonusMixin, self).setUp()
self.place_1, self.place_2, self.place_3 = create_test_map()
result, account_1_id, bundle_id = register_user('test_user', '*****@*****.**', '111111')
result, account_2_id, bundle_id = register_user('test_user_2')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.account_2 = AccountPrototype.get_by_id(account_2_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.storage.load_account_data(self.account_2)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
environment.deinitialize()
environment.initialize()
self.highlevel = environment.workers.highlevel
self.highlevel.process_initialize(0, 'highlevel')
def test_use(self):
person = self.place_1.persons[0]
result, step, postsave_actions = self.card.use(**self.use_attributes(hero=self.hero, storage=self.storage, person_id=person.id))
self.assertEqual((result, step), (ComplexChangeTask.RESULT.CONTINUE, ComplexChangeTask.STEP.HIGHLEVEL))
self.assertEqual(len(postsave_actions), 1)
with mock.patch('the_tale.game.workers.highlevel.Worker.cmd_logic_task') as highlevel_logic_task_counter:
postsave_actions[0]()
self.assertEqual(highlevel_logic_task_counter.call_count, 1)
with self.check_delta(lambda: person.power_positive, self.CARD.BONUS):
result, step, postsave_actions = self.card.use(**self.use_attributes(hero=self.hero,
step=step,
highlevel=self.highlevel,
person_id=person.id))
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ()))
def test_no_person(self):
self.assertEqual(self.card.use(**self.use_attributes(hero=self.hero, person_id=666, storage=self.storage)),
(ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR, ()))
class HeroLogicAccessorsTestBase(testcase.TestCase):
def setUp(self):
super(HeroLogicAccessorsTestBase, self).setUp()
self.place_1, self.place_2, self.place_3 = create_test_map()
result, account_id, bundle_id = register_user('test_user', '*****@*****.**', '111111')
self.storage = LogicStorage()
self.storage.load_account_data(AccountPrototype.get_by_id(account_id))
self.hero = self.storage.accounts_to_heroes[account_id]
class HeroLogicAccessorsTestBase(testcase.TestCase):
def setUp(self):
super(HeroLogicAccessorsTestBase, self).setUp()
self.place_1, self.place_2, self.place_3 = create_test_map()
account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(account)
self.hero = self.storage.accounts_to_heroes[account.id]
class ChangeHeroSpendingsMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(ChangeHeroSpendingsMixin, self).setUp()
create_test_map()
result, account_1_id, bundle_id = register_user('test_user', '*****@*****.**', '111111')
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
old_companion_record = random.choice(companions_storage.companions.all())
self.hero.set_companion(companions_logic.create_companion(old_companion_record))
def test_use(self):
# sure that quests will be loaded and not cal mark_updated
self.hero.quests.mark_updated()
for item in ITEMS_OF_EXPENDITURE.records:
if item == self.CARD.ITEM:
continue
self.hero.next_spending = item
with mock.patch('the_tale.game.quests.container.QuestsContainer.mark_updated') as mark_updated:
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(mark_updated.call_count, 1)
self.assertEqual(self.hero.next_spending, self.CARD.ITEM)
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ()))
def test_equal(self):
self.hero.next_spending = self.CARD.ITEM
with mock.patch('the_tale.game.quests.container.QuestsContainer.mark_updated') as mark_updated:
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(mark_updated.call_count, 0)
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR, ()))
class RepairRandomArtifactTests(RepairArtifacsTestMixin, testcase.TestCase):
CARD = effects.RepairRandomArtifact
def setUp(self):
super(RepairRandomArtifactTests, self).setUp()
create_test_map()
result, account_1_id, bundle_id = register_user("test_user", "*****@*****.**", "111111")
self.account_1 = AccountPrototype.get_by_id(account_1_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
def test_all_repaired(self):
self.check_all_equipment_repaired(True)
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(
(result, step, postsave_actions), (ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR, ())
)
self.check_all_equipment_repaired(True)
def test_use(self):
self.check_all_equipment_repaired(True)
items = [item for item in self.hero.equipment.values() if item]
random.shuffle(items)
items[0].integrity = 0
items[1].integrity = 0
self.check_all_equipment_repaired(False)
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(
(result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ())
)
self.check_all_equipment_repaired(False)
result, step, postsave_actions = self.card.use(**self.use_attributes(storage=self.storage, hero=self.hero))
self.assertEqual(
(result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ())
)
self.check_all_equipment_repaired(True)
class KeepersGoodsMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(KeepersGoodsMixin, self).setUp()
self.place_1, self.place_2, self.place_3 = create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.account_2 = self.accounts_factory.create_account(is_fast=True)
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.storage.load_account_data(self.account_2)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
environment.deinitialize()
environment.initialize()
self.highlevel = environment.workers.highlevel
self.highlevel.process_initialize(0, 'highlevel')
def test_use(self):
result, step, postsave_actions = self.card.use(**self.use_attributes(hero=self.hero, storage=self.storage, place_id=self.place_1.id))
self.assertEqual((result, step), (ComplexChangeTask.RESULT.CONTINUE, ComplexChangeTask.STEP.HIGHLEVEL))
self.assertEqual(len(postsave_actions), 1)
with mock.patch('the_tale.game.workers.highlevel.Worker.cmd_logic_task') as highlevel_logic_task_counter:
postsave_actions[0]()
self.assertEqual(highlevel_logic_task_counter.call_count, 1)
with self.check_delta(lambda: self.place_1.attrs.keepers_goods, self.CARD.GOODS):
result, step, postsave_actions = self.card.use(**self.use_attributes(hero=self.hero,
step=step,
highlevel=self.highlevel,
place_id=self.place_1.id))
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ()))
def test_use_for_wrong_place_id(self):
with self.check_not_changed(lambda: self.place_1.attrs.keepers_goods):
self.assertEqual(self.card.use(**self.use_attributes(hero=self.hero, place_id=666, storage=self.storage)),
(ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR, ()))
class AddPersonPowerMixin(CardsTestMixin):
CARD = None
def setUp(self):
super(AddPersonPowerMixin, self).setUp()
self.place_1, self.place_2, self.place_3 = create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account_1)
self.hero = self.storage.accounts_to_heroes[self.account_1.id]
self.card = self.CARD()
environment.deinitialize()
environment.initialize()
self.highlevel = environment.workers.highlevel
self.highlevel.process_initialize(0, 'highlevel')
def test_use(self):
person = self.place_1.persons[0]
result, step, postsave_actions = self.card.use(**self.use_attributes(hero=self.hero, storage=self.storage, person_id=person.id))
self.assertEqual((result, step), (ComplexChangeTask.RESULT.CONTINUE, ComplexChangeTask.STEP.HIGHLEVEL))
self.assertEqual(len(postsave_actions), 1)
with mock.patch('the_tale.game.workers.highlevel.Worker.cmd_logic_task') as highlevel_logic_task_counter:
postsave_actions[0]()
self.assertEqual(highlevel_logic_task_counter.call_count, 1)
with mock.patch('the_tale.game.persons.logic.PersonPoliticPower.change_power') as change_power:
result, step, postsave_actions = self.card.use(**self.use_attributes(hero=self.hero,
step=step,
highlevel=self.highlevel,
person_id=person.id))
self.assertEqual(change_power.call_args_list,
[mock.call(hero_id=self.hero.id, person=person, power=self.CARD.BONUS, has_in_preferences=True)])
self.assertEqual((result, step, postsave_actions), (ComplexChangeTask.RESULT.SUCCESSED, ComplexChangeTask.STEP.SUCCESS, ()))
def test_no_person(self):
self.assertEqual(self.card.use(**self.use_attributes(hero=self.hero, person_id=666, storage=self.storage)),
(ComplexChangeTask.RESULT.FAILED, ComplexChangeTask.STEP.ERROR, ()))
class PrototypesTests(testcase.TestCase):
def setUp(self):
super(PrototypesTests, self).setUp()
create_test_map()
result, account_id, bundle_id = register_user('test_user_1', '*****@*****.**', '111111')
self.account = AccountPrototype.get_by_id(account_id)
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.card_effect = effects.EFFECTS[relations.CARD_TYPE.KEEPERS_GOODS_COMMON]
self.card_1 = objects.Card(relations.CARD_TYPE.KEEPERS_GOODS_COMMON)
self.hero.cards.add_card(self.card_1)
self.task_data = {'card_uid': self.card_1.uid}
def test_check_hero_conditions__has_card(self):
self.assertTrue(self.card_effect.check_hero_conditions(self.hero, self.task_data))
def test_check_hero_conditions__has_no_card(self):
self.hero.cards.remove_card(self.card_1.uid)
self.assertFalse(self.card_effect.check_hero_conditions(self.hero, self.task_data))
def test_hero_actions(self):
card_2 = objects.Card(relations.CARD_TYPE.KEEPERS_GOODS_COMMON)
self.hero.cards.add_card(card_2)
self.assertEqual(self.card_1.type, card_2.type)
self.assertEqual(self.hero.cards.cards_count(), 2)
with self.check_delta(lambda: self.hero.statistics.cards_used, 1):
self.card_effect.hero_actions(self.hero, self.task_data)
self.assertEqual(self.hero.cards.cards_count(), 1)
self.assertTrue(self.hero.cards.has_card(card_2.uid))
self.assertFalse(self.hero.cards.has_card(self.card_1.uid))
def test_activate(self):
with mock.patch('the_tale.game.workers.supervisor.Worker.cmd_logic_task') as cmd_logic_task:
task = self.card_effect.activate(self.hero, self.card_1.uid, {'x': 'y'})
self.assertEqual(cmd_logic_task.call_args_list, [mock.call(self.hero.account_id, task.id)])
class HeroRequestsTestBase(TestCase):
def setUp(self):
super(HeroRequestsTestBase, self).setUp()
create_test_map()
self.account = self.accounts_factory.create_account()
self.storage = LogicStorage()
self.storage.load_account_data(self.account)
self.hero = self.storage.accounts_to_heroes[self.account.id]
self.client = client.Client()
self.request_login(self.account.email)
class _HeroEquipmentTestsBase(TestCase):
def setUp(self):
super(_HeroEquipmentTestsBase, self).setUp()
create_test_map()
result, account_id, bundle_id = register_user('test_user', '*****@*****.**', '111111')
self.storage = LogicStorage()
self.storage.load_account_data(AccountPrototype.get_by_id(account_id))
self.hero = self.storage.accounts_to_heroes[account_id]
self.hero._model.level = relations.PREFERENCE_TYPE.EQUIPMENT_SLOT.level_required
self.hero.save()
class DoNothingActionTest(testcase.TestCase):
@mock.patch('the_tale.game.actions.prototypes.ActionBase.get_description', lambda self: 'abrakadabra')
def setUp(self):
super(DoNothingActionTest, self).setUp()
create_test_map()
account = self.accounts_factory.create_account(is_fast=True)
self.storage = LogicStorage()
self.storage.load_account_data(account)
self.hero = self.storage.accounts_to_heroes[account.id]
self.action_idl = self.hero.actions.current_action
self.action_donothing = ActionDoNothingPrototype.create(hero=self.hero, duration=7, messages_prefix='QUEST_HOMETOWN_JOURNAL_CHATTING', messages_probability=0.3)
def tearDown(self):
pass
def test_create(self):
self.assertEqual(self.action_idl.leader, False)
self.assertEqual(self.action_donothing.leader, True)
self.assertEqual(self.action_donothing.textgen_id, 'QUEST_HOMETOWN_JOURNAL_CHATTING')
self.assertEqual(self.action_donothing.percents_barier, 7)
self.assertEqual(self.action_donothing.extra_probability, 0.3)
self.assertEqual(self.action_donothing.bundle_id, self.action_idl.bundle_id)
self.storage._test_save()
def test_not_ready(self):
self.storage.process_turn()
self.assertEqual(len(self.hero.actions.actions_list), 2)
self.assertEqual(self.hero.actions.current_action, self.action_donothing)
self.storage._test_save()
def test_full(self):
current_time = TimePrototype.get_current_time()
for i in range(7):
self.assertEqual(len(self.hero.actions.actions_list), 2)
self.assertTrue(self.action_donothing.leader)
self.storage.process_turn(continue_steps_if_needed=False)
current_time.increment_turn()
self.assertEqual(len(self.hero.actions.actions_list), 1)
self.assertTrue(self.action_idl.leader)
self.storage._test_save()
