--- /dev/null
+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))
fnp / redakcja.git / blobdiff