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_add_post(self): """Can new Tags be created?""" self.assertEqual(Tag.objects.count(), 1) data = get_instance_data(TagFactory.build()) with self.login(self.test_user): self.post("admin:organizer_tag_add", data=data) self.assertEqual(Tag.objects.count(), 2)
def test_create_post(self): """Can we submit a form to create NewsLinks?""" newslink_num = NewsLink.objects.count() startup = StartupFactory() newslink_data = { **omit_keys( "id", get_instance_data(NewsLinkFactory.build()), ), "startup": startup.pk, } with perm_user(self, "organizer.add_newslink"): response = self.post( "newslink_create", startup_slug=startup.slug, data=newslink_data, ) self.assertEqual( NewsLink.objects.count(), newslink_num + 1, response.content.decode("utf8"), ) newslink = NewsLink.objects.get(slug=newslink_data["slug"]) self.assertEqual(startup.pk, newslink.startup.pk) self.assertRedirects(response, newslink.get_absolute_url())
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_create_post_malicious_form(self): """Can we maliciously change startups in NewsLink create?""" newslink_num = NewsLink.objects.count() startup1 = StartupFactory() startup2 = StartupFactory() newslink_data = { **omit_keys( "id", get_instance_data(NewsLinkFactory.build()), ), "startup": startup1.pk, } with perm_user(self, "organizer.add_newslink"): response = self.post( "newslink_create", startup_slug=startup2.slug, data=newslink_data, ) self.response_400() # ensure NewsLink _not_ created self.assertEqual( NewsLink.objects.count(), newslink_num, response.content.decode("utf8"), )
def test_create_post(self): """Can we submit a form to create Posts?""" with perm_user(self, "blog.add_post"): post_num = Post.objects.count() tag = TagFactory() startup = StartupFactory() post_data = { **omit_keys( "id", get_instance_data(PostFactory.build()), ), "tags": [tag.pk], "startups": [startup.pk], } self.assertFalse( Post.objects.filter( slug=post_data["slug"] ).exists() ) response = self.post( "post_create", data=post_data ) self.assertEqual( Post.objects.count(), post_num + 1, response.content.decode("utf8"), ) post = Post.objects.get(slug=post_data["slug"]) self.assertIn(tag, post.tags.all()) self.assertIn(startup, post.startups.all()) self.assertRedirects( response, post.get_absolute_url() )
def test_update_post(self): """Can we submit a form to update posts?""" with perm_user(self, "blog.change_post"): post = PostFactory( tags=TagFactory.create_batch(randint(1, 5)), startups=StartupFactory.create_batch( randint(1, 5) ), ) self.assertNotEqual(post.title, "django") post_data = omit_keys( "id", get_instance_data(post) ) response = self.post( "post_update", year=post.pub_date.year, month=post.pub_date.month, slug=post.slug, data=dict(post_data, title="django"), ) post.refresh_from_db() self.assertEqual( post.title, "django", response.content.decode("utf8"), ) self.assertRedirects( response, post.get_absolute_url() )
def test_update_post_malicious_form(self): """Can we maliciously change startups in NewsLink update?""" startup1 = StartupFactory() startup2 = StartupFactory() newslink = NewsLinkFactory(startup=startup1) new_title = "django" self.assertNotEqual(newslink.title, new_title) newslink_data = { **omit_keys("id", get_instance_data(newslink)), "title": new_title, "startup": startup2.pk, } with perm_user(self, "organizer.change_newslink"): response = self.post( "newslink_update", startup_slug=startup1.slug, newslink_slug=newslink.slug, data=newslink_data, ) self.response_400() # ensure NewsLink _not_ update newslink.refresh_from_db() self.assertNotEqual( newslink.title, new_title, response.content.decode("utf8"), )
def test_detail_update(self): """Can we update a Post via PUT?""" post = PostFactory(title="first") count = Post.objects.count() 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 ] self.put( "api-post-detail", year=post.pub_date.year, month=post.pub_date.month, slug=post.slug, data=dict( remove_m2m(get_instance_data(post)), title="second", tags=tag_urls, startups=startup_urls, ), ) self.response_200() self.assertEqual(count, Post.objects.count()) post.refresh_from_db() self.assertEqual("second", post.title) self.assertCountEqual(tag_list, post.tags.all()) self.assertCountEqual(startup_list, post.startups.all())
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_list_create_m2m(self): """Can new Posts be related with tags & startups?""" count = Post.objects.count() 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.build() self.post( "api-post-list", data=dict( remove_m2m(get_instance_data(post)), tags=tag_urls, startups=startup_urls, ), ) self.response_201() self.assertEqual(count + 1, Post.objects.count()) post = Post.objects.get(slug=post.slug, pub_date=post.pub_date) self.assertCountEqual(tag_list, post.tags.all()) self.assertCountEqual(startup_list, post.startups.all())
def test_slug_validation(self): """Do we error if slug is create?""" data = omit_keys( "slug", get_instance_data(StartupFactory.build()), ) sform = StartupForm({**data, "slug": "create"}) self.assertFalse(sform.is_valid())
def test_detail_update_404(self): """Do we generate 404 if startup not found?""" url = reverse("api-startup-detail", slug="nonexistent") self.put( url, data=get_instance_data(StartupFactory.build()), ) self.response_404()
def test_change_post(self): """Can existing Tags be modified?""" t2 = TagFactory() data = dict(name="a new tag name") self.assertNotEqual(get_instance_data(t2), data) with self.login(self.test_user): self.post( "admin:organizer_tag_change", data=data, object_id=t2.pk, ) self.response_302() t2.refresh_from_db() self.assertEqual( omit_keys("id", "slug", get_instance_data(t2)), data, ) self.assertEqual(Tag.objects.count(), 2)
def test_list_create(self): """Does Startup list view create new objects via POST?""" self.assertEqual(Startup.objects.count(), 0) self.post( "api-startup-list", data=get_instance_data(StartupFactory.build()), ) self.response_201() self.assertEqual(Startup.objects.count(), 1)
def test_list_create(self): """Can we create Posts via the POST to list view?""" count = Post.objects.count() self.post( "api-post-list", data=remove_m2m(get_instance_data(PostFactory.build())), ) self.response_201() self.assertEqual(count + 1, Post.objects.count())
def test_tag_create_post(self): """Can we submit a form to create tags?""" with perm_user(self, "organizer.add_tag"): self.assertEqual(Tag.objects.count(), 0) tag_data = omit_keys("id", get_instance_data(TagFactory.build())) response = self.post("tag_create", data=tag_data) self.assertEqual(Tag.objects.count(), 1, response.content) tag = Tag.objects.get(slug=slugify(tag_data["name"])) self.assertRedirects(response, tag.get_absolute_url())
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_tag_update_post(self): """Can we submit a form to update tags?""" tag = TagFactory() self.assertNotEqual(tag.name, "django") tag_data = omit_keys("id", "name", get_instance_data(tag)) with perm_user(self, "organizer.change_tag"): response = self.post( "tag_update", slug=tag.slug, data=dict(**tag_data, name="django"), ) tag.refresh_from_db() self.assertEqual(tag.name, "django", response.content) self.assertRedirects(response, tag.get_absolute_url())
def test_detail_update(self): """Can we update a Startup via PUT?""" startup = StartupFactory(name="first") url = reverse("api-startup-detail", slug=startup.slug) self.put( url, data={ **get_instance_data(startup), "name": "second", }, ) self.response_200() startup.refresh_from_db() self.assertEqual(startup.name, "second")
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_creation(self): """Can we save new posts based on input?""" tag = TagFactory() startup = StartupFactory() post = PostFactory.build() self.assertFalse(Post.objects.filter(slug=post.slug).exists()) bounded_form = PostForm( data={ **get_instance_data(post), "tags": [tag.pk], "startups": [startup.pk], }) self.assertTrue(bounded_form.is_valid(), bounded_form.errors) bounded_form.save() self.assertTrue(Post.objects.filter(slug=post.slug).exists())
def test_slug_validation(self): """Do we error if slug conflicts with URL?""" conflicts = ["delete", "update", "add_article"] startup = StartupFactory() for url_path in conflicts: with self.subTest(slug=url_path): nl_form = NewsLinkForm( dict( get_instance_data( NewsLinkFactory.build() ), slug=url_path, startup=startup.pk, ) ) self.assertFalse(nl_form.is_valid())
def test_update_post(self): """Can we submit a form to update startups?""" startup = StartupFactory(tags=TagFactory.create_batch(randint(1, 5))) self.assertNotEqual(startup.name, "django") startup_data = omit_keys("id", get_instance_data(startup)) with perm_user(self, "organizer.change_startup"): response = self.post( "startup_update", slug=startup.slug, data=dict(startup_data, name="django"), ) startup.refresh_from_db() self.assertEqual( startup.name, "django", response.content.decode("utf8"), ) self.assertRedirects(response, startup.get_absolute_url())
def test_update(self): """Can we update posts based on input?""" tag = TagFactory() startup = StartupFactory() post = PostFactory(tags=[tag], startups=[startup]) self.assertNotEqual(post.title, "django") pform = PostForm( instance=post, data=dict( get_instance_data(post), title="django", tags=[tag.pk], startups=[startup.pk], ), ) self.assertTrue(pform.is_valid(), pform.errors) pform.save() post.refresh_from_db() self.assertEqual(post.title, "django")
def test_update(self): """Can we updated newslinks based on input?""" startup = StartupFactory() newslink = NewsLinkFactory(startup=startup) self.assertNotEqual(newslink.title, "django") nl_form = NewsLinkForm( instance=newslink, data=dict( omit_keys( "name", get_instance_data(newslink) ), title="django", startups=[startup.pk], ), ) self.assertTrue(nl_form.is_valid(), nl_form.errors) nl_form.save() newslink.refresh_from_db() self.assertEqual(newslink.title, "django")
def test_update(self): """Can we updated startups based on input?""" tag = TagFactory() startup = StartupFactory(tags=[tag]) self.assertNotEqual(startup.name, "django") sform = StartupForm( instance=startup, data=dict( omit_keys( "name", get_instance_data(startup) ), name="django", tags=[tag.pk], ), ) self.assertTrue(sform.is_valid(), sform.errors) sform.save() startup.refresh_from_db() self.assertEqual(startup.name, "django")
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_update_post(self): """Can we submit a form to update newslinks?""" startup = StartupFactory() newslink = NewsLinkFactory(startup=startup) self.assertNotEqual(newslink.title, "django") newslink_data = omit_keys("id", get_instance_data(newslink)) with perm_user(self, "organizer.change_newslink"): response = self.post( "newslink_update", startup_slug=startup.slug, newslink_slug=newslink.slug, data=dict(newslink_data, title="django"), ) newslink.refresh_from_db() self.assertEqual( newslink.title, "django", response.content.decode("utf8"), ) self.assertRedirects(response, newslink.get_absolute_url())
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)