| import datetime |
| from django.test import TestCase |
| from django import forms |
| from models import Category, Writer, Book, DerivedBook, Post, FlexibleDatePost |
| from mforms import (ProductForm, PriceForm, BookForm, DerivedBookForm, |
| ExplicitPKForm, PostForm, DerivedPostForm, CustomWriterForm, |
| FlexDatePostForm) |
| |
| |
| class IncompleteCategoryFormWithFields(forms.ModelForm): |
| """ |
| A form that replaces the model's url field with a custom one. This should |
| prevent the model field's validation from being called. |
| """ |
| url = forms.CharField(required=False) |
| |
| class Meta: |
| fields = ('name', 'slug') |
| model = Category |
| |
| class IncompleteCategoryFormWithExclude(forms.ModelForm): |
| """ |
| A form that replaces the model's url field with a custom one. This should |
| prevent the model field's validation from being called. |
| """ |
| url = forms.CharField(required=False) |
| |
| class Meta: |
| exclude = ['url'] |
| model = Category |
| |
| |
| class ValidationTest(TestCase): |
| def test_validates_with_replaced_field_not_specified(self): |
| form = IncompleteCategoryFormWithFields(data={'name': 'some name', 'slug': 'some-slug'}) |
| assert form.is_valid() |
| |
| def test_validates_with_replaced_field_excluded(self): |
| form = IncompleteCategoryFormWithExclude(data={'name': 'some name', 'slug': 'some-slug'}) |
| assert form.is_valid() |
| |
| def test_notrequired_overrides_notblank(self): |
| form = CustomWriterForm({}) |
| assert form.is_valid() |
| |
| # unique/unique_together validation |
| class UniqueTest(TestCase): |
| def setUp(self): |
| self.writer = Writer.objects.create(name='Mike Royko') |
| |
| def test_simple_unique(self): |
| form = ProductForm({'slug': 'teddy-bear-blue'}) |
| self.assertTrue(form.is_valid()) |
| obj = form.save() |
| form = ProductForm({'slug': 'teddy-bear-blue'}) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['slug'], [u'Product with this Slug already exists.']) |
| form = ProductForm({'slug': 'teddy-bear-blue'}, instance=obj) |
| self.assertTrue(form.is_valid()) |
| |
| def test_unique_together(self): |
| """ModelForm test of unique_together constraint""" |
| form = PriceForm({'price': '6.00', 'quantity': '1'}) |
| self.assertTrue(form.is_valid()) |
| form.save() |
| form = PriceForm({'price': '6.00', 'quantity': '1'}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['__all__'], [u'Price with this Price and Quantity already exists.']) |
| |
| def test_unique_null(self): |
| title = 'I May Be Wrong But I Doubt It' |
| form = BookForm({'title': title, 'author': self.writer.pk}) |
| self.assertTrue(form.is_valid()) |
| form.save() |
| form = BookForm({'title': title, 'author': self.writer.pk}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['__all__'], [u'Book with this Title and Author already exists.']) |
| form = BookForm({'title': title}) |
| self.assertTrue(form.is_valid()) |
| form.save() |
| form = BookForm({'title': title}) |
| self.assertTrue(form.is_valid()) |
| |
| def test_inherited_unique(self): |
| title = 'Boss' |
| Book.objects.create(title=title, author=self.writer, special_id=1) |
| form = DerivedBookForm({'title': 'Other', 'author': self.writer.pk, 'special_id': u'1', 'isbn': '12345'}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['special_id'], [u'Book with this Special id already exists.']) |
| |
| def test_inherited_unique_together(self): |
| title = 'Boss' |
| form = BookForm({'title': title, 'author': self.writer.pk}) |
| self.assertTrue(form.is_valid()) |
| form.save() |
| form = DerivedBookForm({'title': title, 'author': self.writer.pk, 'isbn': '12345'}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['__all__'], [u'Book with this Title and Author already exists.']) |
| |
| def test_abstract_inherited_unique(self): |
| title = 'Boss' |
| isbn = '12345' |
| dbook = DerivedBook.objects.create(title=title, author=self.writer, isbn=isbn) |
| form = DerivedBookForm({'title': 'Other', 'author': self.writer.pk, 'isbn': isbn}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['isbn'], [u'Derived book with this Isbn already exists.']) |
| |
| def test_abstract_inherited_unique_together(self): |
| title = 'Boss' |
| isbn = '12345' |
| dbook = DerivedBook.objects.create(title=title, author=self.writer, isbn=isbn) |
| form = DerivedBookForm({'title': 'Other', 'author': self.writer.pk, 'isbn': '9876', 'suffix1': u'0', 'suffix2': u'0'}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['__all__'], [u'Derived book with this Suffix1 and Suffix2 already exists.']) |
| |
| def test_explicitpk_unspecified(self): |
| """Test for primary_key being in the form and failing validation.""" |
| form = ExplicitPKForm({'key': u'', 'desc': u'' }) |
| self.assertFalse(form.is_valid()) |
| |
| def test_explicitpk_unique(self): |
| """Ensure keys and blank character strings are tested for uniqueness.""" |
| form = ExplicitPKForm({'key': u'key1', 'desc': u''}) |
| self.assertTrue(form.is_valid()) |
| form.save() |
| form = ExplicitPKForm({'key': u'key1', 'desc': u''}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 3) |
| self.assertEqual(form.errors['__all__'], [u'Explicit pk with this Key and Desc already exists.']) |
| self.assertEqual(form.errors['desc'], [u'Explicit pk with this Desc already exists.']) |
| self.assertEqual(form.errors['key'], [u'Explicit pk with this Key already exists.']) |
| |
| def test_unique_for_date(self): |
| p = Post.objects.create(title="Django 1.0 is released", |
| slug="Django 1.0", subtitle="Finally", posted=datetime.date(2008, 9, 3)) |
| form = PostForm({'title': "Django 1.0 is released", 'posted': '2008-09-03'}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['title'], [u'Title must be unique for Posted date.']) |
| form = PostForm({'title': "Work on Django 1.1 begins", 'posted': '2008-09-03'}) |
| self.assertTrue(form.is_valid()) |
| form = PostForm({'title': "Django 1.0 is released", 'posted': '2008-09-04'}) |
| self.assertTrue(form.is_valid()) |
| form = PostForm({'slug': "Django 1.0", 'posted': '2008-01-01'}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['slug'], [u'Slug must be unique for Posted year.']) |
| form = PostForm({'subtitle': "Finally", 'posted': '2008-09-30'}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(form.errors['subtitle'], [u'Subtitle must be unique for Posted month.']) |
| form = PostForm({'subtitle': "Finally", "title": "Django 1.0 is released", |
| "slug": "Django 1.0", 'posted': '2008-09-03'}, instance=p) |
| self.assertTrue(form.is_valid()) |
| form = PostForm({'title': "Django 1.0 is released"}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['posted'], [u'This field is required.']) |
| |
| def test_inherited_unique_for_date(self): |
| p = Post.objects.create(title="Django 1.0 is released", |
| slug="Django 1.0", subtitle="Finally", posted=datetime.date(2008, 9, 3)) |
| form = DerivedPostForm({'title': "Django 1.0 is released", 'posted': '2008-09-03'}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['title'], [u'Title must be unique for Posted date.']) |
| form = DerivedPostForm({'title': "Work on Django 1.1 begins", 'posted': '2008-09-03'}) |
| self.assertTrue(form.is_valid()) |
| form = DerivedPostForm({'title': "Django 1.0 is released", 'posted': '2008-09-04'}) |
| self.assertTrue(form.is_valid()) |
| form = DerivedPostForm({'slug': "Django 1.0", 'posted': '2008-01-01'}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(len(form.errors), 1) |
| self.assertEqual(form.errors['slug'], [u'Slug must be unique for Posted year.']) |
| form = DerivedPostForm({'subtitle': "Finally", 'posted': '2008-09-30'}) |
| self.assertFalse(form.is_valid()) |
| self.assertEqual(form.errors['subtitle'], [u'Subtitle must be unique for Posted month.']) |
| form = DerivedPostForm({'subtitle': "Finally", "title": "Django 1.0 is released", |
| "slug": "Django 1.0", 'posted': '2008-09-03'}, instance=p) |
| self.assertTrue(form.is_valid()) |
| |
| def test_unique_for_date_with_nullable_date(self): |
| p = FlexibleDatePost.objects.create(title="Django 1.0 is released", |
| slug="Django 1.0", subtitle="Finally", posted=datetime.date(2008, 9, 3)) |
| |
| form = FlexDatePostForm({'title': "Django 1.0 is released"}) |
| self.assertTrue(form.is_valid()) |
| form = FlexDatePostForm({'slug': "Django 1.0"}) |
| self.assertTrue(form.is_valid()) |
| form = FlexDatePostForm({'subtitle': "Finally"}) |
| self.assertTrue(form.is_valid()) |
| form = FlexDatePostForm({'subtitle': "Finally", "title": "Django 1.0 is released", |
| "slug": "Django 1.0"}, instance=p) |
| self.assertTrue(form.is_valid()) |
