apps/forms_builder/forms/tests.py

   1 from __future__ import unicode_literals
   2
   3 from django.conf import settings
   4 from django.contrib.auth.models import User, AnonymousUser
   5 from django.contrib.sites.models import Site
   6 from django.db import IntegrityError
   7 from django.http import HttpResponseRedirect
   8 from django.template import Context, RequestContext, Template
   9 from django.test import TestCase
  10
  11 from forms_builder.forms.fields import NAMES, FILE
  12 from forms_builder.forms.forms import FormForForm
  13 from forms_builder.forms.models import (Form, Field,
  14                                         STATUS_DRAFT, STATUS_PUBLISHED)
  15 from forms_builder.forms.settings import USE_SITES
  16 from forms_builder.forms.signals import form_invalid, form_valid
  17
  18
  19 class Tests(TestCase):
  20
  21     def setUp(self):
  22         self._site = Site.objects.get_current()
  23
  24     def test_form_fields(self):
  25         """
  26         Simple 200 status check against rendering and posting to forms with
  27         both optional and required fields.
  28         """
  29         for required in (True, False):
  30             form = Form.objects.create(title="Test", status=STATUS_PUBLISHED)
  31             if USE_SITES:
  32                 form.sites.add(self._site)
  33                 form.save()
  34             for (field, _) in NAMES:
  35                 form.fields.create(label=field, field_type=field,
  36                                    required=required, visible=True)
  37             response = self.client.get(form.get_absolute_url())
  38             self.assertEqual(response.status_code, 200)
  39             fields = form.fields.visible()
  40             data = dict([(f.slug, "test") for f in fields])
  41             response = self.client.post(form.get_absolute_url(), data=data)
  42             self.assertEqual(response.status_code, 200)
  43
  44     def test_draft_form(self):
  45         """
  46         Test that a form with draft status is only visible to staff.
  47         """
  48         settings.DEBUG = True # Don't depend on having a 404 template.
  49         username = "test"
  50         password = "test"
  51         User.objects.create_superuser(username, "", password)
  52         self.client.logout()
  53         draft = Form.objects.create(title="Draft", status=STATUS_DRAFT)
  54         if USE_SITES:
  55             draft.sites.add(self._site)
  56             draft.save()
  57         response = self.client.get(draft.get_absolute_url())
  58         self.assertEqual(response.status_code, 404)
  59         self.client.login(username=username, password=password)
  60         response = self.client.get(draft.get_absolute_url())
  61         self.assertEqual(response.status_code, 200)
  62
  63     def test_form_signals(self):
  64         """
  65         Test that each of the signals are sent.
  66         """
  67         events = ["valid", "invalid"]
  68         invalid = lambda **kwargs: events.remove("invalid")
  69         form_invalid.connect(invalid)
  70         valid = lambda **kwargs: events.remove("valid")
  71         form_valid.connect(valid)
  72         form = Form.objects.create(title="Signals", status=STATUS_PUBLISHED)
  73         if USE_SITES:
  74             form.sites.add(self._site)
  75             form.save()
  76         form.fields.create(label="field", field_type=NAMES[0][0],
  77                            required=True, visible=True)
  78         self.client.post(form.get_absolute_url(), data={})
  79         data = {form.fields.visible()[0].slug: "test"}
  80         self.client.post(form.get_absolute_url(), data=data)
  81         self.assertEqual(len(events), 0)
  82
  83     def test_tag(self):
  84         """
  85         Test that the different formats for the ``render_built_form``
  86         tag all work.
  87         """
  88         form = Form.objects.create(title="Tags", status=STATUS_PUBLISHED)
  89         request = type(str(""), (), {"META": {}, "user": AnonymousUser()})()
  90         context = RequestContext(request, {"form": form})
  91         template = "{%% load forms_builder_tags %%}{%% render_built_form %s %%}"
  92         formats = ("form", "form=form", "id=form.id", "slug=form.slug")
  93         for format in formats:
  94             t = Template(template % format).render(context)
  95             self.assertTrue(form.get_absolute_url(), t)
  96
  97     def test_optional_filefield(self):
  98         form = Form.objects.create(title="Test", status=STATUS_PUBLISHED)
  99         if USE_SITES:
 100             form.sites.add(self._site)
 101         form.save()
 102         form.fields.create(label="file field",
 103                 field_type=FILE,
 104                 required=False,
 105                 visible=True)
 106         fields = form.fields.visible()
 107         data = {'field_%s' % fields[0].id: ''}
 108         context = Context({})
 109         form_for_form = FormForForm(form, context, data=data)
 110         # Should not raise IntegrityError: forms_fieldentry.value
 111         # may not be NULL
 112         form_for_form.save()
 113
 114
 115     def test_field_validate_slug_names(self):
 116         form = Form.objects.create(title="Test")
 117         field = Field(form=form,
 118                 label="First name", field_type=NAMES[0][0])
 119         field.save()
 120         self.assertEqual(field.slug, 'first_name')
 121
 122         field_2 = Field(form=form,
 123                 label="First name", field_type=NAMES[0][0])
 124         try:
 125             field_2.save()
 126         except IntegrityError:
 127             self.fail("Slugs were not auto-unique")
 128
 129     def test_field_default_ordering(self):
 130         form = Form.objects.create(title="Test")
 131         form.fields.create(label="second field",
 132                 field_type=NAMES[0][0], order=2)
 133         f1 = form.fields.create(label="first field",
 134                 field_type=NAMES[0][0], order=1)
 135         self.assertEqual(form.fields.all()[0], f1)
 136
 137     def test_form_errors(self):
 138         from future.builtins import str
 139         form = Form.objects.create(title="Test")
 140         if USE_SITES:
 141             form.sites.add(self._site)
 142             form.save()
 143         form.fields.create(label="field", field_type=NAMES[0][0],
 144                            required=True, visible=True)
 145         response = self.client.post(form.get_absolute_url(), {"foo": "bar"})
 146         self.assertTrue("This field is required" in str(response.content))
 147
 148     def test_form_redirect(self):
 149         redirect_url = 'http://example.com/foo'
 150         form = Form.objects.create(title='Test', redirect_url=redirect_url)
 151         if USE_SITES:
 152             form.sites.add(self._site)
 153             form.save()
 154         form.fields.create(label='field', field_type=NAMES[3][0],
 155                            required=True, visible=True)
 156         form_absolute_url = form.get_absolute_url()
 157         response = self.client.post(form_absolute_url, {'field': '0'})
 158         self.assertEqual(response["location"], redirect_url)
 159         response = self.client.post(form_absolute_url, {'field': 'bar'})
 160         self.assertFalse(isinstance(response, HttpResponseRedirect))