def setUp(self): super(CardsGoodTypeTests, self).setUp() create_test_map() self.account_1 = self.accounts_factory.create_account() self.storage = LogicStorage() self.hero_1 = self.storage.load_account_data(self.account_1) self.container = self.hero_1.cards self.card_1 = objects.Card(relations.CARD_TYPE.ADD_GOLD_COMMON, available_for_auction=True) self.card_2 = objects.Card(relations.CARD_TYPE.ADD_GOLD_UNCOMMON, available_for_auction=False) self.card_3 = objects.Card(relations.CARD_TYPE.ADD_GOLD_RARE, available_for_auction=True) self.card_4 = objects.Card(relations.CARD_TYPE.LEVEL_UP, available_for_auction=False) self.container.add_card(self.card_1) self.container.add_card(self.card_2) self.container.add_card(self.card_3) self.container.add_card(self.card_4)
def test_add_card(self): self.assertFalse(self.container.updated) card_1 = objects.Card(relations.CARD_TYPE.KEEPERS_GOODS_COMMON) card_2 = objects.Card(relations.CARD_TYPE.ADD_GOLD_COMMON, available_for_auction=True) card_3 = objects.Card(relations.CARD_TYPE.KEEPERS_GOODS_LEGENDARY) with mock.patch( 'the_tale.finances.market.goods_types.BaseGoodType.sync_added_item' ) as sync_added_item: self.container.add_card(card_1) self.container.add_card(card_2) self.container.add_card(card_3) self.assertEqual(sync_added_item.call_args_list, [ mock.call(self.account.id, card_1), mock.call(self.account.id, card_2), mock.call(self.account.id, card_3) ]) self.assertTrue(self.container.updated) self.assertEqual(self.container._cards, { card_1.uid: card_1, card_2.uid: card_2, card_3.uid: card_3 })
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_serialization(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) self.hero.cards.add_card(card_1) self.hero.cards.add_card(card_2) task = CombineCardsTask(self.hero.id, cards=[card_1.uid, card_2.uid], message='test message') self.assertEqual(task.serialize(), CombineCardsTask.deserialize(task.serialize()).serialize())
def test_serialization(self): self.container.add_card(objects.Card(relations.CARD_TYPE.KEEPERS_GOODS_COMMON)) self.container.add_card(objects.Card(relations.CARD_TYPE.ADD_GOLD_COMMON, available_for_auction=True)) self.container.change_help_count(5) with mock.patch('the_tale.game.heroes.objects.Hero.is_premium', True): self.container.change_help_count(3) self.assertEqual(self.container.serialize(), container.CardsContainer.deserialize(self.container.serialize()).serialize())
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_card_count(self): self.assertEqual(len(list(self.container.all_cards())), 0) card_1 = objects.Card(relations.CARD_TYPE.KEEPERS_GOODS_COMMON) card_2 = objects.Card(relations.CARD_TYPE.KEEPERS_GOODS_COMMON, available_for_auction=True) card_3 = objects.Card(relations.CARD_TYPE.ADD_GOLD_COMMON, available_for_auction=True) self.container.add_card(card_1) self.container.add_card(card_2) self.container.add_card(card_3) cards_counter = collections.Counter(card.type for card in self.container.all_cards()) self.assertEqual(cards_counter.get(relations.CARD_TYPE.KEEPERS_GOODS_COMMON), 2) self.assertEqual(cards_counter.get(relations.CARD_TYPE.ADD_GOLD_COMMON), 1) self.assertEqual(cards_counter.get(relations.CARD_TYPE.ADD_GOLD_RARE), None)
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_insert_good(self): card = objects.Card(relations.CARD_TYPE.CHANGE_ABILITIES_CHOICES, available_for_auction=False) good = goods_types.cards_hero_good.create_good(card) goods_types.cards_hero_good.insert_good(self.hero_1, good) self.assertTrue(self.container.has_card(card.uid))
def test_serialization(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 self.assertEqual(task.serialize(), UseCardTask.deserialize(task.serialize()).serialize())
def test_remove_card(self): card_1 = objects.Card(relations.CARD_TYPE.KEEPERS_GOODS_COMMON) card_2 = objects.Card(relations.CARD_TYPE.ADD_GOLD_COMMON, available_for_auction=True) self.container.add_card(card_1) self.container.add_card(card_2) with mock.patch( 'the_tale.finances.market.goods_types.BaseGoodType.sync_removed_item' ) as sync_removed_item: self.container.remove_card(card_1.uid) self.assertEqual(sync_removed_item.call_args_list, [mock.call(self.account.id, card_1)]) self.assertEqual(self.container._cards, {card_2.uid: card_2})
def create_card(self, available_for_auction, companion=None): if companion is None: available_companions = self.get_available_companions() companion = random.choice(available_companions) return objects.Card(type=self.TYPE, available_for_auction=available_for_auction, data={'companion_id': companion.id})
def test_created(self): self.request_login(self.account.email) card_1 = objects.Card(relations.CARD_TYPE.ADD_GOLD_COMMON) card_2 = objects.Card(relations.CARD_TYPE.ADD_GOLD_COMMON) self.hero.cards.add_card(card_1) self.hero.cards.add_card(card_2) heroes_logic.save_hero(self.hero) with self.check_delta(PostponedTaskPrototype._db_count, 1): response = self.post_ajax_json(logic.combine_cards_url((card_1.uid, card_2.uid) )) task = PostponedTaskPrototype._db_get_object(0) self.check_ajax_processing(response, task.status_url)
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_create(self): for card_effect in effects.EFFECTS.values(): card = objects.Card(card_effect.TYPE) self.hero.cards.add_card(card) with self.check_delta(PostponedTaskPrototype._db_count, 1): task = card.activate(self.hero, data=self.task_data) self.assertTrue(task.internal_logic.state.is_UNPROCESSED)
def test_process_success(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.SUCCESSED, None, ())): self.assertEqual(task.process(FakePostpondTaskPrototype(), storage=self.storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS) self.assertEqual(task.state, UseCardTask.STATE.PROCESSED)
def setUp(self): super(CombineCardsTests, 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.card__add_power_common_1 = objects.Card( type=relations.CARD_TYPE.ADD_POWER_COMMON) self.card__add_power_common_2 = objects.Card( type=relations.CARD_TYPE.ADD_POWER_COMMON) self.card__add_power_common_3 = objects.Card( type=relations.CARD_TYPE.ADD_POWER_COMMON) self.card__add_power_common_4 = objects.Card( type=relations.CARD_TYPE.ADD_POWER_COMMON) self.card__add_bonus_energy_common_1 = objects.Card( type=relations.CARD_TYPE.ADD_BONUS_ENERGY_COMMON) self.card__add_bonus_energy_legendary_1 = objects.Card( type=relations.CARD_TYPE.ADD_BONUS_ENERGY_LEGENDARY) self.card__add_bonus_energy_legendary_2 = objects.Card( type=relations.CARD_TYPE.ADD_BONUS_ENERGY_LEGENDARY) self.card__add_bonus_energy_legendary_3 = objects.Card( type=relations.CARD_TYPE.ADD_BONUS_ENERGY_LEGENDARY) self.card__add_gold_common_1 = objects.Card( type=relations.CARD_TYPE.ADD_GOLD_COMMON) self.hero.cards.add_card(self.card__add_power_common_1) self.hero.cards.add_card(self.card__add_power_common_2) self.hero.cards.add_card(self.card__add_power_common_3) self.hero.cards.add_card(self.card__add_power_common_4) self.hero.cards.add_card(self.card__add_bonus_energy_common_1) self.hero.cards.add_card(self.card__add_bonus_energy_legendary_1) self.hero.cards.add_card(self.card__add_bonus_energy_legendary_2) self.hero.cards.add_card(self.card__add_bonus_energy_legendary_3) self.hero.cards.add_card(self.card__add_gold_common_1)
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 setUp(self): super(CardsRequestsTestsBase, 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.card = objects.Card(relations.CARD_TYPE.KEEPERS_GOODS_COMMON) self.building_1 = BuildingPrototype.create(person=self.place_1.persons[0], utg_name=names.generator().get_test_name('building-1-name'))
def setUp(self): super(CardsRequestsTestsBase, self).setUp() self.place_1, self.place_2, self.place_3 = 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 = objects.Card(relations.CARD_TYPE.KEEPERS_GOODS_COMMON) self.building_1 = BuildingPrototype.create(person=self.place_1.persons[0], utg_name=names.generator.get_test_name('building-1-name'))
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.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 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_group_of(self): for card_type in relations.CARD_TYPE.records: card = objects.Card(card_type, available_for_auction=False) self.assertEqual( goods_types.cards_hero_good.group_of(card).id, card.type.rarity.value)
def test_has_cards(self): self.assertFalse(self.container.has_cards) self.container.add_card(objects.Card(relations.CARD_TYPE.KEEPERS_GOODS_COMMON)) self.assertTrue(self.container.has_cards)
def create_card(self, available_for_auction): return objects.Card(type=self.TYPE, available_for_auction=available_for_auction)
def purchase_card(self, card_type, count): for i in xrange(count): self.cards.add_card( cards_objects.Card(card_type, available_for_auction=True))