|
1 import datetime |
|
2 from django.test import TestCase |
|
3 from django import forms |
|
4 from models import Category, Writer, Book, DerivedBook, Post |
|
5 from mforms import (ProductForm, PriceForm, BookForm, DerivedBookForm, |
|
6 ExplicitPKForm, PostForm, DerivedPostForm, CustomWriterForm) |
|
7 |
|
8 |
|
9 class IncompleteCategoryFormWithFields(forms.ModelForm): |
|
10 """ |
|
11 A form that replaces the model's url field with a custom one. This should |
|
12 prevent the model field's validation from being called. |
|
13 """ |
|
14 url = forms.CharField(required=False) |
|
15 |
|
16 class Meta: |
|
17 fields = ('name', 'slug') |
|
18 model = Category |
|
19 |
|
20 class IncompleteCategoryFormWithExclude(forms.ModelForm): |
|
21 """ |
|
22 A form that replaces the model's url field with a custom one. This should |
|
23 prevent the model field's validation from being called. |
|
24 """ |
|
25 url = forms.CharField(required=False) |
|
26 |
|
27 class Meta: |
|
28 exclude = ['url'] |
|
29 model = Category |
|
30 |
|
31 |
|
32 class ValidationTest(TestCase): |
|
33 def test_validates_with_replaced_field_not_specified(self): |
|
34 form = IncompleteCategoryFormWithFields(data={'name': 'some name', 'slug': 'some-slug'}) |
|
35 assert form.is_valid() |
|
36 |
|
37 def test_validates_with_replaced_field_excluded(self): |
|
38 form = IncompleteCategoryFormWithExclude(data={'name': 'some name', 'slug': 'some-slug'}) |
|
39 assert form.is_valid() |
|
40 |
|
41 def test_notrequired_overrides_notblank(self): |
|
42 form = CustomWriterForm({}) |
|
43 assert form.is_valid() |
|
44 |
|
45 # unique/unique_together validation |
|
46 class UniqueTest(TestCase): |
|
47 def setUp(self): |
|
48 self.writer = Writer.objects.create(name='Mike Royko') |
|
49 |
|
50 def test_simple_unique(self): |
|
51 form = ProductForm({'slug': 'teddy-bear-blue'}) |
|
52 self.assertTrue(form.is_valid()) |
|
53 obj = form.save() |
|
54 form = ProductForm({'slug': 'teddy-bear-blue'}) |
|
55 self.assertEqual(len(form.errors), 1) |
|
56 self.assertEqual(form.errors['slug'], [u'Product with this Slug already exists.']) |
|
57 form = ProductForm({'slug': 'teddy-bear-blue'}, instance=obj) |
|
58 self.assertTrue(form.is_valid()) |
|
59 |
|
60 def test_unique_together(self): |
|
61 """ModelForm test of unique_together constraint""" |
|
62 form = PriceForm({'price': '6.00', 'quantity': '1'}) |
|
63 self.assertTrue(form.is_valid()) |
|
64 form.save() |
|
65 form = PriceForm({'price': '6.00', 'quantity': '1'}) |
|
66 self.assertFalse(form.is_valid()) |
|
67 self.assertEqual(len(form.errors), 1) |
|
68 self.assertEqual(form.errors['__all__'], [u'Price with this Price and Quantity already exists.']) |
|
69 |
|
70 def test_unique_null(self): |
|
71 title = 'I May Be Wrong But I Doubt It' |
|
72 form = BookForm({'title': title, 'author': self.writer.pk}) |
|
73 self.assertTrue(form.is_valid()) |
|
74 form.save() |
|
75 form = BookForm({'title': title, 'author': self.writer.pk}) |
|
76 self.assertFalse(form.is_valid()) |
|
77 self.assertEqual(len(form.errors), 1) |
|
78 self.assertEqual(form.errors['__all__'], [u'Book with this Title and Author already exists.']) |
|
79 form = BookForm({'title': title}) |
|
80 self.assertTrue(form.is_valid()) |
|
81 form.save() |
|
82 form = BookForm({'title': title}) |
|
83 self.assertTrue(form.is_valid()) |
|
84 |
|
85 def test_inherited_unique(self): |
|
86 title = 'Boss' |
|
87 Book.objects.create(title=title, author=self.writer, special_id=1) |
|
88 form = DerivedBookForm({'title': 'Other', 'author': self.writer.pk, 'special_id': u'1', 'isbn': '12345'}) |
|
89 self.assertFalse(form.is_valid()) |
|
90 self.assertEqual(len(form.errors), 1) |
|
91 self.assertEqual(form.errors['special_id'], [u'Book with this Special id already exists.']) |
|
92 |
|
93 def test_inherited_unique_together(self): |
|
94 title = 'Boss' |
|
95 form = BookForm({'title': title, 'author': self.writer.pk}) |
|
96 self.assertTrue(form.is_valid()) |
|
97 form.save() |
|
98 form = DerivedBookForm({'title': title, 'author': self.writer.pk, 'isbn': '12345'}) |
|
99 self.assertFalse(form.is_valid()) |
|
100 self.assertEqual(len(form.errors), 1) |
|
101 self.assertEqual(form.errors['__all__'], [u'Book with this Title and Author already exists.']) |
|
102 |
|
103 def test_abstract_inherited_unique(self): |
|
104 title = 'Boss' |
|
105 isbn = '12345' |
|
106 dbook = DerivedBook.objects.create(title=title, author=self.writer, isbn=isbn) |
|
107 form = DerivedBookForm({'title': 'Other', 'author': self.writer.pk, 'isbn': isbn}) |
|
108 self.assertFalse(form.is_valid()) |
|
109 self.assertEqual(len(form.errors), 1) |
|
110 self.assertEqual(form.errors['isbn'], [u'Derived book with this Isbn already exists.']) |
|
111 |
|
112 def test_abstract_inherited_unique_together(self): |
|
113 title = 'Boss' |
|
114 isbn = '12345' |
|
115 dbook = DerivedBook.objects.create(title=title, author=self.writer, isbn=isbn) |
|
116 form = DerivedBookForm({'title': 'Other', 'author': self.writer.pk, 'isbn': '9876', 'suffix1': u'0', 'suffix2': u'0'}) |
|
117 self.assertFalse(form.is_valid()) |
|
118 self.assertEqual(len(form.errors), 1) |
|
119 self.assertEqual(form.errors['__all__'], [u'Derived book with this Suffix1 and Suffix2 already exists.']) |
|
120 |
|
121 def test_explicitpk_unspecified(self): |
|
122 """Test for primary_key being in the form and failing validation.""" |
|
123 form = ExplicitPKForm({'key': u'', 'desc': u'' }) |
|
124 self.assertFalse(form.is_valid()) |
|
125 |
|
126 def test_explicitpk_unique(self): |
|
127 """Ensure keys and blank character strings are tested for uniqueness.""" |
|
128 form = ExplicitPKForm({'key': u'key1', 'desc': u''}) |
|
129 self.assertTrue(form.is_valid()) |
|
130 form.save() |
|
131 form = ExplicitPKForm({'key': u'key1', 'desc': u''}) |
|
132 self.assertFalse(form.is_valid()) |
|
133 self.assertEqual(len(form.errors), 3) |
|
134 self.assertEqual(form.errors['__all__'], [u'Explicit pk with this Key and Desc already exists.']) |
|
135 self.assertEqual(form.errors['desc'], [u'Explicit pk with this Desc already exists.']) |
|
136 self.assertEqual(form.errors['key'], [u'Explicit pk with this Key already exists.']) |
|
137 |
|
138 def test_unique_for_date(self): |
|
139 p = Post.objects.create(title="Django 1.0 is released", |
|
140 slug="Django 1.0", subtitle="Finally", posted=datetime.date(2008, 9, 3)) |
|
141 form = PostForm({'title': "Django 1.0 is released", 'posted': '2008-09-03'}) |
|
142 self.assertFalse(form.is_valid()) |
|
143 self.assertEqual(len(form.errors), 1) |
|
144 self.assertEqual(form.errors['title'], [u'Title must be unique for Posted date.']) |
|
145 form = PostForm({'title': "Work on Django 1.1 begins", 'posted': '2008-09-03'}) |
|
146 self.assertTrue(form.is_valid()) |
|
147 form = PostForm({'title': "Django 1.0 is released", 'posted': '2008-09-04'}) |
|
148 self.assertTrue(form.is_valid()) |
|
149 form = PostForm({'slug': "Django 1.0", 'posted': '2008-01-01'}) |
|
150 self.assertFalse(form.is_valid()) |
|
151 self.assertEqual(len(form.errors), 1) |
|
152 self.assertEqual(form.errors['slug'], [u'Slug must be unique for Posted year.']) |
|
153 form = PostForm({'subtitle': "Finally", 'posted': '2008-09-30'}) |
|
154 self.assertFalse(form.is_valid()) |
|
155 self.assertEqual(form.errors['subtitle'], [u'Subtitle must be unique for Posted month.']) |
|
156 form = PostForm({'subtitle': "Finally", "title": "Django 1.0 is released", |
|
157 "slug": "Django 1.0", 'posted': '2008-09-03'}, instance=p) |
|
158 self.assertTrue(form.is_valid()) |
|
159 form = PostForm({'title': "Django 1.0 is released"}) |
|
160 self.assertFalse(form.is_valid()) |
|
161 self.assertEqual(len(form.errors), 1) |
|
162 self.assertEqual(form.errors['posted'], [u'This field is required.']) |
|
163 |
|
164 def test_inherited_unique_for_date(self): |
|
165 p = Post.objects.create(title="Django 1.0 is released", |
|
166 slug="Django 1.0", subtitle="Finally", posted=datetime.date(2008, 9, 3)) |
|
167 form = DerivedPostForm({'title': "Django 1.0 is released", 'posted': '2008-09-03'}) |
|
168 self.assertFalse(form.is_valid()) |
|
169 self.assertEqual(len(form.errors), 1) |
|
170 self.assertEqual(form.errors['title'], [u'Title must be unique for Posted date.']) |
|
171 form = DerivedPostForm({'title': "Work on Django 1.1 begins", 'posted': '2008-09-03'}) |
|
172 self.assertTrue(form.is_valid()) |
|
173 form = DerivedPostForm({'title': "Django 1.0 is released", 'posted': '2008-09-04'}) |
|
174 self.assertTrue(form.is_valid()) |
|
175 form = DerivedPostForm({'slug': "Django 1.0", 'posted': '2008-01-01'}) |
|
176 self.assertFalse(form.is_valid()) |
|
177 self.assertEqual(len(form.errors), 1) |
|
178 self.assertEqual(form.errors['slug'], [u'Slug must be unique for Posted year.']) |
|
179 form = DerivedPostForm({'subtitle': "Finally", 'posted': '2008-09-30'}) |
|
180 self.assertFalse(form.is_valid()) |
|
181 self.assertEqual(form.errors['subtitle'], [u'Subtitle must be unique for Posted month.']) |
|
182 form = DerivedPostForm({'subtitle': "Finally", "title": "Django 1.0 is released", |
|
183 "slug": "Django 1.0", 'posted': '2008-09-03'}, instance=p) |
|
184 self.assertTrue(form.is_valid()) |
|
185 |