def test_success(self):
deck = factories.DeckFactory(
name='test_deck',
is_ask_mode_enabled=True,
evaluation_period_status=card_module.EVALUATION_PERIOD_STATUS_OPEN)
self.db.session.add(deck)
question = factories.CardFactory(name='question')
self.db.session.add(question)
deck.cards.append(question)
answer1 = factories.CardFactory(name='answer1')
self.db.session.add(answer1)
deck.cards.append(answer1)
answer2 = factories.CardFactory(name='answer2')
self.db.session.add(answer2)
deck.cards.append(answer2)
self.db.session.commit()
data = {'card_id': answer1.id}
response = self.client.post('/api/v1/deck/revoke_card_from_deck',
data=json.dumps(data),
follow_redirects=True,
content_type='application/json')
self.assertEqual(response.status, '200 OK')
deck = Card.query.get(deck.id)
self.assertEqual(len(deck.cards), 2)
self.assertEqual(deck.cards[0].id, question.id)
self.assertEqual(deck.cards[1].id, answer2.id)
def test_for_specific_user_true(self):
from lib.models import card as card_module
self.creator = User(username='******')
self.card = factories.CardFactory(type=Card.DECK,
is_ask_mode_enabled=True,
creator=self.creator)
self.viewer = factories.UserFactory()
self.card.views.append(self.viewer)
self.card.comments.append(factories.Comment(user=self.viewer))
urc = factories.UserRoleCard(card=self.card,
user=self.viewer,
prize=56)
self.db.session.add(self.card)
self.db.session.commit()
self.call_target(by_user=self.viewer)
self.assertEqual(self.result['views_count'], 1)
self.assertEqual(self.result['viewed_by_me'], True)
self.assertEqual(self.result['commented_by_me'], True)
self.assertEqual(self.result['won_by_me'], True)
def test_succcess(self):
card_id = 'card_id'
card_name = 'card_name'
card = factories.CardFactory(id=card_id,
name='card_name',
creator=self.user,
description='description')
tag = factories.Tag(name="tag1")
card.tags.append(tag)
self.db.session.commit()
result = self.call_target(card_id=card_id)
self.assertEqual(result.status, '200 OK')
card = factories.CardFactory.get(card_id)
deck = card.parent
self.assertEqual(
result, factories.JsonResponseFactory.build(data=deck.to_dict()))
self.assertEqual(deck.type, Card.DECK)
self.assertEqual(deck.name, card_name)
self.assertEqual(deck.description, 'description')
self.assertEqual(len(deck.tags), 1)
self.assertEqual(deck.tags[0].name, 'tag1')
def test_givers_and_is_answer_flag(self):
deck = factories.CardFactory(type=Card.DECK, is_ask_mode_enabled=True)
self.db.session.add(deck)
self.db.session.commit()
question_creator = User(username='******')
self.db.session.add(question_creator)
question = Card(type=Card.TEXT,
parent_id=deck.id,
position=0,
is_answer=False,
creator=question_creator)
self.db.session.add(question)
giver1 = User(username='******')
self.db.session.add(giver1)
answer = Card(type=Card.TEXT,
parent_id=deck.id,
creator=giver1,
position=1,
is_answer=True)
self.db.session.add(answer)
answer1 = Card(type=Card.TEXT,
parent_id=deck.id,
creator=giver1,
position=2,
is_answer=True)
self.db.session.add(answer1)
question1 = Card(type=Card.TEXT,
parent_id=deck.id,
position=3,
is_answer=False,
creator=question_creator)
self.db.session.add(question1)
self.db.session.commit()
res = deck.to_dict()
self.assertEqual(len(res['givers']), 1)
self.assertEqual(res['givers'][0]['user_id'], giver1.id)
#check if children elements has correct flag is_answer
children = res['children']
self.assertEqual(len(children), 4)
self.assertEqual(children[0]['id'], question.id)
self.assertEqual(children[0]['is_answer'], False)
self.assertEqual(children[1]['id'], answer.id)
self.assertEqual(children[1]['is_answer'], True)
self.assertEqual(children[2]['id'], answer1.id)
self.assertEqual(children[2]['is_answer'], True)
self.assertEqual(children[3]['id'], question1.id)
self.assertEqual(children[3]['is_answer'], False)
def test_tags_field(self):
tag = factories.Tag(name='tag1')
card = factories.CardFactory(tags=[tag])
self.db.session.commit()
res = card.to_dict()
self.assertEqual(len(res['tags']), 1)
self.assertEqual(res['tags'][0], 'tag1')
def test_card_should_not_published(self):
deck = factories.DeckFactory(published=True, creator=self.user)
card1 = factories.CardFactory(parent=deck)
card2 = factories.CardFactory(parent=deck)
self.db.session.commit()
self.assertEqual(card1.position, 0)
self.assertEqual(card2.position, 1)
result = self.call_target(card_id=card1.id, position=1)
self.assertEqual(
result,
factories.JsonResponseWithResultStatusFactory.build(
data={
'result': 'error',
'message':
u'Card deck is published. you can not change order'
}))
def test_image_scale_field(self):
self.card = factories.CardFactory(type=Card.IMAGE, scale=4)
self.db.session.commit()
self.call_target()
self.assert_result()
self.assertEqual(self.result['scale'], 4)
self.assertEqual(self.result['image_scale'], 4)
def test_succcess(self):
card = factories.CardFactory(creator=self.user)
self.db.session.commit()
result = self.call_target()
self.assertEqual(result.status, '200 OK')
data = flask.json.loads(result.data)
cards = data['created']
self.assertEqual(len(cards), 1)
self.assertEqual(cards[0]['id'], card.id)
def test_simple_fields(self):
from lib.models import card as card_module
self.creator = User(username='******')
self.card = factories.CardFactory(type=Card.DECK,
is_ask_mode_enabled=True,
creator=self.creator)
eastern = timezone('US/Eastern')
self.card.evaluation_period_status = card_module.EVALUATION_PERIOD_STATUS_OPEN
self.card.distribution_rule = card_module.DISTRIBUTION_RULE_SPLIT_EVENLY
self.card.distribution_for = 10
self.card.evaluation_start_dt = datetime(2016,
11,
28,
9,
51,
38,
tzinfo=eastern)
self.card.evaluation_end_dt = datetime(2016,
11,
29,
9,
51,
38,
tzinfo=eastern)
self.card.answer_visibility = card_module.ANSWER_VISIBILITY_ONLY_ASKERS
self.card.scale = 3
self.card.original_prize_pool = 123
self.viewer = factories.UserFactory()
self.card.views.append(self.viewer)
self.db.session.add(self.card)
self.db.session.commit()
self.call_target()
self.assert_result()
self.joined_users = [self.creator]
self.assertEqual(self.result['evaluation_period_status'],
card_module.EVALUATION_PERIOD_STATUS_OPEN)
self.assertEqual(self.result['distribution_rule'],
card_module.DISTRIBUTION_RULE_SPLIT_EVENLY)
self.assertEqual(self.result['distribution_for'], 10)
self.assertEqual(self.result['evaluation_start_dt'],
datetime(2016, 11, 28, 9, 51, 38, tzinfo=eastern))
self.assertEqual(self.result['evaluation_end_dt'],
datetime(2016, 11, 29, 9, 51, 38, tzinfo=eastern))
self.assertEqual(self.result['answer_visibility'],
card_module.ANSWER_VISIBILITY_ONLY_ASKERS)
self.assertEqual(self.result['creator_info']['user_id'],
self.creator.id)
self.assertEqual(self.result['scale'], 3)
self.assertEqual(self.result['original_prize_pool'], 123)
self.assertEqual(self.result['views_count'], 1)
def test_succcess(self):
card = factories.CardFactory(id="card")
self.db.session.commit()
result = self.call_target(card_id="card")
self.assertEqual(result, factories.JsonResponseFactory.build())
card = factories.CardFactory.get("card")
self.assertEqual(card.views_count, 1)
self.assertEqual(len(card.views), 1)
self.assertEqual(card.views[0].id, self.user.id)
def test_succcess(self):
deck = factories.DeckFactory(creator=self.user)
card1 = factories.CardFactory(parent=deck)
card2 = factories.CardFactory(parent=deck)
card3 = factories.CardFactory(parent=deck)
self.db.session.commit()
self.assertEqual(card1.position, 0)
self.assertEqual(card2.position, 1)
self.assertEqual(card3.position, 2)
result = self.call_target(card_id=card1.id, position=1)
self.assertEqual(result,
factories.JsonResponseWithResultStatusFactory.build())
card1 = factories.CardFactory.get(card1.id)
self.assertEqual(card1.position, 1)
self.assertEqual(card2.position, 0)
self.assertEqual(card3.position, 2)
def test_delete_card_with_reference_to_user_role_card(self):
user_role_card = factories.UserRoleCard(card=factories.CardFactory(creator=self.user))
self.db.session.commit()
card = user_role_card.card
data = {
'card_ids': [card.id]
}
response = self.client.post('/api/v1/deck/delete_cards', data=flask.json.dumps(data), content_type='application/json')
self.assertEqual(response.status, '200 OK')
card = Card.query.get(card.id)
self.assertIsNone(card)
def test_change_order_for_drafts(self):
card1 = factories.CardFactory(creator=self.user, position=0)
card2 = factories.CardFactory(creator=self.user, position=1)
card3 = factories.CardFactory(creator=self.user, position=2)
self.db.session.commit()
self.assertEqual(card1.position, 0)
self.assertEqual(card2.position, 1)
self.assertEqual(card3.position, 2)
result = self.call_target(card_id=card1.id, position=1)
self.assertEqual(result,
factories.JsonResponseWithResultStatusFactory.build())
card1 = factories.CardFactory.get(card1.id)
card2 = factories.CardFactory.get(card2.id)
card3 = factories.CardFactory.get(card3.id)
self.assertEqual(card1.position, 1)
self.assertEqual(card2.position, 0)
self.assertEqual(card3.position, 2)
def test_succcess(self):
card_id = 'card_id'
card = factories.CardFactory(id=card_id,
name='card_name',
creator=self.user)
self.db.session.commit()
result = self.call_target(card_id=card_id)
self.assertEqual(result.status, '200 OK')
data = json.loads(result.data)
new_card_id = data['id']
card = factories.CardFactory.get(card_id)
new_card = factories.CardFactory.get(new_card_id)
self.assertEqual(card.name, new_card.name)
def test_wins(self):
ask = factories.CardFactory()
self.db.session.add(ask)
urc = factories.UserRoleCard(card=ask, user=self.user, role_id=card_role.CardRole.GIVER, prize=10)
self.db.session.add(urc)
self.db.session.commit()
self.data['fields'] = 'wins'
response = self.call_target()
self.assertEqual(response.status, '200 OK')
data = flask.json.loads(response.data)
asks = data['wins']
self.assertEqual(len(asks), 1)
self.assertEqual(asks[0]['id'], ask.id)
def test_asks(self):
card = factories.CardFactory()
self.db.session.add(card)
urc = factories.UserRoleCard(card=card, user=self.user, role_id=card_role.CardRole.JOINED)
self.db.session.add(urc)
self.db.session.commit()
self.data['fields'] = 'asks'
response = self.call_target()
self.assertEqual(response.status, '200 OK')
data = flask.json.loads(response.data)
asks = data['asks']
self.assertEqual(len(asks), 1)
self.assertEqual(asks[0]['id'], card.id)
def test_published(self):
'''Get all card published by user'''
user = factories.UserFactory()
self.db.session.add(user)
card = factories.CardFactory(user_id=user.id, published=True, creator=user)
self.db.session.add(card)
self.db.session.commit()
self.data['fields'] = 'published'
self.data['user_id'] = user.id
response = self.call_target()
self.assertEqual(response.status, '200 OK')
data = flask.json.loads(response.data)
cards = data['published']
self.assertEqual(len(cards), 1)
self.assertEqual(cards[0]['id'], card.id)
def test_for_specific_user_false(self):
from lib.models import card as card_module
self.creator = User(username='******')
self.card = factories.CardFactory(type=Card.DECK,
is_ask_mode_enabled=True,
creator=self.creator)
self.viewer = factories.UserFactory()
self.db.session.commit()
self.call_target(by_user=self.viewer)
self.assert_result()
self.joined_users = [self.creator]
self.assertEqual(self.result['views_count'], 0)
self.assertEqual(self.result['viewed_by_me'], False)
self.assertEqual(self.result['commented_by_me'], False)
self.assertEqual(self.result['won_by_me'], False)
def call_target(self, by_user=None):
if self.card is None:
self.card = factories.CardFactory(type=Card.DECK,
is_ask_mode_enabled=True)
if self.creator:
if self.creator.id is None:
self.db.session.add(self.creator)
self.db.session.commit()
self.card.creator = self.creator
if self.evaluation_period_status is not None:
self.card.evaluation_period_status = self.evaluation_period_status
self.db.session.add(self.card)
self.db.session.commit()
if self.creator is not None:
urc = UserRoleCard(user_id=self.creator.id,
role_id=CardRole.JOINED,
card_id=self.card.id)
self.db.session.add(urc)
self.db.session.commit()
if self.joined_user1_name is not None:
self.joined_user_id1 = User(username=self.joined_user1_name)
self.db.session.add(self.joined_user_id1)
self.db.session.commit()
if self.joined_user_id1 is not None:
if self.joined_user_id1.id is None:
self.db.session.add(self.joined_user_id1)
self.db.session.commit()
urc = UserRoleCard(user_id=self.joined_user_id1.id,
role_id=CardRole.JOINED,
card_id=self.card.id)
if self.joined_user_id1_contribution is not None:
urc.contribution = self.joined_user_id1_contribution
self.db.session.add(urc)
self.db.session.commit()
res = self.card.to_dict(user=by_user)
self.result = res
self.create_expected()
return self.result
def test_deck_deck_card_structure(self):
deck = factories.DeckFactory(id="deck", is_ask_mode_enabled=True)
container = factories.DeckFactory(id='container',
parent=deck,
is_ask_mode_enabled=False)
factories.CardFactory(id='card', parent=container)
self.db.session.commit()
res = deck.to_dict()
self.assertEqual(res['id'], 'deck')
self.assertEqual(len(res['children']), 1)
c = res['children'][0]
self.assertEqual(c['id'], 'container')
self.assertEqual(len(c['children']), 1)
ca = c['children'][0]
self.assertEqual(ca['id'], 'card')
self.assertNotIn('children', ca)
def test_success(self):
user = factories.UserFactory(silver_points=39, gold_points=44)
card = factories.CardFactory(creator=user, likes=4)
self.db.session.commit()
response = self.call_target(user_id=user.id)
res = flask.json.loads(response.data)
self.assertEqual(res['user_info']['user_id'], user.id)
self.assertEqual(len(res['cards']), 1)
self.assertEqual(res['cards'][0]['id'], card.id)
stats = res['stats']
self.assertEqual(stats['total_followers'], 0)
self.assertEqual(stats['total_followings'], 0)
self.assertEqual(stats['total_likes'], 4)
self.assertEqual(stats['total_shared'], 113)
self.assertEqual(stats['total_points'], {'silver': 39, 'gold': 44})
def test_likes(self):
'''Get all card liked by user'''
card = factories.CardFactory()
self.db.session.add(card)
user = factories.UserFactory()
self.db.session.add(user)
like = factories.CardLikesFactory(card=card, user=user)
self.db.session.add(like)
self.db.session.commit()
self.data['fields'] = 'likes'
self.data['user_id'] = user.id
response = self.call_target()
self.assertEqual(response.status, '200 OK')
data = flask.json.loads(response.data)
cards = data['likes']
self.assertEqual(len(cards), 1)
self.assertEqual(cards[0]['id'], card.id)
def test_create_ask_from_single_card(self):
card = factories.CardFactory(name="card_name")
self.db.session.commit()
self.call_target(data=dict(deck_id=card.id, is_ask_mode_enabled=True))
# TO DO check response
card = factories.CardFactory.get(card.id)
self.assertEqual(card.type, Card.TEXT)
self.assertEqual(card.is_ask_mode_enabled, False)
self.assertEqual(card.name, "card_name")
container = card.parent
self.assertEqual(container.type, Card.DECK)
self.assertEqual(container.name, "card_name")
self.assertEqual(container.is_ask_mode_enabled, False)
ask_mode_deck = container.parent
self.assertEqual(ask_mode_deck.type, Card.DECK)
self.assertEqual(ask_mode_deck.is_ask_mode_enabled, True)
def test_enable_ask_mode_for_deck(self):
deck = factories.DeckFactory(name="deck_name")
card = factories.CardFactory(parent=deck, name="card_name")
self.call_target(data=dict(deck_id=deck.id, is_ask_mode_enabled=True))
# TO DO check response
card = factories.CardFactory.get(card.id)
self.assertEqual(card.type, Card.TEXT)
self.assertEqual(card.is_ask_mode_enabled, False)
self.assertEqual(card.name, "card_name")
container = card.parent
self.assertEqual(container.type, Card.DECK)
self.assertEqual(container.name, "deck_name")
self.assertEqual(container.is_ask_mode_enabled, False)
ask_mode_deck = container.parent
self.assertEqual(ask_mode_deck.type, Card.DECK)
self.assertEqual(ask_mode_deck.name, "deck_name")
self.assertEqual(ask_mode_deck.is_ask_mode_enabled, True)
def test_points_cannot_be_less_than_0(self):
try:
factories.CardFactory(silver_points=-1, gold_points=-1)
self.fail('Value error shoulb be thrown')
except ValueError:
pass
def test_many_questions(self):
self.questions = [factories.CardFactory(), factories.CardFactory()]
self.call_target()
self.assert_output()
