def test_page_fetch_posts(self):
page = PageFactory(graph_id=PAGE_ID)
self.assertEqual(Post.objects.count(), 0)
posts = page.fetch_posts(limit=25)
self.assertEqual(posts.count(), 25)
self.assertEqual(posts.count(), Post.objects.count())
earliest = posts.aggregate(Min('created_time'))['created_time__min'] - timedelta(30)
posts = page.fetch_posts(all=True, since=earliest)
self.assertGreater(posts.count(), 25)
self.assertEqual(posts.count(), Post.objects.count())
earliest1 = posts.aggregate(Min('created_time'))['created_time__min']
self.assertTrue(earliest <= earliest1)
# posts = page.fetch_posts(all=True, limit=95)
# posts_count = Post.objects.count()
#
# self.assertGreaterEqual(posts.count(), 95)
# self.assertEqual(posts.count(), posts_count)
Post.objects.all().delete()
posts = page.fetch_posts(all=True, since=timezone.now() - timedelta(10))
self.assertEqual(posts.count(), Post.objects.count())
self.assertLess(posts.count(), 25)
def test_page_fetch_posts(self):
page = PageFactory(graph_id=PAGE_ID)
self.assertEqual(Post.objects.count(), 0)
posts = page.fetch_posts(limit=25)
self.assertEqual(posts.count(), 25)
self.assertEqual(posts.count(), Post.objects.count())
earliest = posts.aggregate(
Min('created_time'))['created_time__min'] - timedelta(30)
posts = page.fetch_posts(all=True, since=earliest)
self.assertGreater(posts.count(), 25)
self.assertEqual(posts.count(), Post.objects.count())
earliest1 = posts.aggregate(Min('created_time'))['created_time__min']
self.assertTrue(earliest <= earliest1)
# posts = page.fetch_posts(all=True, limit=95)
# posts_count = Post.objects.count()
#
# self.assertGreaterEqual(posts.count(), 95)
# self.assertEqual(posts.count(), posts_count)
Post.objects.all().delete()
posts = page.fetch_posts(all=True,
since=timezone.now() - timedelta(10))
self.assertEqual(posts.count(), Post.objects.count())
self.assertLess(posts.count(), 25)
def test_page_fetch_many_posts(self):
page = PageFactory(graph_id=PAGE1_ID)
self.assertEqual(Post.objects.count(), 0)
posts = page.fetch_posts(all=True, since=datetime(2014, 1, 1).replace(tzinfo=timezone.utc))
self.assertGreater(posts.count(), 250)
self.assertEqual(posts.count(), Post.objects.count())
self.assertEqual(posts.filter(created_time__lte=datetime(2014, 1, 7).replace(tzinfo=timezone.utc)).count(), 1)
def test_fetch_page_many_posts(self):
page = PageFactory(graph_id=PAGE1_ID)
self.assertEqual(Post.objects.count(), 0)
posts = page.fetch_posts(since=datetime(2014, 1, 1))
posts_count = Post.objects.count()
self.assertTrue(posts_count > 250)
self.assertEqual(posts_count, len(posts))
self.assertTrue(posts.filter(created_time__lte=datetime(2014, 1, 7)).count(), 1)
def test_page_fetch_posts_reduce_the_amount_error(self):
since = datetime(2015, 10, 17, 16, 21, 43, 402029).replace(tzinfo=timezone.utc)
page = PageFactory(graph_id=363440539014)
posts = page.fetch_posts(since=since)
self.assertEqual(posts.count(), 125)
posts = page.fetch_posts(since=since, all=True)
self.assertGreater(posts.count(), 950)
self.assertGreater(posts.aggregate(Min('created_time'))['created_time__min'], since)
posts = page.fetch_posts(since=since, limit=250)
self.assertEqual(posts.count(), 250) # TODO: 125!=250 Implement fetching requested amount of posts
def test_page_fetch_many_posts(self):
page = PageFactory(graph_id=PAGE1_ID)
self.assertEqual(Post.objects.count(), 0)
posts = page.fetch_posts(all=True,
since=datetime(
2014, 1, 1).replace(tzinfo=timezone.utc))
self.assertGreater(posts.count(), 250)
self.assertEqual(posts.count(), Post.objects.count())
self.assertEqual(
posts.filter(created_time__lte=datetime(2014, 1, 7).replace(
tzinfo=timezone.utc)).count(), 1)
def test_null_stats_test(self):
page = PageFactory(likes_count=None, talking_about_count=None)
facebook_api_post_fetch.send(sender=page.__class__,
instance=page,
created=True)
self.assertEqual(PageStatistic.objects.count(), 0)
def test_page_statistic_create(self):
self.assertEqual(PageStatistic.objects.count(), 0)
page = PageFactory(graph_id=PAGE_FANS_ID,
likes_count=10,
talking_about_count=20)
self.assertEqual(PageStatistic.objects.count(), 0)
facebook_api_post_fetch.send(sender=page.__class__,
instance=page,
created=True)
self.assertEqual(PageStatistic.objects.count(), 1)
stat = page.statistics.latest()
self.assertEqual(stat.likes_count, 10)
self.assertEqual(stat.talking_about_count, 20)
self.assertTrue(isinstance(stat.updated_at, datetime))
page = Page.remote.fetch(PAGE_FANS_ID)
self.assertEqual(PageStatistic.objects.count(), 2)
stat = page.statistics.latest()
self.assertTrue(stat.likes_count > 10)
self.assertTrue(stat.talking_about_count > 20)
self.assertTrue(isinstance(stat.updated_at, datetime))
def test_page_fetch_posts_reduce_the_amount_error(self):
since = datetime(2015, 10, 17, 16, 21, 43,
402029).replace(tzinfo=timezone.utc)
page = PageFactory(graph_id=363440539014)
posts = page.fetch_posts(since=since)
self.assertEqual(posts.count(), 125)
posts = page.fetch_posts(since=since, all=True)
self.assertGreater(posts.count(), 950)
self.assertGreater(
posts.aggregate(Min('created_time'))['created_time__min'], since)
posts = page.fetch_posts(since=since, limit=250)
self.assertEqual(
posts.count(),
250) # TODO: 125!=250 Implement fetching requested amount of posts
def test_fetch_page_posts(self):
page = PageFactory(graph_id=PAGE_ID)
self.assertEqual(Post.objects.count(), 0)
posts = page.fetch_posts(limit=100)
posts_count = Post.objects.count()
self.assertEqual(posts_count, 100)
self.assertEqual(posts_count, len(posts))
Post.objects.all().delete()
posts = page.fetch_posts(since=datetime.now() - timedelta(10))
posts_count1 = Post.objects.count()
self.assertTrue(posts_count1 < posts_count)
self.assertEqual(posts_count1, len(posts))
def test_fetch_page_albums(self):
page = PageFactory(graph_id=PAGE_ID)
self.assertEqual(Album.objects.count(), 0)
albums = page.fetch_albums(all=True)
albums_count = Album.objects.count()
self.assertGreater(albums.count(), 1500)
self.assertEqual(albums.count(), albums_count)
self.assertEqual(albums[0].author, page)
since = albums.order_by('created_time')[100].created_time
until = albums.order_by('-created_time')[100].created_time
self.assertLess(since, until)
# testing `since` parameter
albums_since = page.fetch_albums(all=True, since=since)
self.assertLess(albums_since.count(), albums.count())
# testing `until` parameter
albums_until = page.fetch_albums(all=True, since=since, until=until)
self.assertLess(albums_until.count(), albums_since.count())
def test_fetch_posts_of_page(self):
page = PageFactory.create(graph_id=PAGE_ID)
self.assertEqual(Post.objects.count(), 0)
posts = page.fetch_posts(limit=100)
posts_count = Post.objects.count()
self.assertEqual(posts_count, 100)
self.assertEqual(posts_count, len(posts))
Post.objects.all().delete()
posts = page.fetch_posts(since=datetime.now() - timedelta(10))
posts_count1 = Post.objects.count()
self.assertTrue(posts_count1 < posts_count)
self.assertEqual(posts_count1, len(posts))
def test_album_fetch_limit(self):
page = PageFactory(graph_id=PAGE_ID)
albums = Album.remote.fetch_page(page=page, limit=5)
self.assertEqual(albums.count(), 5)
def test_null_stats_test(self):
count = PageStatistic.objects.count()
p = PageFactory(graph_id=123456,
likes_count=None,
talking_about_count=None)
self.assertEqual(PageStatistic.objects.count(), count)
def setUp(self):
self.t = timezone.now()
self.p = PageFactory(graph_id=PAGE_FANS_ID,
likes_count=10,
talking_about_count=20)
def test_page_fetch_posts_with_strange_object_id(self):
instance = PageFactory(graph_id=252974534827155)
posts = instance.fetch_posts(since=datetime(2014,9,2))
self.assertEqual(posts.filter(graph_id='252974534827155_323648421093099')[0].object_id, None)
