def test_fetch_group_post_comments(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID, screen_name=GROUP_SCREEN_NAME)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
self.assertEqual(Comment.objects.count(), 0)
comments = post.fetch_comments(sort='desc', count=90)
self.assertTrue(len(comments) == Comment.objects.count() == post.wall_comments.count() == 90)
self.assertEqual(comments[0].post, post)
self.assertEqual(comments[0].wall_owner, group)
# testing `after` parameter
after = Comment.objects.order_by('date')[0].date
Comment.objects.all().delete()
self.assertEqual(Comment.objects.count(), 0)
comments = post.fetch_comments(sort='desc', after=after, count=100)
self.assertTrue(len(comments) == Comment.objects.count() == post.wall_comments.count() == 90)
# testing `before` parameter
before = Comment.objects.order_by('-date')[5].date
Comment.objects.all().delete()
self.assertEqual(Comment.objects.count(), 0)
comments = post.fetch_comments(sort='desc', before=before, after=after)
self.assertTrue(len(comments) == Comment.objects.count() == 85)
# testing `after` and `all` parameters
Comment.objects.all().delete()
self.assertEqual(Comment.objects.count(), 0)
comments = post.fetch_comments(sort='desc', after=after, all=True)
self.assertTrue(len(comments) == Comment.objects.count() == post.wall_comments.count() == 90)
def test_posts_with_posts_in_db(self):
posts_count = 10
PostFactory.create_batch(posts_count)
response = self.app.get('/posts')
self.assertEqual(len(response.json), posts_count)
def test_fetch_post_comments(self):
post = PostFactory(graph_id=POST_WITH_MANY_COMMENTS_ID)
self.assertEqual(Comment.objects.count(), 0)
comments = post.fetch_comments(limit=100)
self.assertEqual(comments.count(), 100)
self.assertEqual(comments.count(), Comment.objects.count())
self.assertEqual(comments.count(), post.comments.count())
comments = post.fetch_comments(all=True)
self.assertTrue(post.comments_count > 1000)
self.assertEqual(post.comments_count, Comment.objects.count())
self.assertEqual(post.comments_count, comments.count())
self.assertEqual(post.comments_count, post.comments.count())
comment = comments.get(graph_id=COMMENT1_ID)
user = User.objects.get(graph_id='100000422272038')
self.assertEqual(user.name, 'Jordan Alvarez')
self.assertEqual(comment.post, post)
self.assertEqual(comment.author, user)
self.assertEqual(comment.message, 'PLAYDOM? bahhhhhhhhh ZYNGA RULES!')
self.assertEqual(comment.can_remove, False)
self.assertEqual(comment.user_likes, False)
self.assertTrue(isinstance(comment.created_time, datetime))
self.assertTrue(comment.likes_count > 5)
def test_post_prepare_delete_params(self):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id='%s_17' % GROUP_ID, wall_owner=group)
expected_params = {
'owner_id': GROUP_ID * -1,
'post_id': '17',
}
self.assertEqual(post.prepare_delete_params(), expected_params)
def test_post_prepare_delete_params(self):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id='%s_17' % GROUP_ID, wall_owner=group)
expected_params = {
'owner_id': GROUP_ID * -1,
'post_id': '17',
}
self.assertEqual(post.prepare_delete_params(), expected_params)
def test_post_crud_methods(self):
message = 'Test message'
user = UserFactory.create(remote_id=TRAVIS_USER_ID)
mock_post = PostFactory.create(text=message, wall_owner=user)
#create by objects api
post = Post.objects.create(
**PostFactory.get_mock_params_dict(
mock_post, commit_remote=True)
)
self.assertTrue(post.remote_id > 0)
self.assertEqual(post.text, message)
fetched_post = Post.remote.fetch(ids=[post.remote_id]).first()
self.assertEqual(fetched_post.text, post.text)
# Update
edited_message = 'Edited message with CRUD'
post = Post.objects.get(id=post.id)
post.text = edited_message
post.save(commit_remote=True)
self.assertEqual(post.text, edited_message)
fetched_post = Post.remote.fetch(ids=[post.remote_id]).first()
self.assertEqual(fetched_post.text, edited_message)
# Delete
post.delete()
post1 = Post.objects.get(id=post.id)
self.assertTrue(post1.archived)
fetched_post = Post.remote.fetch(ids=[post.remote_id])
self.assertFalse(fetched_post)
# Restore
post.restore()
post1 = Post.objects.get(id=post.id)
self.assertFalse(post1.archived)
fetched_post = Post.remote.fetch(ids=[post1.remote_id])
self.assertTrue(fetched_post)
post.delete()
# Create with save()
post = Post()
post.__dict__.update(PostFactory.get_mock_params_dict(mock_post))
post.text = message + message
post.save(commit_remote=True)
self.assertTrue(post.remote_id > 0)
self.assertEqual(post.text, message + message)
fetched_post = Post.remote.fetch(ids=[post.remote_id]).first()
self.assertEqual(fetched_post.text, post.text)
post.delete()
def test_fetch_post_likes_parser(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
self.assertEqual(post.like_users.count(), 0)
self.assertEqual(post.likes, 0)
post.fetch_likes(source='parser')
self.assertTrue(post.likes > 120)
self.assertEqual(post.likes, post.like_users.count())
def test_fetch_post_likes_parser(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
self.assertEqual(post.like_users.count(), 0)
self.assertEqual(post.likes, 0)
post.fetch_likes(source='parser')
self.assertTrue(post.likes > 120)
self.assertEqual(post.likes, post.like_users.count())
def test_fetch_post_likes(self):
post = PostFactory(graph_id=POST_WITH_MANY_LIKES_ID)
self.assertEqual(post.like_users.count(), 0)
self.assertEqual(User.objects.count(), 1)
users = post.fetch_likes(all=True)
self.assertTrue(users.count() > 1000)
self.assertEqual(post.likes_count, users.count())
self.assertEqual(post.likes_count, User.objects.count() - 1)
self.assertEqual(post.likes_count, post.like_users.count())
def test_fetch_post_comments_recursive_calls_ammount(self, fetch_method, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
comments = post.fetch_comments(sort='desc', all=True)
self.assertTrue(len(comments) > 105)
self.assertEqual(fetch_method.called, True)
self.assertEqual(fetch_method.call_count, 2)
self.assertEqual(fetch_method.call_args_list[0][1]['offset'], 0)
self.assertEqual(fetch_method.call_args_list[1][1]['offset'], 100)
def test_fetch_user_post_comments(self):
owner = UserFactory(remote_id=USER_ID)
post = PostFactory(remote_id=POST_ID, wall_owner=owner, author=owner)
self.assertEqual(Comment.objects.count(), 0)
comments = post.fetch_comments()
self.assertTrue(len(comments) > 0)
self.assertEqual(Comment.objects.count(), len(comments))
self.assertEqual(comments[0].post, post)
post.fetch_comments(all=True)
def test_fetch_user_post_comments(self):
owner = UserFactory(remote_id=USER_ID)
post = PostFactory(remote_id=POST_ID, wall_owner=owner, author=owner)
self.assertEqual(Comment.objects.count(), 0)
comments = post.fetch_comments()
self.assertTrue(len(comments) > 0)
self.assertEqual(Comment.objects.count(), len(comments))
self.assertEqual(comments[0].post, post)
post.fetch_comments(all=True)
def test_fetch_post_comments_recursive_calls_ammount(
self, fetch_method, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
comments = post.fetch_comments(sort='desc', all=True)
self.assertTrue(len(comments) > 105)
self.assertEqual(fetch_method.called, True)
self.assertEqual(fetch_method.call_count, 2)
self.assertEqual(fetch_method.call_args_list[0][1]['offset'], 0)
self.assertEqual(fetch_method.call_args_list[1][1]['offset'], 100)
def test_fetch_post_reposts1(self, *args, **kwargs):
group = GroupFactory(remote_id=36948301)
post = PostFactory(remote_id='-36948301_23383', wall_owner=group)
users_initial = User.objects.count()
self.assertEqual(post.repost_users.count(), 0)
users = post.fetch_reposts(all=True)
# print post.reposts
self.assertTrue(post.reposts > 120)
self.assertEqual(post.reposts, users.count())
self.assertEqual(post.reposts, User.objects.count() - users_initial)
self.assertEqual(post.reposts, post.repost_users.count())
def test_fetch_group_post_many_likes(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP2_ID)
post = PostFactory(remote_id=GROUP2_POST_WITH_MANY_LIKES_ID, wall_owner=group)
users_initial = User.objects.count()
self.assertEqual(post.like_users.count(), 0)
self.assertEqual(post.likes, 0)
users = post.fetch_likes(all=True)
self.assertTrue(post.likes > 3800)
self.assertEqual(post.likes, len(users))
self.assertEqual(post.likes, User.objects.count() - users_initial)
self.assertEqual(post.likes, post.like_users.count())
def test_fetch_post_reposts(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
users_initial = User.objects.count()
self.assertEqual(post.repost_users.count(), 0)
users = post.fetch_reposts(all=True)
self.assertTrue(post.reposts > 20)
# self.assertTrue(len(post.reposters) > 20)
self.assertEqual(post.reposts, users.count())
self.assertEqual(post.reposts, User.objects.count() - users_initial)
self.assertEqual(post.reposts, post.repost_users.count())
def test_fetch_post_reposts(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
users_initial = User.objects.count()
self.assertEqual(post.repost_users.count(), 0)
users = post.fetch_reposts(all=True)
self.assertTrue(post.reposts > 20)
# self.assertTrue(len(post.reposters) > 20)
self.assertEqual(post.reposts, users.count())
self.assertEqual(post.reposts, User.objects.count() - users_initial)
self.assertEqual(post.reposts, post.repost_users.count())
def test_fetch_post_reposts1(self, *args, **kwargs):
group = GroupFactory(remote_id=36948301)
post = PostFactory(remote_id='-36948301_23383', wall_owner=group)
users_initial = User.objects.count()
self.assertEqual(post.repost_users.count(), 0)
users = post.fetch_reposts(all=True)
# print post.reposts
self.assertTrue(post.reposts > 120)
self.assertEqual(post.reposts, users.count())
self.assertEqual(post.reposts, User.objects.count() - users_initial)
self.assertEqual(post.reposts, post.repost_users.count())
def test_fetch_group_post_many_likes(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP2_ID)
post = PostFactory(remote_id=GROUP2_POST_WITH_MANY_LIKES_ID,
wall_owner=group)
users_initial = User.objects.count()
self.assertEqual(post.like_users.count(), 0)
self.assertEqual(post.likes, 0)
users = post.fetch_likes(all=True)
self.assertTrue(post.likes > 3800)
self.assertEqual(post.likes, len(users))
self.assertEqual(post.likes, User.objects.count() - users_initial)
self.assertEqual(post.likes, post.like_users.count())
def test_parse_comments(self):
response = '''{"response":[6,
{"cid":2505,"uid":16271479,"date":1298365200,"text":"Добрый день , кароче такая идея когда опросы создаешь вместо статуса - можно выбрать аудитории опрашиваемых, например только женский или мужской пол могут участвовать (то бишь голосовать в опросе)."},
{"cid":2507,"uid":16271479,"date":1286105582,"text":"Это уже не практично, имхо.<br>Для этого делайте группу и там опрос, а в группу принимайте тех, кого нужно.","reply_to_uid":16271479,"reply_to_cid":2505},
{"cid":2547,"uid":2943,"date":1286218080,"text":"Он будет только для групп благотворительных организаций."}]}
'''
group = GroupFactory.create(remote_id=OWNER_ID)
post = PostFactory.create(remote_id=TR_POST_ID, wall_owner=group)
instance = CommentFactory.create(post=post)
author = UserFactory.create(remote_id=16271479)
instance.parse(json.loads(response)['response'][1])
instance.save()
self.assertEqual(instance.remote_id, '201164356_2505')
self.assertEqual(instance.text, u'Добрый день , кароче такая идея когда опросы создаешь вместо статуса - можно выбрать аудитории опрашиваемых, например только женский или мужской пол могут участвовать (то бишь голосовать в опросе).')
self.assertEqual(instance.author, author)
self.assertTrue(isinstance(instance.date, datetime))
instance = Comment(post=post)
instance.parse(json.loads(response)['response'][2])
instance.save()
self.assertEqual(instance.remote_id, '201164356_2507')
self.assertEqual(instance.reply_for.remote_id, 16271479)
def test_comment_crud_methods(self):
text = 'Test message'
user = UserFactory.create(remote_id=TRAVIS_USER_ID)
post = PostFactory.create(remote_id=TR_POST_ID, wall_owner=user)
mock_comment = CommentFactory.create(text=text, post=post, wall_owner=user)
# Create
comment = Comment.objects.create(
**CommentFactory.get_mock_params_dict(
mock_comment, commit_remote=True)
)
self.assertTrue(comment.remote_id > 0)
self.assertEqual(comment.text, text)
fetched_comment = post.fetch_comments(sort='asc').first()
self.assertEqual(fetched_comment.text, text)
# Update
edited_message = 'Edited comment message'
comment = Comment.objects.get(id=comment.id)
comment.text = edited_message
comment.save(commit_remote=True)
self.assertEqual(comment.text, edited_message)
fetched_comment = post.fetch_comments(sort='asc').first()
self.assertEqual(fetched_comment.text, edited_message)
# Delete
comment.delete()
comment1 = Comment.objects.get(id=comment.id)
self.assertTrue(comment1.archived)
fetched_ids = [comment.remote_id for comment in post.fetch_comments()]
self.assertFalse(comment1.remote_id in fetched_ids)
# Restore
comment.restore()
comment1 = Comment.objects.get(id=comment.id)
self.assertFalse(comment1.archived)
fetched_ids = [comment.remote_id for comment in post.fetch_comments()]
self.assertTrue(comment1.remote_id in fetched_ids)
# Create with save()
comment = Comment()
comment.__dict__.update(
CommentFactory.get_mock_params_dict(mock_comment)
)
comment.text = text + text
comment.save(commit_remote=True)
self.assertTrue(comment.remote_id > 0)
self.assertEqual(comment.text, text + text)
fetched_comment = post.fetch_comments(sort='asc').first()
self.assertEqual(fetched_comment.text, text + text)
comment.delete()
def test_parse_comment(self):
response = '''{"response":[6,
{"cid":2505,"uid":16271479,"date":1298365200,"text":"Добрый день , кароче такая идея когда опросы создаешь вместо статуса - можно выбрать аудитории опрашиваемых, например только женский или мужской пол могут участвовать (то бишь голосовать в опросе)."},
{"cid":2507,"uid":16271479,"date":1286105582,"text":"Это уже не практично, имхо.<br>Для этого делайте группу и там опрос, а в группу принимайте тех, кого нужно.","reply_to_uid":16271479,"reply_to_cid":2505},
{"cid":2547,"uid":2943,"date":1286218080,"text":"Он будет только для групп благотворительных организаций."}]}
'''
user = UserFactory(remote_id=USER_ID)
post = PostFactory(remote_id=POST_ID, wall_owner=user)
#instance = Comment(post=post)
instance = CommentFactory(post=post)
author = UserFactory(remote_id=16271479)
instance.parse(json.loads(response)['response'][1])
instance.save()
self.assertEqual(instance.remote_id, '%s_2505' % USER_ID)
self.assertEqual(
instance.text,
u'Добрый день , кароче такая идея когда опросы создаешь вместо статуса - можно выбрать аудитории опрашиваемых, например только женский или мужской пол могут участвовать (то бишь голосовать в опросе).'
)
self.assertEqual(instance.author, author)
self.assertTrue(isinstance(instance.date, datetime))
instance = Comment(post=post)
instance.parse(json.loads(response)['response'][2])
instance.save()
self.assertEqual(instance.remote_id, '%s_2507' % USER_ID)
self.assertEqual(instance.reply_for.remote_id, 16271479)
def test_fetch_group_post_comments_bad_unicode(self, *args, **kwargs):
# http://vk.com/wall-23482909_195292
# UnicodeDecodeError: 'utf8' codec can't decode byte 0xca in position 0: invalid continuation byte
group = GroupFactory(remote_id=23482909)
post = PostFactory(remote_id='-23482909_195292', wall_owner=group)
comments = post.fetch_comments(sort='desc', count=100)
self.assertTrue(comments.count() > 0)
# http://vk.com/wall-41330561_73352
# UnicodeDecodeError: 'utf8' codec can't decode byte 0xd3 in position 0: invalid continuation byte
group = GroupFactory(remote_id=41330561)
post = PostFactory(remote_id='-41330561_73352', wall_owner=group)
comments = post.fetch_comments(sort='desc', count=100)
self.assertTrue(comments.count() > 0)
def test_fetch_group_post_changing_reposts(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
resources1 = [{'from_id': 1, 'date': int(time.time()) - 1000}]
with mock.patch('vkontakte_wall.models.Post.fetch_repost_items', side_effect=lambda **kw: resources1):
users1 = post.fetch_reposts(all=True)
state_time1 = post.repost_users.last_update_time()
state_time_add1 = datetime.fromtimestamp(resources1[0]['date'])
self.assertEqual(post.repost_users.count(), users1.count())
self.assertEqual(post.repost_users.count(), 1)
self.assertItemsEqual(post.repost_users.all(), User.objects.filter(remote_id__in=[1]))
resources2 = [{'from_id': 2, 'date': int(time.time()) - 500}]
with mock.patch('vkontakte_wall.models.Post.fetch_repost_items', side_effect=lambda **kw: resources1 + resources2):
users2 = post.fetch_reposts(all=True)
state_time2 = post.repost_users.last_update_time()
state_time_add2 = datetime.fromtimestamp(resources2[0]['date'])
self.assertEqual(post.repost_users.count(), users2.count())
self.assertEqual(post.repost_users.count(), 2)
self.assertItemsEqual(post.repost_users.all(), User.objects.filter(remote_id__in=[1, 2]))
resources3 = [{'from_id': 3, 'date': int(time.time()) - 100}]
with mock.patch('vkontakte_wall.models.Post.fetch_repost_items', side_effect=lambda **kw: resources3):
users3 = post.fetch_reposts(all=True)
state_time3 = post.repost_users.last_update_time()
state_time_add3 = datetime.fromtimestamp(resources3[0]['date'])
self.assertEqual(post.repost_users.count(), users3.count())
self.assertEqual(post.repost_users.count(), 1)
self.assertItemsEqual(post.repost_users.all(), User.objects.filter(remote_id__in=[3]))
self.assertItemsEqual(post.repost_users.were_at(state_time1, only_pk=True), [1])
self.assertItemsEqual(post.repost_users.were_at(state_time2, only_pk=True), [1, 2])
self.assertItemsEqual(post.repost_users.were_at(state_time3, only_pk=True), [3])
self.assertItemsEqual(post.repost_users.added_at(state_time_add1, only_pk=True), [1])
self.assertItemsEqual(post.repost_users.removed_at(state_time1, only_pk=True), [])
self.assertItemsEqual(post.repost_users.added_at(state_time_add2, only_pk=True), [2])
self.assertItemsEqual(post.repost_users.removed_at(state_time2, only_pk=True), [])
self.assertItemsEqual(post.repost_users.added_at(state_time_add3, only_pk=True), [3])
self.assertItemsEqual(post.repost_users.removed_at(state_time3, only_pk=True), [1, 2])
def test_fetch_post_reposts(self, *args, **kwargs):
group = GroupFactory.create(remote_id=GROUP_ID)
post = PostFactory.create(remote_id=GROUP_POST_ID, wall_owner=group)
self.assertTrue(post.repost_users.count() == 0)
users = post.fetch_reposts(all=True)
self.assertTrue(post.reposts >= 20)
self.assertTrue(post.reposts == post.repost_users.count() == users.count())
group = GroupFactory.create(remote_id=36948301)
post = PostFactory.create(remote_id='-36948301_13599', wall_owner=group)
self.assertTrue(post.reposts == post.repost_users.count() == 0)
users = post.fetch_reposts(all=True)
self.assertTrue(post.reposts == 1)
self.assertTrue(post.reposts == post.repost_users.count() == users.count())
def test_post_prepare_delete_restore_params(self):
group = GroupFactory.create(remote_id=OWNER_ID)
post = PostFactory.create(remote_id='%s_17' % OWNER_ID, wall_owner=group)
expected_params = {
'owner_id': OWNER_ID,
'post_id': '17',
}
self.assertEqual(post.prepare_delete_restore_params(), expected_params)
def init():
"""
Populate data
"""
User.objects.filter(email='*****@*****.**').delete()
user = UserFactory(email='*****@*****.**')
logger.debug('User %s', user)
posts = PostFactory.create_batch(10, author=user)
logger.debug('Created posts %s', posts)
def test_fetch_group_post_updating_initial_reposts_time_from(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
post.repost_users.through.objects.bulk_create([post.repost_users.through(user_id=1, post_id=post.pk)])
self.assertEqual(post.repost_users.through.objects.count(), 1)
resources = [{'from_id': 1, 'date': int(time.time())}]
with mock.patch('vkontakte_wall.models.Post.fetch_repost_items', side_effect=lambda **kw: resources):
post.fetch_reposts(all=True)
self.assertEqual(post.repost_users.through.objects.count(), 1)
instance = post.repost_users.through.objects.all()[0]
self.assertEqual(instance.user_id, 1)
self.assertEqual(instance.post_id, post.pk)
self.assertEqual(instance.time_from, datetime.fromtimestamp(resources[0]['date']))
def test_ordering(self):
posts = PostFactory.create_batch(3)
response = self.app.get('/posts?order=-title')
sorted_posts = sorted(posts, key=lambda x: x.title, reverse=True)
self.assertEqual(
list(map(lambda x: x['title'], response.json)),
[post.title for post in sorted_posts],
)
def test_fetch_comment_likes(self, *args, **kwargs):
user = UserFactory.create(remote_id=TRAVIS_USER_ID)
post = PostFactory.create(remote_id=TR_POST_ID, wall_owner=user)
comment = post.fetch_comments().last()
self.assertTrue(comment.like_users.count() == 0)
comment.fetch_likes(all=True)
self.assertTrue(comment.like_users.count() >= 1)
self.assertTrue(comment.likes >= 1)
def test_offset(self):
posts_count = 10
offset = 5
posts = PostFactory.create_batch(posts_count)
response = self.app.get(f'/posts?offset={offset}')
self.assertEqual(
list(map(lambda x: x['id'], response.json)),
[post.external_id for post in posts][offset:],
)
def test_fetch_group_post_changing_likes(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP2_ID)
post = PostFactory(remote_id=GROUP2_POST_WITH_MANY_LIKES_ID, wall_owner=group)
ids1 = range(100, 200)
with mock.patch('vkontakte_users.models.User.remote.fetch_likes_user_ids', side_effect=lambda **kw: ids1):
users1 = post.fetch_likes(all=True)
state_time1 = post.like_users.last_update_time()
self.assertEqual(post.like_users.count(), users1.count())
self.assertEqual(post.like_users.count(), len(ids1))
self.assertItemsEqual(post.like_users.all(), User.objects.filter(remote_id__in=ids1))
ids2 = range(50, 150)
with mock.patch('vkontakte_users.models.User.remote.fetch_likes_user_ids', side_effect=lambda **kw: ids2):
users2 = post.fetch_likes(all=True)
state_time2 = post.like_users.last_update_time()
self.assertEqual(post.like_users.count(), users2.count())
self.assertEqual(post.like_users.count(), len(ids2))
self.assertItemsEqual(post.like_users.all(), User.objects.filter(remote_id__in=ids2))
ids3 = range(0, 30)
with mock.patch('vkontakte_users.models.User.remote.fetch_likes_user_ids', side_effect=lambda **kw: ids3):
users3 = post.fetch_likes(all=True)
state_time3 = post.like_users.last_update_time()
self.assertEqual(post.like_users.count(), users3.count())
self.assertEqual(post.like_users.count(), len(ids3))
self.assertItemsEqual(post.like_users.all(), User.objects.filter(remote_id__in=ids3))
self.assertItemsEqual(post.like_users.were_at(state_time1, only_pk=True), ids1)
self.assertItemsEqual(post.like_users.were_at(state_time2, only_pk=True), ids2)
self.assertItemsEqual(post.like_users.were_at(state_time3, only_pk=True), ids3)
self.assertItemsEqual(post.like_users.added_at(state_time2, only_pk=True), range(50, 100))
self.assertItemsEqual(post.like_users.removed_at(state_time2, only_pk=True), range(150, 200))
self.assertItemsEqual(post.like_users.added_at(state_time3, only_pk=True), range(0, 30))
self.assertItemsEqual(post.like_users.removed_at(state_time3, only_pk=True), range(50, 150))
def test_post_prepare_create_params(self):
text = 'test text'
expected_config = {
'owner_id': GROUP_ID * -1,
'friends_only': 0,
'from_group': '',
'message': text,
'attachments': u'',
'services': '',
'signed': 0,
'publish_date': '',
'lat': '',
'long': '',
'place_id': '',
'post_id': ''
}
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory()
post.wall_owner = group
post.text = text
self.assertEqual(post.prepare_create_params(), expected_config)
def test_post_prepare_create_params(self):
text = 'test text'
expected_config = {
'owner_id': GROUP_ID * -1,
'friends_only': 0,
'from_group': '',
'message': text,
'attachments': u'',
'services': '',
'signed': 0,
'publish_date': '',
'lat': '',
'long': '',
'place_id': '',
'post_id': ''
}
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory()
post.wall_owner = group
post.text = text
self.assertEqual(post.prepare_create_params(), expected_config)
def test_post_fetch_shares(self):
post = PostFactory(graph_id=POST_WITH_MANY_LIKES_ID)
self.assertEqual(post.shares_users.count(), 0)
self.assertEqual(User.objects.count(), 1)
users = post.fetch_shares(all=True)
self.assertTrue(users.count() >= 40)
self.assertEqual(post.shares_count, users.count())
self.assertEqual(post.shares_count, User.objects.count() - 1)
self.assertEqual(post.shares_count, post.shares_users.count())
post = PostFactory(graph_id='1411299469098495_1534163126812128')
users = post.fetch_shares(all=True)
self.assertTrue(users.count() >= 8)
count = users.count()
users = post.fetch_shares(all=True)
self.assertEqual(users.count(), count)
def test_fetch_group_post_updating_initial_reposts_time_from(
self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
post.repost_users.through.objects.bulk_create(
[post.repost_users.through(user_id=1, post_id=post.pk)])
self.assertEqual(post.repost_users.through.objects.count(), 1)
resources = [{'from_id': 1, 'date': int(time.time())}]
with mock.patch('vkontakte_wall.models.Post.fetch_repost_items',
side_effect=lambda **kw: resources):
post.fetch_reposts(all=True)
self.assertEqual(post.repost_users.through.objects.count(), 1)
instance = post.repost_users.through.objects.all()[0]
self.assertEqual(instance.user_id, 1)
self.assertEqual(instance.post_id, post.pk)
self.assertEqual(instance.time_from,
datetime.fromtimestamp(resources[0]['date']))
def test_post_fields(self):
post = PostFactory(
external_id=1,
title='test',
url='http://example.com',
created=datetime(2000, 1, 1),
)
response = self.app.get('/posts')
self.assertEqual(
response.json,
[self.get_post_as_dict(post)],
)
def test_fetch_group_post_likes(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
self.assertEqual(post.like_users.count(), 0)
self.assertEqual(post.likes, 0)
users_initial = User.objects.count()
users = post.fetch_likes(all=True)
self.assertTrue(post.likes > 120)
self.assertEqual(post.likes, len(users))
self.assertEqual(post.likes, User.objects.count() - users_initial)
self.assertEqual(post.likes, post.like_users.count())
# try to fetch again
likes = post.likes
users = post.fetch_likes(all=True)
self.assertEqual(post.likes, likes)
self.assertEqual(post.likes, len(users))
self.assertEqual(post.likes, User.objects.count() - users_initial)
self.assertEqual(post.likes, post.like_users.count())
def test_fetch_group_post_likes(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
self.assertEqual(post.like_users.count(), 0)
self.assertEqual(post.likes, 0)
users_initial = User.objects.count()
users = post.fetch_likes(all=True)
self.assertTrue(post.likes > 120)
self.assertEqual(post.likes, len(users))
self.assertEqual(post.likes, User.objects.count() - users_initial)
self.assertEqual(post.likes, post.like_users.count())
# try to fetch again
likes = post.likes
users = post.fetch_likes(all=True)
self.assertEqual(post.likes, likes)
self.assertEqual(post.likes, len(users))
self.assertEqual(post.likes, User.objects.count() - users_initial)
self.assertEqual(post.likes, post.like_users.count())
def test_fetch_post_likes(self, *args, **kwargs):
group = GroupFactory.create(remote_id=GROUP_ID)
post = PostFactory.create(remote_id=GROUP_POST_ID, wall_owner=group)
self.assertTrue(post.likes == post.like_users.count() == 0)
post.fetch_likes(source='parser')
self.assertTrue(post.likes == post.like_users.count() > 120)
post.like_users.all().delete()
post.likes = 0
post.save()
self.assertTrue(post.likes == post.like_users.count() == 0)
post.fetch_likes(all=True)
self.assertTrue(post.likes == post.like_users.count() > 120)
def test_fetch_group_post_comment_likes(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
comment = CommentFactory(remote_id=GROUP_COMMENT_ID,
post=post,
wall_owner=group)
self.assertEqual(comment.like_users.count(), 0)
self.assertEqual(comment.likes, 0)
users_initial = User.objects.count()
users = comment.fetch_likes(all=True)
self.assertTrue(comment.likes > 0)
self.assertEqual(comment.likes, len(users))
self.assertEqual(comment.likes, User.objects.count() - users_initial)
self.assertEqual(comment.likes, comment.like_users.count())
def test_make_commnet(self):
post = PostFactory()
query = """
mutation myFirstMutation {
makeComment(postId: "%s", name: "Just do it", content: "Yesterday you sad tomorrow") {
post {
id
}
}
}
""" % post.id
data = run_query(schema, query)
expect = {
"makeComment": {
"post": {
'id': id
},
}
}
self.assertDictContainsSubset(expect, data)
def test_post_prepare_update_params(self):
group = GroupFactory.create(remote_id=OWNER_ID)
post = PostFactory.create(remote_id='%s_17' % OWNER_ID, wall_owner=group)
update_text = 'update text'
expected_config = {
'owner_id': OWNER_ID,
'friends_only': 0,
'from_group': '',
'message': update_text,
'attachments': u'',
'services': '',
'signed': 0,
'publish_date': '',
'lat': '',
'long': '',
'place_id': '',
'post_id': '17'
}
post1 = Post.objects.get(id=post.id)
post1.text = update_text
self.assertEqual(post1.prepare_update_params(), expected_config)
def test_post_prepare_update_params(self):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id='%s_17' % GROUP_ID, wall_owner=group)
update_text = 'update text'
expected_config = {
'owner_id': GROUP_ID * -1,
'friends_only': 0,
'from_group': '',
'message': update_text,
'attachments': u'',
'services': '',
'signed': 0,
'publish_date': '',
'lat': '',
'long': '',
'place_id': '',
'post_id': u'17'
}
post1 = Post.objects.get(id=post.id)
post1.text = update_text
self.assertEqual(post1.prepare_update_params(), expected_config)
def test_fetch_group_post_comments_bad_unicode(self, *args, **kwargs):
# http://vk.com/wall-23482909_195292
# UnicodeDecodeError: 'utf8' codec can't decode byte 0xca in position 0: invalid continuation byte
group = GroupFactory(remote_id=23482909)
post = PostFactory(remote_id='-23482909_195292', wall_owner=group)
comments = post.fetch_comments(sort='desc', count=100)
self.assertTrue(comments.count() > 0)
# http://vk.com/wall-41330561_73352
# UnicodeDecodeError: 'utf8' codec can't decode byte 0xd3 in position 0: invalid continuation byte
group = GroupFactory(remote_id=41330561)
post = PostFactory(remote_id='-41330561_73352', wall_owner=group)
comments = post.fetch_comments(sort='desc', count=100)
self.assertTrue(comments.count() > 0)
def test_fetch_group_post_comments(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID, screen_name=GROUP_SCREEN_NAME)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
self.assertEqual(Comment.objects.count(), 0)
comments = post.fetch_comments(sort='desc', count=90)
self.assertTrue(
len(comments) == Comment.objects.count() ==
post.wall_comments.count() == 90)
self.assertEqual(comments[0].post, post)
self.assertEqual(comments[0].wall_owner, group)
# testing `after` parameter
after = Comment.objects.order_by('date')[0].date
Comment.objects.all().delete()
self.assertEqual(Comment.objects.count(), 0)
comments = post.fetch_comments(sort='desc', after=after, count=100)
self.assertTrue(
len(comments) == Comment.objects.count() ==
post.wall_comments.count() == 90)
# testing `before` parameter
before = Comment.objects.order_by('-date')[5].date
Comment.objects.all().delete()
self.assertEqual(Comment.objects.count(), 0)
comments = post.fetch_comments(sort='desc', before=before, after=after)
self.assertTrue(len(comments) == Comment.objects.count() == 85)
# testing `after` and `all` parameters
Comment.objects.all().delete()
self.assertEqual(Comment.objects.count(), 0)
comments = post.fetch_comments(sort='desc', after=after, all=True)
self.assertTrue(
len(comments) == Comment.objects.count() ==
post.wall_comments.count() == 90)
def test_fetch_group_post_changing_likes(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP2_ID)
post = PostFactory(remote_id=GROUP2_POST_WITH_MANY_LIKES_ID,
wall_owner=group)
ids1 = range(100, 200)
with mock.patch(
'vkontakte_users.models.User.remote.fetch_likes_user_ids',
side_effect=lambda **kw: ids1):
users1 = post.fetch_likes(all=True)
state_time1 = post.like_users.last_update_time()
self.assertEqual(post.like_users.count(), users1.count())
self.assertEqual(post.like_users.count(), len(ids1))
self.assertItemsEqual(post.like_users.all(),
User.objects.filter(remote_id__in=ids1))
ids2 = range(50, 150)
with mock.patch(
'vkontakte_users.models.User.remote.fetch_likes_user_ids',
side_effect=lambda **kw: ids2):
users2 = post.fetch_likes(all=True)
state_time2 = post.like_users.last_update_time()
self.assertEqual(post.like_users.count(), users2.count())
self.assertEqual(post.like_users.count(), len(ids2))
self.assertItemsEqual(post.like_users.all(),
User.objects.filter(remote_id__in=ids2))
ids3 = range(0, 30)
with mock.patch(
'vkontakte_users.models.User.remote.fetch_likes_user_ids',
side_effect=lambda **kw: ids3):
users3 = post.fetch_likes(all=True)
state_time3 = post.like_users.last_update_time()
self.assertEqual(post.like_users.count(), users3.count())
self.assertEqual(post.like_users.count(), len(ids3))
self.assertItemsEqual(post.like_users.all(),
User.objects.filter(remote_id__in=ids3))
self.assertItemsEqual(
post.like_users.were_at(state_time1, only_pk=True), ids1)
self.assertItemsEqual(
post.like_users.were_at(state_time2, only_pk=True), ids2)
self.assertItemsEqual(
post.like_users.were_at(state_time3, only_pk=True), ids3)
self.assertItemsEqual(
post.like_users.added_at(state_time2, only_pk=True),
range(50, 100))
self.assertItemsEqual(
post.like_users.removed_at(state_time2, only_pk=True),
range(150, 200))
self.assertItemsEqual(
post.like_users.added_at(state_time3, only_pk=True), range(0, 30))
self.assertItemsEqual(
post.like_users.removed_at(state_time3, only_pk=True),
range(50, 150))
def make_post_list(posts_json): return [PostFactory.make_post(post_json) for post_json in reversed(posts_json)]
def test_comment_crud_methods(self):
group = GroupFactory(remote_id=GROUP_CRUD_ID)
post = PostFactory(remote_id=POST_CRUD_ID, text='', wall_owner=group)
user = UserFactory(remote_id=USER_AUTHOR_ID)
def assert_local_equal_to_remote(comment):
comment_remote = Comment.remote.fetch_post(post=comment.post).get(
remote_id=comment.remote_id)
self.assertEqual(comment_remote.remote_id, comment.remote_id)
self.assertEqual(comment_remote.text, comment.text)
Comment.remote.fetch_post(post=post)
self.assertEqual(Comment.objects.count(), 0)
# create
comment = Comment(text='Test comment',
post=post,
wall_owner=group,
author=user,
date=datetime.now())
comment.save(commit_remote=True)
self.objects_to_delete += [comment]
self.assertEqual(Comment.objects.count(), 1)
self.assertNotEqual(len(comment.remote_id), 0)
assert_local_equal_to_remote(comment)
# create by manager
comment = Comment.objects.create(
text='Test comment created by manager',
post=post,
wall_owner=group,
author=user,
date=datetime.now(),
commit_remote=True)
self.objects_to_delete += [comment]
self.assertEqual(Comment.objects.count(), 2)
self.assertNotEqual(len(comment.remote_id), 0)
assert_local_equal_to_remote(comment)
# update
comment.text = 'Test comment updated'
comment.save(commit_remote=True)
self.assertEqual(Comment.objects.count(), 2)
assert_local_equal_to_remote(comment)
# delete
comment.delete(commit_remote=True)
self.assertEqual(Comment.objects.count(), 2)
self.assertTrue(comment.archived)
self.assertEqual(
Comment.remote.fetch_post(post=comment.post).filter(
remote_id=comment.remote_id).count(), 0)
# restore
comment.restore(commit_remote=True)
self.assertFalse(comment.archived)
self.assertEqual(Comment.objects.count(), 2)
assert_local_equal_to_remote(comment)
def test_fetch_group_post_changing_reposts(self, *args, **kwargs):
group = GroupFactory(remote_id=GROUP_ID)
post = PostFactory(remote_id=GROUP_POST_ID, wall_owner=group)
resources1 = [{'from_id': 1, 'date': int(time.time()) - 1000}]
with mock.patch('vkontakte_wall.models.Post.fetch_repost_items',
side_effect=lambda **kw: resources1):
users1 = post.fetch_reposts(all=True)
state_time1 = post.repost_users.last_update_time()
state_time_add1 = datetime.fromtimestamp(resources1[0]['date'])
self.assertEqual(post.repost_users.count(), users1.count())
self.assertEqual(post.repost_users.count(), 1)
self.assertItemsEqual(post.repost_users.all(),
User.objects.filter(remote_id__in=[1]))
resources2 = [{'from_id': 2, 'date': int(time.time()) - 500}]
with mock.patch('vkontakte_wall.models.Post.fetch_repost_items',
side_effect=lambda **kw: resources1 + resources2):
users2 = post.fetch_reposts(all=True)
state_time2 = post.repost_users.last_update_time()
state_time_add2 = datetime.fromtimestamp(resources2[0]['date'])
self.assertEqual(post.repost_users.count(), users2.count())
self.assertEqual(post.repost_users.count(), 2)
self.assertItemsEqual(post.repost_users.all(),
User.objects.filter(remote_id__in=[1, 2]))
resources3 = [{'from_id': 3, 'date': int(time.time()) - 100}]
with mock.patch('vkontakte_wall.models.Post.fetch_repost_items',
side_effect=lambda **kw: resources3):
users3 = post.fetch_reposts(all=True)
state_time3 = post.repost_users.last_update_time()
state_time_add3 = datetime.fromtimestamp(resources3[0]['date'])
self.assertEqual(post.repost_users.count(), users3.count())
self.assertEqual(post.repost_users.count(), 1)
self.assertItemsEqual(post.repost_users.all(),
User.objects.filter(remote_id__in=[3]))
self.assertItemsEqual(
post.repost_users.were_at(state_time1, only_pk=True), [1])
self.assertItemsEqual(
post.repost_users.were_at(state_time2, only_pk=True), [1, 2])
self.assertItemsEqual(
post.repost_users.were_at(state_time3, only_pk=True), [3])
self.assertItemsEqual(
post.repost_users.added_at(state_time_add1, only_pk=True), [1])
self.assertItemsEqual(
post.repost_users.removed_at(state_time1, only_pk=True), [])
self.assertItemsEqual(
post.repost_users.added_at(state_time_add2, only_pk=True), [2])
self.assertItemsEqual(
post.repost_users.removed_at(state_time2, only_pk=True), [])
self.assertItemsEqual(
post.repost_users.added_at(state_time_add3, only_pk=True), [3])
self.assertItemsEqual(
post.repost_users.removed_at(state_time3, only_pk=True), [1, 2])
