X-Git-Url: https://git.mdrn.pl/redakcja.git/blobdiff_plain/82c38a77943cf91a084429bf10740edffbd0c195..2f9cb34a07fcd98effda2fa900e48c31813f14c8:/apps/forms_builder/forms/tests.py?ds=inline diff --git a/apps/forms_builder/forms/tests.py b/apps/forms_builder/forms/tests.py new file mode 100644 index 00000000..22b4086d --- /dev/null +++ b/apps/forms_builder/forms/tests.py @@ -0,0 +1,160 @@ +from __future__ import unicode_literals + +from django.conf import settings +from django.contrib.auth.models import User, AnonymousUser +from django.contrib.sites.models import Site +from django.db import IntegrityError +from django.http import HttpResponseRedirect +from django.template import Context, RequestContext, Template +from django.test import TestCase + +from forms_builder.forms.fields import NAMES, FILE +from forms_builder.forms.forms import FormForForm +from forms_builder.forms.models import (Form, Field, + STATUS_DRAFT, STATUS_PUBLISHED) +from forms_builder.forms.settings import USE_SITES +from forms_builder.forms.signals import form_invalid, form_valid + + +class Tests(TestCase): + + def setUp(self): + self._site = Site.objects.get_current() + + def test_form_fields(self): + """ + Simple 200 status check against rendering and posting to forms with + both optional and required fields. + """ + for required in (True, False): + form = Form.objects.create(title="Test", status=STATUS_PUBLISHED) + if USE_SITES: + form.sites.add(self._site) + form.save() + for (field, _) in NAMES: + form.fields.create(label=field, field_type=field, + required=required, visible=True) + response = self.client.get(form.get_absolute_url()) + self.assertEqual(response.status_code, 200) + fields = form.fields.visible() + data = dict([(f.slug, "test") for f in fields]) + response = self.client.post(form.get_absolute_url(), data=data) + self.assertEqual(response.status_code, 200) + + def test_draft_form(self): + """ + Test that a form with draft status is only visible to staff. + """ + settings.DEBUG = True # Don't depend on having a 404 template. + username = "test" + password = "test" + User.objects.create_superuser(username, "", password) + self.client.logout() + draft = Form.objects.create(title="Draft", status=STATUS_DRAFT) + if USE_SITES: + draft.sites.add(self._site) + draft.save() + response = self.client.get(draft.get_absolute_url()) + self.assertEqual(response.status_code, 404) + self.client.login(username=username, password=password) + response = self.client.get(draft.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + def test_form_signals(self): + """ + Test that each of the signals are sent. + """ + events = ["valid", "invalid"] + invalid = lambda **kwargs: events.remove("invalid") + form_invalid.connect(invalid) + valid = lambda **kwargs: events.remove("valid") + form_valid.connect(valid) + form = Form.objects.create(title="Signals", status=STATUS_PUBLISHED) + if USE_SITES: + form.sites.add(self._site) + form.save() + form.fields.create(label="field", field_type=NAMES[0][0], + required=True, visible=True) + self.client.post(form.get_absolute_url(), data={}) + data = {form.fields.visible()[0].slug: "test"} + self.client.post(form.get_absolute_url(), data=data) + self.assertEqual(len(events), 0) + + def test_tag(self): + """ + Test that the different formats for the ``render_built_form`` + tag all work. + """ + form = Form.objects.create(title="Tags", status=STATUS_PUBLISHED) + request = type(str(""), (), {"META": {}, "user": AnonymousUser()})() + context = RequestContext(request, {"form": form}) + template = "{%% load forms_builder_tags %%}{%% render_built_form %s %%}" + formats = ("form", "form=form", "id=form.id", "slug=form.slug") + for format in formats: + t = Template(template % format).render(context) + self.assertTrue(form.get_absolute_url(), t) + + def test_optional_filefield(self): + form = Form.objects.create(title="Test", status=STATUS_PUBLISHED) + if USE_SITES: + form.sites.add(self._site) + form.save() + form.fields.create(label="file field", + field_type=FILE, + required=False, + visible=True) + fields = form.fields.visible() + data = {'field_%s' % fields[0].id: ''} + context = Context({}) + form_for_form = FormForForm(form, context, data=data) + # Should not raise IntegrityError: forms_fieldentry.value + # may not be NULL + form_for_form.save() + + + def test_field_validate_slug_names(self): + form = Form.objects.create(title="Test") + field = Field(form=form, + label="First name", field_type=NAMES[0][0]) + field.save() + self.assertEqual(field.slug, 'first_name') + + field_2 = Field(form=form, + label="First name", field_type=NAMES[0][0]) + try: + field_2.save() + except IntegrityError: + self.fail("Slugs were not auto-unique") + + def test_field_default_ordering(self): + form = Form.objects.create(title="Test") + form.fields.create(label="second field", + field_type=NAMES[0][0], order=2) + f1 = form.fields.create(label="first field", + field_type=NAMES[0][0], order=1) + self.assertEqual(form.fields.all()[0], f1) + + def test_form_errors(self): + from future.builtins import str + form = Form.objects.create(title="Test") + if USE_SITES: + form.sites.add(self._site) + form.save() + form.fields.create(label="field", field_type=NAMES[0][0], + required=True, visible=True) + response = self.client.post(form.get_absolute_url(), {"foo": "bar"}) + self.assertTrue("This field is required" in str(response.content)) + + def test_form_redirect(self): + redirect_url = 'http://example.com/foo' + form = Form.objects.create(title='Test', redirect_url=redirect_url) + if USE_SITES: + form.sites.add(self._site) + form.save() + form.fields.create(label='field', field_type=NAMES[3][0], + required=True, visible=True) + form_absolute_url = form.get_absolute_url() + response = self.client.post(form_absolute_url, {'field': '0'}) + self.assertEqual(response["location"], redirect_url) + response = self.client.post(form_absolute_url, {'field': 'bar'}) + self.assertFalse(isinstance(response, HttpResponseRedirect))