def test_process_second_step_error(self): card_effect = random.choice(effects.EFFECTS.values()) card = objects.Card(card_effect.TYPE) self.hero.cards.add_card(card) task = card.activate(self.hero, data=self.task_data).internal_logic with mock.patch.object( card_effect, 'use', lambda **kwargs: (UseCardTask.RESULT.CONTINUE, UseCardTask.STEP.HIGHLEVEL, ())): self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.CONTINUE) self.assertTrue(task.step.is_HIGHLEVEL) self.assertEqual(task.state, UseCardTask.STATE.UNPROCESSED) with mock.patch.object( card_effect, 'use', lambda **kwargs: (UseCardTask.RESULT.FAILED, None, ())): self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertEqual(task.state, UseCardTask.STATE.CAN_NOT_PROCESS)
def test_process_second_step_success(self): with mock.patch('the_tale.game.abilities.deck.help.Help.use', lambda self, task, storage, pvp_balancer, highlevel: (ComplexChangeTask.RESULT.CONTINUE, ComplexChangeTask.STEP.HIGHLEVEL, ())): self.assertEqual(self.task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.CONTINUE) self.assertTrue(self.task.step.is_HIGHLEVEL) self.assertEqual(self.task.state, ComplexChangeTask.STATE.UNPROCESSED) self.assertEqual(self.task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertEqual(self.task.state, ComplexChangeTask.STATE.PROCESSED)
def test_already_chosen(self): task = self.create_task(option_uid=self.option_1_1_uid) self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertTrue(task.state.is_PROCESSED) task = self.create_task(option_uid=self.option_1_2_uid) self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertTrue(task.state.is_ALREADY_CHOSEN)
def test_choose_second_choice_before_first_completed(self): task = self.create_task(option_uid=self.option_1_2_uid) self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertTrue(task.state.is_PROCESSED) task = self.create_task(option_uid=self.option_2_1_uid) self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertTrue(task.state.is_WRONG_POINT)
def test_process_success__with_action(self): result, account_id, bundle_id = register_user('test_user', '*****@*****.**', '111111') task = RegistrationTask(account_id=None, referer=None, referral_of_id=None, action_id='action') self.assertEqual(task.process(FakePostpondTaskPrototype()), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertEqual(task.state, REGISTRATION_TASK_STATE.PROCESSED) self.assertTrue(task.account) self.assertEqual(task.account.action_id, 'action')
def test_success__3_cards(self): card_1 = cards_objects.Card(cards_relations.CARD_TYPE.ADD_GOLD_COMMON) card_2 = cards_objects.Card(cards_relations.CARD_TYPE.ADD_GOLD_COMMON) card_3 = cards_objects.Card(cards_relations.CARD_TYPE.ADD_GOLD_COMMON) self.hero.cards.add_card(card_1) self.hero.cards.add_card(card_2) self.hero.cards.add_card(card_3) task = CombineCardsTask(self.hero.id, cards=[card_1.uid, card_2.uid, card_3.uid]) with self.check_delta(self.hero.cards.cards_count, -2): self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertTrue(self.hero.cards.has_cards) self.assertTrue( self.hero.cards.all_cards().next().type.rarity.is_UNCOMMON) self.assertTrue(self.hero.cards.all_cards().next().name.lower() in task.processed_data['message'].lower()) self.assertTrue(self.hero.cards.all_cards().next().effect.DESCRIPTION. lower() in task.processed_data['message'].lower()) self.assertTrue(task.state.is_PROCESSED)
def test_wrong_ability_id(self): task = UsePvPAbilityTask(battle_id=self.battle.id, account_id=self.account_1.id, ability_id='wrong_ability_id') task.process(FakePostpondTaskPrototype(), self.storage) self.assertEqual(task.state, USE_PVP_ABILITY_TASK_STATE.WRONG_ABILITY_ID)
def test_process_success(self): self.assertEqual(self.task.process(FakePostpondTaskPrototype()), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertEqual(self.task.state, REGISTRATION_TASK_STATE.PROCESSED) self.assertTrue(self.task.account) self.assertTrue(self.task.account.is_fast) self.assertEqual(Account.objects.all().count(), 1)
def test_success__remove_duplicates(self): cards = [cards_objects.Card(cards_relations.CARD_TYPE.ADD_GOLD_COMMON), cards_objects.Card(cards_relations.CARD_TYPE.ADD_GOLD_COMMON), cards_objects.Card(cards_relations.CARD_TYPE.ADD_GOLD_COMMON), cards_objects.Card(cards_relations.CARD_TYPE.ADD_EXPERIENCE_COMMON), cards_objects.Card(cards_relations.CARD_TYPE.ADD_EXPERIENCE_COMMON), cards_objects.Card(cards_relations.CARD_TYPE.ADD_BONUS_ENERGY_COMMON), cards_objects.Card(cards_relations.CARD_TYPE.CHANGE_HERO_SPENDINGS_TO_INSTANT_HEAL), cards_objects.Card(cards_relations.CARD_TYPE.LEVEL_UP)] for card in cards: self.hero.cards.add_card(card) task = CombineCardsTask(self.hero.id, cards=[cards[1].uid, cards[2].uid, cards[5].uid]) with self.check_delta(self.hero.cards.cards_count, -2): self.assertEqual(task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertTrue(self.hero.cards.has_card(cards[0].uid)) self.assertFalse(self.hero.cards.has_card(cards[1].uid)) self.assertFalse(self.hero.cards.has_card(cards[2].uid)) self.assertTrue(self.hero.cards.has_card(cards[3].uid)) self.assertTrue(self.hero.cards.has_card(cards[4].uid)) self.assertFalse(self.hero.cards.has_card(cards[5].uid)) self.assertTrue(self.hero.cards.has_card(cards[6].uid)) self.assertTrue(self.hero.cards.has_card(cards[7].uid)) self.assertTrue(task.state.is_PROCESSED)
def test_process_second_step_error(self): card = logic.create_card(allow_premium_cards=True, available_for_auction=True) tt_api.change_cards(account_id=self.hero.account_id, operation_type='#test', to_add=[card]) task = card.activate(self.hero, data=self.task_data).internal_logic with mock.patch.object(card.type.effect.__class__, 'use', lambda *argv, **kwargs: (postponed_tasks.UseCardTask.RESULT.CONTINUE, postponed_tasks.UseCardTask.STEP.HIGHLEVEL, ())): self.assertEqual(task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.CONTINUE) self.assertTrue(task.step.is_HIGHLEVEL) self.assertEqual(task.state, postponed_tasks.UseCardTask.STATE.UNPROCESSED) with mock.patch.object(card.type.effect.__class__, 'use', lambda *argv, **kwargs: (postponed_tasks.UseCardTask.RESULT.FAILED, None, ())): self.assertEqual(task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertEqual(task.state, postponed_tasks.UseCardTask.STATE.CAN_NOT_PROCESS)
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)
def test_banned(self): self.hero.ban_state_end_at = datetime.datetime.now( ) + datetime.timedelta(days=1) heroes_logic.save_hero(self.hero) self.assertEqual( self.task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertEqual(self.task.state, ComplexChangeTask.STATE.BANNED)
def test_process_success__with_referer(self): referer = 'http://example.com/forum/post/1/' task = RegistrationTask(account_id=None, referer=referer, referral_of_id=None, action_id=None) self.assertEqual(task.process(FakePostpondTaskPrototype()), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertEqual(task.state, REGISTRATION_TASK_STATE.PROCESSED) self.assertTrue(task.account) self.assertEqual(task.account.referer, referer) self.assertEqual(task.account.referer_domain, 'example.com')
def test_process_id_not_in_choices(self): task = ChooseHeroAbilityTask(self.hero.id, self.get_unchoosed_ability_id()) self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertEqual(task.state, CHOOSE_HERO_ABILITY_STATE.NOT_IN_CHOICE_LIST)
def test_process_no_energy(self): self.hero.energy = 0 self.hero.energy_bonus = 0 heroes_logic.save_hero(self.hero) self.assertEqual( self.task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertEqual(self.task.state, ComplexChangeTask.STATE.HERO_CONDITIONS_NOT_PASSED)
def test_response_data(self): card = logic.create_card(allow_premium_cards=True, available_for_auction=True) tt_api.change_cards(account_id=self.hero.account_id, operation_type='#test', to_add=[card]) with mock.patch.object(card.type.effect.__class__, 'use', lambda *argv, **kwargs: (postponed_tasks.UseCardTask.RESULT.SUCCESSED, None, ())): task = card.activate(self.hero, data=self.task_data).internal_logic task.process(FakePostpondTaskPrototype(), self.storage) self.assertEqual(task.processed_data, {})
def test_reset(self): task = ResetHeroAbilitiesTask(self.hero.id) self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertEqual(len(self.hero.abilities.all), 2) self.assertTrue(task.state.is_PROCESSED)
def test_process_can_not_process(self): with mock.patch( 'the_tale.game.abilities.deck.help.Help.use', lambda self, task, storage, pvp_balancer, highlevel: (ComplexChangeTask.RESULT.FAILED, None, ())): self.assertEqual( self.task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertEqual(self.task.state, ComplexChangeTask.STATE.CAN_NOT_PROCESS)
def test__can_not_get(self): self.hero.cards.change_help_count(c.CARDS_HELP_COUNT_TO_NEW_CARD - 1) task = GetCardTask(self.hero.id) with self.check_not_changed(lambda: self.hero.cards.help_count): self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertFalse(self.hero.cards.has_cards) self.assertTrue(task.state.is_CAN_NOT_GET)
def test_reset__timeout(self): task = ResetHeroAbilitiesTask(self.hero.id) self.hero.abilities.set_reseted_at(datetime.datetime.now()) self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertTrue(len(self.hero.abilities.all) > 1) self.assertTrue(task.state.is_RESET_TIMEOUT)
def test_process_success(self): self.assertFalse(self.hero_1.journal.messages) self.assertFalse(self.hero_2.journal.messages) self.assertEqual( self.task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertEqual(self.task.state, SAY_IN_HERO_LOG_TASK_STATE.PROCESSED) self.assertTrue(self.hero_1.journal.messages) self.assertTrue(self.hero_2.journal.messages)
def test_response_data(self): card_effect = random.choice(effects.EFFECTS.values()) card = objects.Card(card_effect.TYPE) self.hero.cards.add_card(card) with mock.patch.object( card_effect, 'use', lambda **kwargs: (UseCardTask.RESULT.SUCCESSED, None, ())): task = card.activate(self.hero, data=self.task_data).internal_logic task.process(FakePostpondTaskPrototype(), self.storage) self.assertEqual(task.processed_data, {})
def test_no_choices(self): task = self.create_task(option_uid=self.option_1_1_uid) knowledge_base = self.hero.quests.current_quest.knowledge_base finish_state = next(knowledge_base.filter(facts.Finish)) self.hero.quests.current_quest.machine.pointer.change_in_knowlege_base( knowledge_base, state=finish_state.uid, jump=None) self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertTrue(task.state.is_NO_CHOICES_IN_QUEST)
def test_process_not_for_heroes(self): task = ChooseHeroAbilityTask(self.hero.id, self.get_only_for_mobs_ability_id()) with mock.patch( 'the_tale.game.heroes.habilities.AbilitiesPrototype.get_for_choose', lambda x: [ABILITIES[task.ability_id]]): self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertEqual(task.state, CHOOSE_HERO_ABILITY_STATE.NOT_FOR_PLAYERS)
def test_choose_second_choice_after_first_completed(self): task = self.create_task(option_uid=self.option_1_2_uid) self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertTrue(task.state.is_PROCESSED) while True: self.assertNotEqual(self.hero.actions.current_action.TYPE, ActionIdlenessPrototype.TYPE) task = self.create_task(option_uid=self.option_2_1_uid) if task.process(FakePostpondTaskPrototype(), self.storage) == POSTPONED_TASK_LOGIC_RESULT.ERROR: break self.storage.process_turn() self.storage.save_changed_data() turn.increment()
def test__can_not_found_method(self): task = InvokeHeroMethodTask(self.hero.id, method_name='missed_method', method_kwargs={ 'x': 'y', 'z': 0 }) self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertTrue(task.state.is_METHOD_NOT_FOUND)
def test__can_not_combine(self): for combine_status in cards_relations.CARDS_COMBINING_STATUS.records: if combine_status.is_ALLOWED: continue task = CombineCardsTask(self.hero.id, cards=[]) with mock.patch('the_tale.game.cards.container.CardsContainer.can_combine_cards', lambda self, cards: combine_status): with self.check_not_changed(self.hero.cards.cards_count): self.assertEqual(task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertFalse(self.hero.cards.has_cards) self.assertTrue(task.state.is_CAN_NOT_COMBINE)
def test_process_success(self): old_hero_1_last_message = self.hero_1.journal.messages[-1] old_hero_2_last_message = self.hero_2.journal.messages[-1] self.assertEqual( self.task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertEqual(self.task.state, SAY_IN_HERO_LOG_TASK_STATE.PROCESSED) self.assertNotEqual(old_hero_1_last_message, self.hero_1.journal.messages[-1]) self.assertNotEqual(old_hero_2_last_message, self.hero_2.journal.messages[-1])
def test_no_quests(self): self.turn_to_quest(self.storage, self.hero.id) account = self.accounts_factory.create_account() self.storage.load_account_data(account) task = self.create_task(option_uid=self.option_1_1_uid, account_id=account.id) self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertTrue(task.state.is_QUEST_NOT_FOUND)
def test_process_no_freee_ability_points(self): task = ChooseHeroAbilityTask(self.hero.id, self.get_new_ability_id()) with mock.patch( 'the_tale.game.heroes.habilities.AbilitiesPrototype.can_choose_new_ability', False): self.assertEqual( task.process(FakePostpondTaskPrototype(), self.storage), POSTPONED_TASK_LOGIC_RESULT.ERROR) self.assertEqual( task.state, CHOOSE_HERO_ABILITY_STATE.MAXIMUM_ABILITY_POINTS_NUMBER)