def test_deserialization(self):
"""Can we deserialize data to a Tag model?"""
tag_data = get_instance_data(TagFactory.build())
s_tag = TagSerializer(data=tag_data, **context_kwarg("/api/v1/tag/"))
self.assertTrue(s_tag.is_valid(), s_tag.errors)
tag = s_tag.save()
self.assertTrue(Tag.objects.filter(pk=tag.pk).exists())
def test_deserialization(self):
"""Can we deserialize data to a Startup model?"""
startup_data = get_instance_data(StartupFactory.build())
tag_urls = [
reverse("api-tag-detail", slug=tag.slug)
for tag in TagFactory.build_batch(3) + TagFactory.create_batch(2)
]
data = dict(startup_data, tags=tag_urls)
s_startup = StartupSerializer(data=data,
**context_kwarg("/api/v1/startup/"))
self.assertTrue(s_startup.is_valid(), msg=s_startup.errors)
self.assertEqual(
Startup.objects.count(),
0,
"Unexpected initial condition",
)
self.assertEqual(
Tag.objects.count(),
2,
"Unexpected initial condition",
)
startup = s_startup.save()
self.assertEqual(
Startup.objects.count(),
1,
"Serialized Startup not saved",
)
self.assertCountEqual(
startup.tags.values_list("slug", flat=True),
[],
"Startup had tags associated with it",
)
self.assertEqual(Tag.objects.count(), 2, "Serialized Tags saved")
def test_deserialization(self):
"""Can we deserialize data to a Post model?"""
tag_list = TagFactory.create_batch(randint(1, 10))
tag_urls = [
reverse("api-tag-detail", slug=tag.slug) for tag in tag_list
]
startup_list = StartupFactory.create_batch(randint(1, 10))
startup_urls = [
reverse("api-startup-detail", slug=startup.slug)
for startup in startup_list
]
post_data = remove_m2m(get_instance_data(PostFactory.build()))
data = dict(
**post_data,
tags=tag_urls,
startups=startup_urls,
)
s_post = PostSerializer(
data=data,
**context_kwarg(reverse("api-post-list", full=True)),
)
self.assertTrue(s_post.is_valid(), msg=s_post.errors)
post = s_post.save()
self.assertCountEqual(tag_list, post.tags.all())
self.assertCountEqual(startup_list, post.startups.all())
def test_deserialization_partial_update_unknown_m2m(self):
"""Can we partially deserialize data to a Post model?"""
tag_urls = [
reverse("api-tag-detail", slug=tag.slug)
for tag in TagFactory.build_batch(randint(1, 10))
]
post = PostFactory()
s_post = PostSerializer(
instance=post,
data=dict(
# necessary due to bug in DRF
# https://github.com/encode/django-rest-framework/issues/6341
slug=post.slug,
pub_date=post.pub_date,
# remove above once DRF fixed
tags=tag_urls,
),
partial=True,
**context_kwarg(
reverse(
"api-post-detail",
year=post.pub_date.year,
month=post.pub_date.month,
slug=post.slug,
full=True,
)),
)
self.assertFalse(s_post.is_valid())
def test_detail(self):
"""Is there a detail view for a Startup object"""
startup = StartupFactory()
url = reverse("api-startup-detail", slug=startup.slug)
self.get_check_200(url)
self.assertCountEqual(
self.response_json,
StartupSerializer(startup, **context_kwarg(url)).data,
)
def test_detail(self):
"""Is there a detail view for a Tag object"""
tag = TagFactory()
url = reverse("api-tag-detail", slug=tag.slug)
self.get_check_200(url)
self.assertCountEqual(
self.response_json,
TagSerializer(tag, **context_kwarg(url)).data,
)
def test_serialization(self):
"""Does an existing Tag serialize correctly?"""
tag = TagFactory()
tag_url = reverse("api-tag-detail", slug=tag.slug, full=True)
s_tag = TagSerializer(tag, **context_kwarg(tag_url))
self.assertEqual(
omit_keys("url", s_tag.data),
omit_keys("id", get_instance_data(tag)),
)
self.assertEqual(s_tag.data["url"], tag_url)
def test_list(self):
"""Is there a list of Post objects"""
url_name = "api-post-list"
post_list = PostFactory.create_batch(10)
self.get_check_200(url_name)
self.assertCountEqual(
self.response_json,
PostSerializer(
post_list,
many=True,
**context_kwarg(reverse(url_name)),
).data,
)
def test_detail(self):
"""Is there a detail view for a NewsLink object"""
newslink = NewsLinkFactory()
url = reverse(
"api-newslink-detail",
startup_slug=newslink.startup.slug,
newslink_slug=newslink.slug,
)
self.get_check_200(url)
self.assertCountEqual(
self.response_json,
NewsLinkSerializer(newslink, **context_kwarg(url)).data,
)
def test_list(self):
"""Is there a list of NewsLink objects"""
url_name = "api-newslink-list"
newslink_list = NewsLinkFactory.create_batch(10)
self.get_check_200(url_name)
self.assertCountEqual(
self.response_json,
NewsLinkSerializer(
newslink_list,
many=True,
**context_kwarg(reverse(url_name)),
).data,
)
def test_list(self):
"""Is there a list of Startup objects"""
url_name = "api-startup-list"
startup_list = StartupFactory.create_batch(10)
self.get_check_200(url_name)
self.assertCountEqual(
self.response_json,
StartupSerializer(
startup_list,
many=True,
**context_kwarg(reverse(url_name)),
).data,
)
def test_detail(self):
"""Is there a detail view for a Post object"""
post = PostFactory()
url = reverse(
"api-post-detail",
year=post.pub_date.year,
month=post.pub_date.month,
slug=post.slug,
)
self.get_check_200(url)
self.assertCountEqual(
self.response_json,
PostSerializer(post, **context_kwarg(url)).data,
)
def test_deserialization(self):
"""Can we deserialize data to a NewsLink model?"""
startup_url = reverse(
"api-startup-detail",
slug=StartupFactory().slug,
full=True,
)
nl_data = omit_keys(
"startup",
get_instance_data(NewsLinkFactory.build()),
)
data = dict(**nl_data, startup=startup_url)
s_nl = NewsLinkSerializer(data=data,
**context_kwarg("/api/v1/newslink/"))
self.assertTrue(s_nl.is_valid(), msg=s_nl.errors)
def test_serialization(self):
"""Does an existing NewsLink serialize correctly?"""
nl = NewsLinkFactory()
nl_url = f"/api/v1/newslink/{nl.slug}"
s_nl = NewsLinkSerializer(nl, **context_kwarg(nl_url))
self.assertNotIn("id", s_nl.data)
self.assertIn("url", s_nl.data)
self.assertEqual(
omit_keys("url", "startup", s_nl.data),
omit_keys("id", "startup", get_instance_data(nl)),
)
self.assertEqual(
self.client.get(s_nl.data["url"]).status_code,
200,
)
self.assertEqual(
self.client.get(s_nl.data["startup"]).status_code,
200,
)
def test_serialization(self):
"""Does an existing Startup serialize correctly?"""
tag_list = TagFactory.create_batch(3)
startup = StartupFactory(tags=tag_list)
startup_url = reverse(
"api-startup-detail",
slug=startup.slug,
full=True,
)
s_startup = StartupSerializer(startup, **context_kwarg(startup_url))
self.assertEqual(
omit_keys("url", "tags", s_startup.data),
omit_keys("id", "tags", get_instance_data(startup)),
)
tag_urls = [
reverse("api-tag-detail", slug=tag.slug, full=True)
for tag in tag_list
]
self.assertCountEqual(s_startup.data["tags"], tag_urls)
self.assertEqual(s_startup.data["url"], startup_url)
def test_serialization(self):
"""Does an existing Posts serialize correctly?"""
tag_list = TagFactory.create_batch(3)
startup_list = StartupFactory.create_batch(2)
post = PostFactory(tags=tag_list, startups=startup_list)
post_ctxt = context_kwarg(f"/api/v1/startup/{post.slug}")
s_post = PostSerializer(post, **post_ctxt)
self.assertEqual(
remove_m2m("url", s_post.data),
remove_m2m("id", get_instance_data(post)),
)
self.assertEqual(
s_post.data["url"],
reverse(
"api-post-detail",
year=post.pub_date.year,
month=post.pub_date.month,
slug=post.slug,
full=True,
),
)
self.assertCountEqual(
s_post.data["tags"],
[
reverse(
"api-tag-detail",
slug=tag.slug,
full=True,
) for tag in tag_list
],
)
self.assertCountEqual(
s_post.data["startups"],
[
reverse(
"api-startup-detail",
slug=startup.slug,
full=True,
) for startup in startup_list
],
)
def test_deserialization_partial_update(self):
"""Can we partially deserialize data to a Post model?"""
tag_list = TagFactory.create_batch(randint(1, 10))
tag_urls = [
reverse("api-tag-detail", slug=tag.slug) for tag in tag_list
]
startup_list = StartupFactory.create_batch(randint(1, 10))
startup_urls = [
reverse("api-startup-detail", slug=startup.slug)
for startup in startup_list
]
post = PostFactory(title="first", tags=TagFactory.create_batch(3))
s_post = PostSerializer(
instance=post,
data=dict(
title="second",
# necessary due to bug in DRF
# https://github.com/encode/django-rest-framework/issues/6341
slug=post.slug,
pub_date=post.pub_date,
# remove above once DRF fixed
tags=tag_urls,
startups=startup_urls,
),
partial=True,
**context_kwarg(
reverse(
"api-post-detail",
year=post.pub_date.year,
month=post.pub_date.month,
slug=post.slug,
full=True,
)),
)
self.assertTrue(s_post.is_valid(), msg=s_post.errors)
post = s_post.save()
self.assertEqual("second", post.title)
self.assertCountEqual(tag_list, post.tags.all())
self.assertCountEqual(startup_list, post.startups.all())
def test_deserialization_update(self):
"""Can we deserialize to an existing Post model?"""
tag_list = TagFactory.create_batch(randint(1, 10))
tag_urls = [
reverse("api-tag-detail", slug=tag.slug) for tag in tag_list
]
startup_list = StartupFactory.create_batch(randint(1, 10))
startup_urls = [
reverse("api-startup-detail", slug=startup.slug)
for startup in startup_list
]
post = PostFactory(title="first", tags=TagFactory.create_batch(3))
post_data = remove_m2m(get_instance_data(post))
data = dict(
post_data,
title="second",
tags=tag_urls,
startups=startup_urls,
)
s_post = PostSerializer(
post,
data=data,
**context_kwarg(
reverse(
"api-post-detail",
year=post.pub_date.year,
month=post.pub_date.month,
slug=post.slug,
full=True,
)),
)
self.assertTrue(s_post.is_valid(), msg=s_post.errors)
post = s_post.save()
self.assertEqual("second", post.title)
self.assertCountEqual(tag_list, post.tags.all())
self.assertCountEqual(startup_list, post.startups.all())
def test_invalid_deserialization(self):
"""Does the serializer validate data?"""
s_startup = StartupSerializer(data={},
**context_kwarg("/api/v1/startup/"))
self.assertFalse(s_startup.is_valid())
def test_invalid_deserialization(self):
"""Does the serializer validate data?"""
s_tag = TagSerializer(data={}, **context_kwarg("/api/v1/tag/"))
self.assertFalse(s_tag.is_valid())
def test_invalid_deserialization(self):
"""Does the serializer validate data?"""
s_nl = NewsLinkSerializer(data={},
**context_kwarg("/api/v1/newslink/"))
self.assertFalse(s_nl.is_valid())