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))
