def test_followings(self):
user = factories.UserFactory()
self.db.session.add(user)
following = factories.UserFactory()
user.followings.append(following)
self.db.session.add(following)
current_user = factories.UserFactory()
self.db.session.add(current_user)
following.followers.append(current_user)
self.db.session.commit()
self.set_current_user(current_user)
response = self.call_target(user_id=user.id)
res = flask.json.loads(response.data)
followings = res['followings']
stats = res['stats']
self.assertEqual(stats['total_followings'], 1)
self.assertEqual(len(followings), 1)
self.assertEqual(followings[0]['user_id'], following.id)
self.assertEqual(followings[0]['follow_by_current_user'], True)
def test_send_to_friend(self):
user_from = factories.UserFactory(silver_points=100, username='******')
user_to = factories.UserFactory(silver_points=30, username='******')
self.call_target(
user_from=user_from.id,
user_to=user_to.id,
transaction_type='send_to_friend',
silver_points=50
)
self.assertEqual(
factories.UserFactory.get(user_from.id),
factories.UserFactory.build(id=user_from.id, silver_points=50, username='******')
)
self.assertEqual(
factories.UserFactory.get(user_to.id),
factories.UserFactory.build(id=user_to.id, silver_points=80, username='******')
)
tr = factories.Transfer.get()[0]
self.assertEqual(
tr,
factories.Transfer.build(
id=tr.id,
user_from=user_from,
user_to=user_to,
silver_points=50,
transaction_type='send_to_friend',
)
)
def test_follow_user(self):
follower = factories.UserFactory(id="follower")
self.db.session.add(follower)
following = factories.UserFactory(id="following")
following.followers.append(follower)
self.db.session.add(following)
self.assertEqual(follower.followings[0].id, following.id)
self.set_current_user(follower)
self.db.session.commit()
result = self.call_target(
following_id="following"
)
# self.assertEqual(result, factories.JsonResponseFactory.build())
self.assertEqual(result.status, '200 OK')
follower = factories.UserFactory.get("follower")
self.assertEqual(len(follower.followings), 0)
following = factories.UserFactory.get("following")
self.assertEqual(len(following.followers), 0)
def test_basic_info(self):
user = factories.UserFactory(id='TestUser',
username='******',
first_name='first_name',
last_name='last_name',
bio='bio')
self.db.session.add(user)
self.db.session.commit()
self.set_current_user(user)
self.user = user
self.data = dict(username='******',
first_name='first_name1',
last_name='last_name1',
bio='bio1')
response = self.call_target()
expected_user = factories.UserFactory.build(id='TestUser',
username='******',
first_name='first_name1',
last_name='last_name1',
bio='bio1')
self.assertEqual(factories.UserFactory.get('TestUser'), expected_user)
self.assertEqual(
response,
factories.JsonResponseFactory(
data=get_base_user_info(expected_user)))
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_create_ask(self):
with factories.TransferTypeRepository() as transaction_type_repository:
transaction_type = transaction_type_repository.create(code='create_ask', silver_points=55)
user_from = factories.UserFactory(silver_points=100, username='******')
card_to = factories.DeckFactory(silver_points=0)
self.call_target(
user_from=user_from.id,
card_to=card_to.id,
transaction_type=transaction_type.code
)
self.assertEqual(
factories.UserFactory.get(user_from.id),
factories.UserFactory.build(id=user_from.id, silver_points=100 - transaction_type.silver_points, username='******')
)
self.assertEqual(
factories.CardFactory.get(card_to.id),
factories.CardFactory.build(id=card_to.id, silver_points=0)
)
tr = factories.Transfer.get()[0]
self.assertEqual(
tr,
factories.Transfer.build(
id=tr.id,
user_from=user_from,
card_to=card_to,
silver_points=transaction_type.silver_points,
transaction_type=transaction_type.code,
)
)
def test_basic_info_for_another_user(self):
user = factories.UserFactory()
self.db.session.add(user)
self.db.session.commit()
self.data['user_id'] = user.id
response = self.call_target()
self.assertEqual(response.status, '200 OK')
data = flask.json.loads(response.data)
self.assertEqual(data['id'], user.id)
def test_not_liked_by_user(self):
user = factories.UserFactory()
comment = factories.Comment()
self.db.session.add(user)
self.db.session.add(comment)
self.db.session.commit()
result = comment.to_dict(user)
self.assertEqual(result['likes'], 0)
self.assertEqual(result['liked_by_current_user'], False)
def test_default_fields(self):
writer = factories.UserFactory()
comment = factories.Comment(user=writer)
self.db.session.add(comment)
self.db.session.commit()
result = comment.to_dict()
self.assertEqual(result['likes'], 0)
self.assertEqual(result['liked_by_current_user'], None)
self.assertEqual(result['user_id'], writer.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_username_exists_exception(self):
factories.UserFactory(username='******')
self.db.session.commit()
result = self.call_target(username="******",
email="*****@*****.**")
self.assertEqual(
result,
factories.JsonResponseFactory.build(
data={'error': 'username_exists'}))
def test_liked_by_user(self):
user = factories.UserFactory()
comment = factories.Comment()
comment_like = factories.CommentLike(user=user, comment=comment)
self.db.session.add(user)
self.db.session.add(comment)
self.db.session.add(comment_like)
self.db.session.commit()
result = comment.to_dict(user)
self.assertEqual(result['likes'], 1)
self.assertEqual(result['liked_by_current_user'], True)
def test_sponsors(self):
ask = factories.AskDeckFactory(id="ask_id")
user = factories.UserFactory()
self.db.session.commit()
urc = UserRoleCard(user_id=user.id,
role_id=CardRole.JOINED,
card_id=ask.id,
contribution=16)
self.db.session.add(urc)
self.db.session.commit()
res = ask.to_dict()
self.assertEqual(len(res['sponsors']), 1)
self.assertEqual(res['sponsors'][0]['user_id'], user.id)
self.assertEqual(res['sponsors'][0]['contribution'], 16)
def test_winners(self):
ask = factories.AskDeckFactory(id="ask_id")
user = factories.UserFactory()
self.db.session.commit()
urc = UserRoleCard(user_id=user.id,
role_id=CardRole.GIVER,
card_id=ask.id,
prize=15)
self.db.session.add(urc)
self.db.session.commit()
res = ask.to_dict()
self.assertEqual(len(res['winners']), 1)
self.assertEqual(res['winners'][0]['user_id'], user.id)
self.assertEqual(res['winners'][0]['prize'], 15)
def test_succcess(self):
user = factories.UserFactory(email='*****@*****.**',
verification_code='12345',
active=False)
self.db.session.commit()
result = self.call_target(email="*****@*****.**", code='12345')
self.assertEqual(result, factories.JsonResponseFactory.build())
user = factories.UserFactory.get(email="*****@*****.**")
self.assertEqual(user.active, True)
self.assertEqual(user.verification_code, '')
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 test_succcess(self):
card = factories.ImageCardFactory.create(
name='name1', creator=factories.UserFactory())
self.db.session.commit()
result = self.call_target(
card_id=card.id,
comment_content='comment_content1',
)
card = factories.ImageCardFactory.get(card.id)
self.assertEqual(len(card.comments), 1)
comment = card.comments[0]
self.assertEqual(comment.card, card)
self.assertEqual(comment.user, self.user)
self.assertEqual(comment.id, comment.id)
self.assertEqual(comment.content, 'comment_content1')
self.assertEqual(
result,
factories.JsonResponseWithResultStatusFactory.build(
extra_data={'comment': comment.to_dict()}))
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_activate_user_if_was_inactive(self, mfb):
user = factories.UserFactory(email='*****@*****.**',
verification_code='',
active=False,
password='******')
self.db.session.commit()
mfb.return_value = {
'verified': True,
'email': '*****@*****.**',
'thumbnail_url': 'thumbnail_url'
}
result = self.call_target(fb_access_token="fb_access_token", )
self.assertEqual(result.status, '200 OK')
user = factories.UserFactory.get(email="*****@*****.**")
self.assertEqual(user.active, True)
self.assertEqual(user.verification_code, '')
def setUp(self):
super(JoinAskTestCase, self).setUp()
self.user = factories.UserFactory(silver_points=100)
self.db.session.add(self.user)
self.set_current_user(self.user)
# input data
self.owner = User(username='******')
self.db.session.add(self.owner)
self.deck = Card(type=Card.DECK,
name='test_deck',
creator=self.owner,
is_ask_mode_enabled=True,
silver_points=0,
prize_to_join=10)
self.db.session.add(self.deck)
self.db.session.commit()
self.asker_ids = None
self.custom_join_prize = None
self.response = None
def test_verify_with_facebook(self):
user_to = factories.UserFactory(silver_points=30, username='******')
transaction_type = transfer.TYPES['verify_with_facebook']
self.call_target(
user_to=user_to.id,
transaction_type=transaction_type.code
)
self.assertEqual(
factories.UserFactory.get(user_to.id),
factories.UserFactory.build(id=user_to.id, silver_points=30 + transaction_type.silver_points, username='******')
)
tr = factories.Transfer.get()[0]
self.assertEqual(
tr,
factories.Transfer.build(
id=tr.id,
user_to=user_to,
silver_points=transaction_type.silver_points,
transaction_type=transaction_type.code,
)
)
def test_add_sub_comment(self):
card = factories.ImageCardFactory.create(
name='name1', creator=factories.UserFactory())
self.db.session.add(card)
comment = factories.Comment(card=card)
self.db.session.add(comment)
self.db.session.commit()
result = self.call_target(
comment_id=comment.id,
comment_content='sub_comment',
)
self.assertEqual(1, len(comment.sub_comments))
sub_comment = comment.sub_comments[0]
self.assertEqual(sub_comment.card, None)
self.assertEqual(sub_comment.user, self.user)
self.assertEqual(sub_comment.comment.id, comment.id)
self.assertEqual(sub_comment.content, 'sub_comment')
self.assertEqual(
result,
factories.JsonResponseWithResultStatusFactory.build(
extra_data={'comment': sub_comment.to_dict()}))
def test_points_cannot_be_less_than_0(self):
try:
factories.UserFactory(silver_points = -1, gold_points = -1)
self.fail('Value error shoulb be thrown')
except ValueError:
pass
