def test_with_post_counts_adds_post_count_to_queryset(self):
Tag.objects.create(name="docker")
PostFactory.create(tags=["python"])
qs = Tag.objects.with_post_counts()
values = qs.values("name", "post_count")
self.assertIn({"name": "python", "post_count": 1}, values)
self.assertIn({"name": "docker", "post_count": 0}, values)
def setUp(self):
posts = [
PostFactory.create(tags=["python", "docker"]),
PostFactory.create(tags=["python"]),
PostFactory.create(tags=["aws"]),
PostFactory.create(),
]
for post in posts:
post.publish()
def _create_posts(self):
"""
"""
count = randint(5, 10)
for i in range(count):
PostFactory.create(tags=(self.tags[i]
for i in range(randint(1, 10))))
print("Created {0} Posts".format(count))
def _create_posts(self):
"""
"""
count = randint(5, 10)
for i in range(count):
PostFactory.create(
tags=(self.tags[i] for i in range(randint(1, 10))))
print("Created {0} Posts".format(count))
def test_filter_not_draft_returns_in_published_date_order(self):
now = timezone.now()
yesterday = timezone.now() - timedelta(days=1)
now_post = PostFactory.create(published=now)
sleep(0.01) # make `created` different for each post
yesterday_post = PostFactory.create(published=yesterday)
posts = self.perform(draft=False)
by_published_desc = sorted(posts,
key=lambda post: post["published"],
reverse=True)
self.assertListEqual([p["id"] for p in by_published_desc],
[now_post.pk, yesterday_post.pk])
def handle(self, *args, **options):
tags = TagFactory.create_batch(5)
python_tag = TagFactory.create(word="python")
for _ in range(10):
post = PostFactory.create(tags=tags)
print("post", post)
for _ in range(5):
post = PostFactory.create(tags=[python_tag])
print("post", post)
for _ in range(2):
post = PostFactory.create(published_date=None,
tags=[python_tag] + tags)
def test_filter_draft_returns_drafts_only(self):
# Create a draft
PostFactory.create()
# And a published post
post = PostFactory.create()
post.publish()
posts = self.perform(draft=True)
self.assertEqual(len(posts), 1)
self.assertNotIn(post.pk, map(lambda post: post["id"], posts))
for post in posts:
self.assertTrue(post["is_draft"])
def test_filter_by_slug(self):
post = PostFactory.create(title="Hello, world!", slug="hello-world")
posts = self.perform(slug=post.slug)
self.assertEqual(len(posts), 1)
self.assertEqual(posts[0]["slug"], "hello-world")
posts = self.perform(slug="good-bye")
self.assertEqual(len(posts), 0)
def test_post(self):
test_post = PostFactory.create(author__first_name='Sebastian',
author__last_name='Fest',
title='My test title',
subtitle='A subtitle for the test post')
self.assertTrue(isinstance(test_post, Post))
self.assertEqual('My test title', test_post.__str__())
def test_filter_not_draft_returns_published_only(self):
post = PostFactory.create()
post.publish()
posts = self.perform(draft=False)
self.assertEqual(len(posts), 1)
post_data = posts[0]
self.assertEqual(post_data["id"], post.pk)
self.assertFalse(post_data["is_draft"])
def test_if_published_and_has_relative_then_relative_with_fields(self):
now = timezone.now()
post = PostFactory.create(published=now)
relative = self.get_relative(now)
response = self.perform(post)
expected = {"title": relative.title, "slug": relative.slug}
data = response.data[self.relative_field]
actual = {field: data.get(field) for field in expected}
self.assertEqual(actual, expected)
def test_can_update_image_url(self):
initial_url = "https://fakeimg.pl/128/"
new_url = "https://fakeimg.pl/256/"
post = PostFactory.create(image_url=initial_url)
url = f"/api/posts/{post.slug}/"
data = {"image_url": new_url}
response = self.client.patch(url, data=data, format="json")
self.assertEqual(response.status_code, 200)
post = Post.objects.get(pk=post.pk) # reload from DB
self.assertEqual(post.image_url, new_url)
def test_if_published_but_no_relative_then_relative_is_none(self):
post = PostFactory.create(published=timezone.now())
response = self.perform(post)
self.assertIsNone(response.data[self.relative_field])
def test_does_not_include_drafts(self):
PostFactory.create(tags=["angular"]) # not published
tags = self.perform()
self.assertNotIn("angular", map(lambda tag: tag["name"], tags))
def setUp(self):
self.post = PostFactory.create()
def get_relative(self, published):
later = published + timedelta(days=1)
return PostFactory.create(published=later)
def get_relative(self, published):
earlier = published - timedelta(days=1)
return PostFactory.create(published=earlier)
def test_if_not_published_then_relative_is_none(self):
response = self.perform(PostFactory.create())
self.assertIsNone(response.data[self.relative_field])
def _create_posts(self, **kwargs):
return [PostFactory.create() for n in range(randint(0, 10))]
def setUp(self):
self.post1 = PostFactory.create(title="Getting Started With Python")
self.post2 = PostFactory.create(description="Ruby: From Zero To Hero")
self.post3 = PostFactory.create(tags=["docker"])
def test_if_post_does_not_have_tag_then_not_included(self):
PostFactory.create(tags=["javascript", "webdev"])
posts = self.perform()
self.assertEqual(len(posts), 0)
def test_if_post_has_tag_then_included(self):
PostFactory.create(tags=["python", "webdev"])
posts = self.perform()
self.assertEqual(len(posts), 1)
