← Back to branch summary

~ubuntu-branches/debian/sid/python-django/sid

« back to all changes in this revision

Viewing changes to tests/regressiontests/forms/tests/input_formats.py

  • Committer: Package Import Robot
  • Author(s): Luke Faraone
  • Date: 2013-11-07 15:33:49 UTC
  • mfrom: (1.3.12)
  • Revision ID: package-import@ubuntu.com-20131107153349-e31sc149l2szs3jb
Tags: 1.6-1
http://bugs.debian.org/557474
http://bugs.debian.org/724637
http://bugs.debian.org/636511
http://bugs.debian.org/686333
http://bugs.debian.org/704203
* New upstream version. Closes: #557474, #724637.
* python-django now also suggests the installation of ipython,
  bpython, python-django-doc, and libgdal1.
  Closes: #636511, #686333, #704203
* Set package maintainer to Debian Python Modules Team.
* Bump standards version to 3.9.5, no changes needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/regressiontests/forms/tests/input_formats.py
1
 
from datetime import time, date, datetime
2
 
 
3
 
from django import forms
4
 
from django.test.utils import override_settings
5
 
from django.utils.translation import activate, deactivate
6
 
from django.test import SimpleTestCase
7
 
 
8
 
 
9
 
@override_settings(TIME_INPUT_FORMATS=["%I:%M:%S %p", "%I:%M %p"], USE_L10N=True)
10
 
class LocalizedTimeTests(SimpleTestCase):
11
 
    def setUp(self):
12
 
        # nl/formats.py has customized TIME_INPUT_FORMATS
13
 
        activate('nl')
14
 
 
15
 
    def tearDown(self):
16
 
        deactivate()
17
 
 
18
 
    def test_timeField(self):
19
 
        "TimeFields can parse dates in the default format"
20
 
        f = forms.TimeField()
21
 
        # Parse a time in an unaccepted format; get an error
22
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM')
23
 
 
24
 
        # Parse a time in a valid format, get a parsed result
25
 
        result = f.clean('13:30:05')
26
 
        self.assertEqual(result, time(13,30,5))
27
 
 
28
 
        # Check that the parsed result does a round trip
29
 
        text = f.widget._format_value(result)
30
 
        self.assertEqual(text, '13:30:05')
31
 
 
32
 
        # Parse a time in a valid, but non-default format, get a parsed result
33
 
        result = f.clean('13:30')
34
 
        self.assertEqual(result, time(13,30,0))
35
 
 
36
 
        # Check that the parsed result does a round trip to default format
37
 
        text = f.widget._format_value(result)
38
 
        self.assertEqual(text, "13:30:00")
39
 
 
40
 
    def test_localized_timeField(self):
41
 
        "Localized TimeFields act as unlocalized widgets"
42
 
        f = forms.TimeField(localize=True)
43
 
        # Parse a time in an unaccepted format; get an error
44
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM')
45
 
 
46
 
        # Parse a time in a valid format, get a parsed result
47
 
        result = f.clean('13:30:05')
48
 
        self.assertEqual(result, time(13,30,5))
49
 
 
50
 
        # Check that the parsed result does a round trip to the same format
51
 
        text = f.widget._format_value(result)
52
 
        self.assertEqual(text, '13:30:05')
53
 
 
54
 
        # Parse a time in a valid format, get a parsed result
55
 
        result = f.clean('13:30')
56
 
        self.assertEqual(result, time(13,30,0))
57
 
 
58
 
        # Check that the parsed result does a round trip to default format
59
 
        text = f.widget._format_value(result)
60
 
        self.assertEqual(text, "13:30:00")
61
 
 
62
 
    def test_timeField_with_inputformat(self):
63
 
        "TimeFields with manually specified input formats can accept those formats"
64
 
        f = forms.TimeField(input_formats=["%H.%M.%S", "%H.%M"])
65
 
        # Parse a time in an unaccepted format; get an error
66
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM')
67
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05')
68
 
 
69
 
        # Parse a time in a valid format, get a parsed result
70
 
        result = f.clean('13.30.05')
71
 
        self.assertEqual(result, time(13,30,5))
72
 
 
73
 
        # Check that the parsed result does a round trip to the same format
74
 
        text = f.widget._format_value(result)
75
 
        self.assertEqual(text, "13:30:05")
76
 
 
77
 
        # Parse a time in a valid format, get a parsed result
78
 
        result = f.clean('13.30')
79
 
        self.assertEqual(result, time(13,30,0))
80
 
 
81
 
        # Check that the parsed result does a round trip to default format
82
 
        text = f.widget._format_value(result)
83
 
        self.assertEqual(text, "13:30:00")
84
 
 
85
 
    def test_localized_timeField_with_inputformat(self):
86
 
        "Localized TimeFields with manually specified input formats can accept those formats"
87
 
        f = forms.TimeField(input_formats=["%H.%M.%S", "%H.%M"], localize=True)
88
 
        # Parse a time in an unaccepted format; get an error
89
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM')
90
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05')
91
 
 
92
 
        # Parse a time in a valid format, get a parsed result
93
 
        result = f.clean('13.30.05')
94
 
        self.assertEqual(result, time(13,30,5))
95
 
 
96
 
        # Check that the parsed result does a round trip to the same format
97
 
        text = f.widget._format_value(result)
98
 
        self.assertEqual(text, "13:30:05")
99
 
 
100
 
        # Parse a time in a valid format, get a parsed result
101
 
        result = f.clean('13.30')
102
 
        self.assertEqual(result, time(13,30,0))
103
 
 
104
 
        # Check that the parsed result does a round trip to default format
105
 
        text = f.widget._format_value(result)
106
 
        self.assertEqual(text, "13:30:00")
107
 
 
108
 
 
109
 
@override_settings(TIME_INPUT_FORMATS=["%I:%M:%S %p", "%I:%M %p"])
110
 
class CustomTimeInputFormatsTests(SimpleTestCase):
111
 
    def test_timeField(self):
112
 
        "TimeFields can parse dates in the default format"
113
 
        f = forms.TimeField()
114
 
        # Parse a time in an unaccepted format; get an error
115
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05')
116
 
 
117
 
        # Parse a time in a valid format, get a parsed result
118
 
        result = f.clean('1:30:05 PM')
119
 
        self.assertEqual(result, time(13,30,5))
120
 
 
121
 
        # Check that the parsed result does a round trip
122
 
        text = f.widget._format_value(result)
123
 
        self.assertEqual(text, '01:30:05 PM')
124
 
 
125
 
        # Parse a time in a valid, but non-default format, get a parsed result
126
 
        result = f.clean('1:30 PM')
127
 
        self.assertEqual(result, time(13,30,0))
128
 
 
129
 
        # Check that the parsed result does a round trip to default format
130
 
        text = f.widget._format_value(result)
131
 
        self.assertEqual(text, "01:30:00 PM")
132
 
 
133
 
    def test_localized_timeField(self):
134
 
        "Localized TimeFields act as unlocalized widgets"
135
 
        f = forms.TimeField(localize=True)
136
 
        # Parse a time in an unaccepted format; get an error
137
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05')
138
 
 
139
 
        # Parse a time in a valid format, get a parsed result
140
 
        result = f.clean('1:30:05 PM')
141
 
        self.assertEqual(result, time(13,30,5))
142
 
 
143
 
        # Check that the parsed result does a round trip to the same format
144
 
        text = f.widget._format_value(result)
145
 
        self.assertEqual(text, '01:30:05 PM')
146
 
 
147
 
        # Parse a time in a valid format, get a parsed result
148
 
        result = f.clean('01:30 PM')
149
 
        self.assertEqual(result, time(13,30,0))
150
 
 
151
 
        # Check that the parsed result does a round trip to default format
152
 
        text = f.widget._format_value(result)
153
 
        self.assertEqual(text, "01:30:00 PM")
154
 
 
155
 
    def test_timeField_with_inputformat(self):
156
 
        "TimeFields with manually specified input formats can accept those formats"
157
 
        f = forms.TimeField(input_formats=["%H.%M.%S", "%H.%M"])
158
 
        # Parse a time in an unaccepted format; get an error
159
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM')
160
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05')
161
 
 
162
 
        # Parse a time in a valid format, get a parsed result
163
 
        result = f.clean('13.30.05')
164
 
        self.assertEqual(result, time(13,30,5))
165
 
 
166
 
        # Check that the parsed result does a round trip to the same format
167
 
        text = f.widget._format_value(result)
168
 
        self.assertEqual(text, "01:30:05 PM")
169
 
 
170
 
        # Parse a time in a valid format, get a parsed result
171
 
        result = f.clean('13.30')
172
 
        self.assertEqual(result, time(13,30,0))
173
 
 
174
 
        # Check that the parsed result does a round trip to default format
175
 
        text = f.widget._format_value(result)
176
 
        self.assertEqual(text, "01:30:00 PM")
177
 
 
178
 
    def test_localized_timeField_with_inputformat(self):
179
 
        "Localized TimeFields with manually specified input formats can accept those formats"
180
 
        f = forms.TimeField(input_formats=["%H.%M.%S", "%H.%M"], localize=True)
181
 
        # Parse a time in an unaccepted format; get an error
182
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM')
183
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05')
184
 
 
185
 
        # Parse a time in a valid format, get a parsed result
186
 
        result = f.clean('13.30.05')
187
 
        self.assertEqual(result, time(13,30,5))
188
 
 
189
 
        # # Check that the parsed result does a round trip to the same format
190
 
        text = f.widget._format_value(result)
191
 
        self.assertEqual(text, "01:30:05 PM")
192
 
 
193
 
        # Parse a time in a valid format, get a parsed result
194
 
        result = f.clean('13.30')
195
 
        self.assertEqual(result, time(13,30,0))
196
 
 
197
 
        # Check that the parsed result does a round trip to default format
198
 
        text = f.widget._format_value(result)
199
 
        self.assertEqual(text, "01:30:00 PM")
200
 
 
201
 
 
202
 
class SimpleTimeFormatTests(SimpleTestCase):
203
 
    def test_timeField(self):
204
 
        "TimeFields can parse dates in the default format"
205
 
        f = forms.TimeField()
206
 
        # Parse a time in an unaccepted format; get an error
207
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM')
208
 
 
209
 
        # Parse a time in a valid format, get a parsed result
210
 
        result = f.clean('13:30:05')
211
 
        self.assertEqual(result, time(13,30,5))
212
 
 
213
 
        # Check that the parsed result does a round trip to the same format
214
 
        text = f.widget._format_value(result)
215
 
        self.assertEqual(text, "13:30:05")
216
 
 
217
 
        # Parse a time in a valid, but non-default format, get a parsed result
218
 
        result = f.clean('13:30')
219
 
        self.assertEqual(result, time(13,30,0))
220
 
 
221
 
        # Check that the parsed result does a round trip to default format
222
 
        text = f.widget._format_value(result)
223
 
        self.assertEqual(text, "13:30:00")
224
 
 
225
 
    def test_localized_timeField(self):
226
 
        "Localized TimeFields in a non-localized environment act as unlocalized widgets"
227
 
        f = forms.TimeField()
228
 
        # Parse a time in an unaccepted format; get an error
229
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM')
230
 
 
231
 
        # Parse a time in a valid format, get a parsed result
232
 
        result = f.clean('13:30:05')
233
 
        self.assertEqual(result, time(13,30,5))
234
 
 
235
 
        # Check that the parsed result does a round trip to the same format
236
 
        text = f.widget._format_value(result)
237
 
        self.assertEqual(text, "13:30:05")
238
 
 
239
 
        # Parse a time in a valid format, get a parsed result
240
 
        result = f.clean('13:30')
241
 
        self.assertEqual(result, time(13,30,0))
242
 
 
243
 
        # Check that the parsed result does a round trip to default format
244
 
        text = f.widget._format_value(result)
245
 
        self.assertEqual(text, "13:30:00")
246
 
 
247
 
    def test_timeField_with_inputformat(self):
248
 
        "TimeFields with manually specified input formats can accept those formats"
249
 
        f = forms.TimeField(input_formats=["%I:%M:%S %p", "%I:%M %p"])
250
 
        # Parse a time in an unaccepted format; get an error
251
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05')
252
 
 
253
 
        # Parse a time in a valid format, get a parsed result
254
 
        result = f.clean('1:30:05 PM')
255
 
        self.assertEqual(result, time(13,30,5))
256
 
 
257
 
        # Check that the parsed result does a round trip to the same format
258
 
        text = f.widget._format_value(result)
259
 
        self.assertEqual(text, "13:30:05")
260
 
 
261
 
        # Parse a time in a valid format, get a parsed result
262
 
        result = f.clean('1:30 PM')
263
 
        self.assertEqual(result, time(13,30,0))
264
 
 
265
 
        # Check that the parsed result does a round trip to default format
266
 
        text = f.widget._format_value(result)
267
 
        self.assertEqual(text, "13:30:00")
268
 
 
269
 
    def test_localized_timeField_with_inputformat(self):
270
 
        "Localized TimeFields with manually specified input formats can accept those formats"
271
 
        f = forms.TimeField(input_formats=["%I:%M:%S %p", "%I:%M %p"], localize=True)
272
 
        # Parse a time in an unaccepted format; get an error
273
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05')
274
 
 
275
 
        # Parse a time in a valid format, get a parsed result
276
 
        result = f.clean('1:30:05 PM')
277
 
        self.assertEqual(result, time(13,30,5))
278
 
 
279
 
        # Check that the parsed result does a round trip to the same format
280
 
        text = f.widget._format_value(result)
281
 
        self.assertEqual(text, "13:30:05")
282
 
 
283
 
        # Parse a time in a valid format, get a parsed result
284
 
        result = f.clean('1:30 PM')
285
 
        self.assertEqual(result, time(13,30,0))
286
 
 
287
 
        # Check that the parsed result does a round trip to default format
288
 
        text = f.widget._format_value(result)
289
 
        self.assertEqual(text, "13:30:00")
290
 
 
291
 
 
292
 
@override_settings(DATE_INPUT_FORMATS=["%d/%m/%Y", "%d-%m-%Y"], USE_L10N=True)
293
 
class LocalizedDateTests(SimpleTestCase):
294
 
    def setUp(self):
295
 
        activate('de')
296
 
 
297
 
    def tearDown(self):
298
 
        deactivate()
299
 
 
300
 
    def test_dateField(self):
301
 
        "DateFields can parse dates in the default format"
302
 
        f = forms.DateField()
303
 
        # Parse a date in an unaccepted format; get an error
304
 
        self.assertRaises(forms.ValidationError, f.clean, '21/12/2010')
305
 
 
306
 
        # ISO formats are accepted, even if not specified in formats.py
307
 
        self.assertEqual(f.clean('2010-12-21'), date(2010,12,21))
308
 
 
309
 
        # Parse a date in a valid format, get a parsed result
310
 
        result = f.clean('21.12.2010')
311
 
        self.assertEqual(result, date(2010,12,21))
312
 
 
313
 
        # Check that the parsed result does a round trip
314
 
        text = f.widget._format_value(result)
315
 
        self.assertEqual(text, '21.12.2010')
316
 
 
317
 
        # Parse a date in a valid, but non-default format, get a parsed result
318
 
        result = f.clean('21.12.10')
319
 
        self.assertEqual(result, date(2010,12,21))
320
 
 
321
 
        # Check that the parsed result does a round trip to default format
322
 
        text = f.widget._format_value(result)
323
 
        self.assertEqual(text, "21.12.2010")
324
 
 
325
 
    def test_localized_dateField(self):
326
 
        "Localized DateFields act as unlocalized widgets"
327
 
        f = forms.DateField(localize=True)
328
 
        # Parse a date in an unaccepted format; get an error
329
 
        self.assertRaises(forms.ValidationError, f.clean, '21/12/2010')
330
 
 
331
 
        # Parse a date in a valid format, get a parsed result
332
 
        result = f.clean('21.12.2010')
333
 
        self.assertEqual(result, date(2010,12,21))
334
 
 
335
 
        # Check that the parsed result does a round trip to the same format
336
 
        text = f.widget._format_value(result)
337
 
        self.assertEqual(text, '21.12.2010')
338
 
 
339
 
        # Parse a date in a valid format, get a parsed result
340
 
        result = f.clean('21.12.10')
341
 
        self.assertEqual(result, date(2010,12,21))
342
 
 
343
 
        # Check that the parsed result does a round trip to default format
344
 
        text = f.widget._format_value(result)
345
 
        self.assertEqual(text, "21.12.2010")
346
 
 
347
 
    def test_dateField_with_inputformat(self):
348
 
        "DateFields with manually specified input formats can accept those formats"
349
 
        f = forms.DateField(input_formats=["%m.%d.%Y", "%m-%d-%Y"])
350
 
        # Parse a date in an unaccepted format; get an error
351
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
352
 
        self.assertRaises(forms.ValidationError, f.clean, '21/12/2010')
353
 
        self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
354
 
 
355
 
        # Parse a date in a valid format, get a parsed result
356
 
        result = f.clean('12.21.2010')
357
 
        self.assertEqual(result, date(2010,12,21))
358
 
 
359
 
        # Check that the parsed result does a round trip to the same format
360
 
        text = f.widget._format_value(result)
361
 
        self.assertEqual(text, "21.12.2010")
362
 
 
363
 
        # Parse a date in a valid format, get a parsed result
364
 
        result = f.clean('12-21-2010')
365
 
        self.assertEqual(result, date(2010,12,21))
366
 
 
367
 
        # Check that the parsed result does a round trip to default format
368
 
        text = f.widget._format_value(result)
369
 
        self.assertEqual(text, "21.12.2010")
370
 
 
371
 
    def test_localized_dateField_with_inputformat(self):
372
 
        "Localized DateFields with manually specified input formats can accept those formats"
373
 
        f = forms.DateField(input_formats=["%m.%d.%Y", "%m-%d-%Y"], localize=True)
374
 
        # Parse a date in an unaccepted format; get an error
375
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
376
 
        self.assertRaises(forms.ValidationError, f.clean, '21/12/2010')
377
 
        self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
378
 
 
379
 
        # Parse a date in a valid format, get a parsed result
380
 
        result = f.clean('12.21.2010')
381
 
        self.assertEqual(result, date(2010,12,21))
382
 
 
383
 
        # # Check that the parsed result does a round trip to the same format
384
 
        text = f.widget._format_value(result)
385
 
        self.assertEqual(text, "21.12.2010")
386
 
 
387
 
        # Parse a date in a valid format, get a parsed result
388
 
        result = f.clean('12-21-2010')
389
 
        self.assertEqual(result, date(2010,12,21))
390
 
 
391
 
        # Check that the parsed result does a round trip to default format
392
 
        text = f.widget._format_value(result)
393
 
        self.assertEqual(text, "21.12.2010")
394
 
 
395
 
 
396
 
@override_settings(DATE_INPUT_FORMATS=["%d.%m.%Y", "%d-%m-%Y"])
397
 
class CustomDateInputFormatsTests(SimpleTestCase):
398
 
    def test_dateField(self):
399
 
        "DateFields can parse dates in the default format"
400
 
        f = forms.DateField()
401
 
        # Parse a date in an unaccepted format; get an error
402
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
403
 
 
404
 
        # Parse a date in a valid format, get a parsed result
405
 
        result = f.clean('21.12.2010')
406
 
        self.assertEqual(result, date(2010,12,21))
407
 
 
408
 
        # Check that the parsed result does a round trip
409
 
        text = f.widget._format_value(result)
410
 
        self.assertEqual(text, '21.12.2010')
411
 
 
412
 
        # Parse a date in a valid, but non-default format, get a parsed result
413
 
        result = f.clean('21-12-2010')
414
 
        self.assertEqual(result, date(2010,12,21))
415
 
 
416
 
        # Check that the parsed result does a round trip to default format
417
 
        text = f.widget._format_value(result)
418
 
        self.assertEqual(text, "21.12.2010")
419
 
 
420
 
    def test_localized_dateField(self):
421
 
        "Localized DateFields act as unlocalized widgets"
422
 
        f = forms.DateField(localize=True)
423
 
        # Parse a date in an unaccepted format; get an error
424
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
425
 
 
426
 
        # Parse a date in a valid format, get a parsed result
427
 
        result = f.clean('21.12.2010')
428
 
        self.assertEqual(result, date(2010,12,21))
429
 
 
430
 
        # Check that the parsed result does a round trip to the same format
431
 
        text = f.widget._format_value(result)
432
 
        self.assertEqual(text, '21.12.2010')
433
 
 
434
 
        # Parse a date in a valid format, get a parsed result
435
 
        result = f.clean('21-12-2010')
436
 
        self.assertEqual(result, date(2010,12,21))
437
 
 
438
 
        # Check that the parsed result does a round trip to default format
439
 
        text = f.widget._format_value(result)
440
 
        self.assertEqual(text, "21.12.2010")
441
 
 
442
 
    def test_dateField_with_inputformat(self):
443
 
        "DateFields with manually specified input formats can accept those formats"
444
 
        f = forms.DateField(input_formats=["%m.%d.%Y", "%m-%d-%Y"])
445
 
        # Parse a date in an unaccepted format; get an error
446
 
        self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
447
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
448
 
 
449
 
        # Parse a date in a valid format, get a parsed result
450
 
        result = f.clean('12.21.2010')
451
 
        self.assertEqual(result, date(2010,12,21))
452
 
 
453
 
        # Check that the parsed result does a round trip to the same format
454
 
        text = f.widget._format_value(result)
455
 
        self.assertEqual(text, "21.12.2010")
456
 
 
457
 
        # Parse a date in a valid format, get a parsed result
458
 
        result = f.clean('12-21-2010')
459
 
        self.assertEqual(result, date(2010,12,21))
460
 
 
461
 
        # Check that the parsed result does a round trip to default format
462
 
        text = f.widget._format_value(result)
463
 
        self.assertEqual(text, "21.12.2010")
464
 
 
465
 
    def test_localized_dateField_with_inputformat(self):
466
 
        "Localized DateFields with manually specified input formats can accept those formats"
467
 
        f = forms.DateField(input_formats=["%m.%d.%Y", "%m-%d-%Y"], localize=True)
468
 
        # Parse a date in an unaccepted format; get an error
469
 
        self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
470
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
471
 
 
472
 
        # Parse a date in a valid format, get a parsed result
473
 
        result = f.clean('12.21.2010')
474
 
        self.assertEqual(result, date(2010,12,21))
475
 
 
476
 
        # # Check that the parsed result does a round trip to the same format
477
 
        text = f.widget._format_value(result)
478
 
        self.assertEqual(text, "21.12.2010")
479
 
 
480
 
        # Parse a date in a valid format, get a parsed result
481
 
        result = f.clean('12-21-2010')
482
 
        self.assertEqual(result, date(2010,12,21))
483
 
 
484
 
        # Check that the parsed result does a round trip to default format
485
 
        text = f.widget._format_value(result)
486
 
        self.assertEqual(text, "21.12.2010")
487
 
 
488
 
class SimpleDateFormatTests(SimpleTestCase):
489
 
    def test_dateField(self):
490
 
        "DateFields can parse dates in the default format"
491
 
        f = forms.DateField()
492
 
        # Parse a date in an unaccepted format; get an error
493
 
        self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
494
 
 
495
 
        # Parse a date in a valid format, get a parsed result
496
 
        result = f.clean('2010-12-21')
497
 
        self.assertEqual(result, date(2010,12,21))
498
 
 
499
 
        # Check that the parsed result does a round trip to the same format
500
 
        text = f.widget._format_value(result)
501
 
        self.assertEqual(text, "2010-12-21")
502
 
 
503
 
        # Parse a date in a valid, but non-default format, get a parsed result
504
 
        result = f.clean('12/21/2010')
505
 
        self.assertEqual(result, date(2010,12,21))
506
 
 
507
 
        # Check that the parsed result does a round trip to default format
508
 
        text = f.widget._format_value(result)
509
 
        self.assertEqual(text, "2010-12-21")
510
 
 
511
 
    def test_localized_dateField(self):
512
 
        "Localized DateFields in a non-localized environment act as unlocalized widgets"
513
 
        f = forms.DateField()
514
 
        # Parse a date in an unaccepted format; get an error
515
 
        self.assertRaises(forms.ValidationError, f.clean, '21.12.2010')
516
 
 
517
 
        # Parse a date in a valid format, get a parsed result
518
 
        result = f.clean('2010-12-21')
519
 
        self.assertEqual(result, date(2010,12,21))
520
 
 
521
 
        # Check that the parsed result does a round trip to the same format
522
 
        text = f.widget._format_value(result)
523
 
        self.assertEqual(text, "2010-12-21")
524
 
 
525
 
        # Parse a date in a valid format, get a parsed result
526
 
        result = f.clean('12/21/2010')
527
 
        self.assertEqual(result, date(2010,12,21))
528
 
 
529
 
        # Check that the parsed result does a round trip to default format
530
 
        text = f.widget._format_value(result)
531
 
        self.assertEqual(text, "2010-12-21")
532
 
 
533
 
    def test_dateField_with_inputformat(self):
534
 
        "DateFields with manually specified input formats can accept those formats"
535
 
        f = forms.DateField(input_formats=["%d.%m.%Y", "%d-%m-%Y"])
536
 
        # Parse a date in an unaccepted format; get an error
537
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
538
 
 
539
 
        # Parse a date in a valid format, get a parsed result
540
 
        result = f.clean('21.12.2010')
541
 
        self.assertEqual(result, date(2010,12,21))
542
 
 
543
 
        # Check that the parsed result does a round trip to the same format
544
 
        text = f.widget._format_value(result)
545
 
        self.assertEqual(text, "2010-12-21")
546
 
 
547
 
        # Parse a date in a valid format, get a parsed result
548
 
        result = f.clean('21-12-2010')
549
 
        self.assertEqual(result, date(2010,12,21))
550
 
 
551
 
        # Check that the parsed result does a round trip to default format
552
 
        text = f.widget._format_value(result)
553
 
        self.assertEqual(text, "2010-12-21")
554
 
 
555
 
    def test_localized_dateField_with_inputformat(self):
556
 
        "Localized DateFields with manually specified input formats can accept those formats"
557
 
        f = forms.DateField(input_formats=["%d.%m.%Y", "%d-%m-%Y"], localize=True)
558
 
        # Parse a date in an unaccepted format; get an error
559
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21')
560
 
 
561
 
        # Parse a date in a valid format, get a parsed result
562
 
        result = f.clean('21.12.2010')
563
 
        self.assertEqual(result, date(2010,12,21))
564
 
 
565
 
        # Check that the parsed result does a round trip to the same format
566
 
        text = f.widget._format_value(result)
567
 
        self.assertEqual(text, "2010-12-21")
568
 
 
569
 
        # Parse a date in a valid format, get a parsed result
570
 
        result = f.clean('21-12-2010')
571
 
        self.assertEqual(result, date(2010,12,21))
572
 
 
573
 
        # Check that the parsed result does a round trip to default format
574
 
        text = f.widget._format_value(result)
575
 
        self.assertEqual(text, "2010-12-21")
576
 
 
577
 
 
578
 
@override_settings(DATETIME_INPUT_FORMATS=["%I:%M:%S %p %d/%m/%Y", "%I:%M %p %d-%m-%Y"], USE_L10N=True)
579
 
class LocalizedDateTimeTests(SimpleTestCase):
580
 
    def setUp(self):
581
 
        activate('de')
582
 
 
583
 
    def tearDown(self):
584
 
        deactivate()
585
 
 
586
 
    def test_dateTimeField(self):
587
 
        "DateTimeFields can parse dates in the default format"
588
 
        f = forms.DateTimeField()
589
 
        # Parse a date in an unaccepted format; get an error
590
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM 21/12/2010')
591
 
 
592
 
        # ISO formats are accepted, even if not specified in formats.py
593
 
        self.assertEqual(f.clean('2010-12-21 13:30:05'), datetime(2010,12,21,13,30,5))
594
 
 
595
 
        # Parse a date in a valid format, get a parsed result
596
 
        result = f.clean('21.12.2010 13:30:05')
597
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
598
 
 
599
 
        # Check that the parsed result does a round trip
600
 
        text = f.widget._format_value(result)
601
 
        self.assertEqual(text, '21.12.2010 13:30:05')
602
 
 
603
 
        # Parse a date in a valid, but non-default format, get a parsed result
604
 
        result = f.clean('21.12.2010 13:30')
605
 
        self.assertEqual(result, datetime(2010,12,21,13,30))
606
 
 
607
 
        # Check that the parsed result does a round trip to default format
608
 
        text = f.widget._format_value(result)
609
 
        self.assertEqual(text, "21.12.2010 13:30:00")
610
 
 
611
 
    def test_localized_dateTimeField(self):
612
 
        "Localized DateTimeFields act as unlocalized widgets"
613
 
        f = forms.DateTimeField(localize=True)
614
 
        # Parse a date in an unaccepted format; get an error
615
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM 21/12/2010')
616
 
 
617
 
        # Parse a date in a valid format, get a parsed result
618
 
        result = f.clean('21.12.2010 13:30:05')
619
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
620
 
 
621
 
        # Check that the parsed result does a round trip to the same format
622
 
        text = f.widget._format_value(result)
623
 
        self.assertEqual(text, '21.12.2010 13:30:05')
624
 
 
625
 
        # Parse a date in a valid format, get a parsed result
626
 
        result = f.clean('21.12.2010 13:30')
627
 
        self.assertEqual(result, datetime(2010,12,21,13,30))
628
 
 
629
 
        # Check that the parsed result does a round trip to default format
630
 
        text = f.widget._format_value(result)
631
 
        self.assertEqual(text, "21.12.2010 13:30:00")
632
 
 
633
 
    def test_dateTimeField_with_inputformat(self):
634
 
        "DateTimeFields with manually specified input formats can accept those formats"
635
 
        f = forms.DateTimeField(input_formats=["%H.%M.%S %m.%d.%Y", "%H.%M %m-%d-%Y"])
636
 
        # Parse a date in an unaccepted format; get an error
637
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05 13:30:05')
638
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM 21/12/2010')
639
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
640
 
 
641
 
        # Parse a date in a valid format, get a parsed result
642
 
        result = f.clean('13.30.05 12.21.2010')
643
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
644
 
 
645
 
        # Check that the parsed result does a round trip to the same format
646
 
        text = f.widget._format_value(result)
647
 
        self.assertEqual(text, "21.12.2010 13:30:05")
648
 
 
649
 
        # Parse a date in a valid format, get a parsed result
650
 
        result = f.clean('13.30 12-21-2010')
651
 
        self.assertEqual(result, datetime(2010,12,21,13,30))
652
 
 
653
 
        # Check that the parsed result does a round trip to default format
654
 
        text = f.widget._format_value(result)
655
 
        self.assertEqual(text, "21.12.2010 13:30:00")
656
 
 
657
 
    def test_localized_dateTimeField_with_inputformat(self):
658
 
        "Localized DateTimeFields with manually specified input formats can accept those formats"
659
 
        f = forms.DateTimeField(input_formats=["%H.%M.%S %m.%d.%Y", "%H.%M %m-%d-%Y"], localize=True)
660
 
        # Parse a date in an unaccepted format; get an error
661
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
662
 
        self.assertRaises(forms.ValidationError, f.clean, '1:30:05 PM 21/12/2010')
663
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
664
 
 
665
 
        # Parse a date in a valid format, get a parsed result
666
 
        result = f.clean('13.30.05 12.21.2010')
667
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
668
 
 
669
 
        # # Check that the parsed result does a round trip to the same format
670
 
        text = f.widget._format_value(result)
671
 
        self.assertEqual(text, "21.12.2010 13:30:05")
672
 
 
673
 
        # Parse a date in a valid format, get a parsed result
674
 
        result = f.clean('13.30 12-21-2010')
675
 
        self.assertEqual(result, datetime(2010,12,21,13,30))
676
 
 
677
 
        # Check that the parsed result does a round trip to default format
678
 
        text = f.widget._format_value(result)
679
 
        self.assertEqual(text, "21.12.2010 13:30:00")
680
 
 
681
 
 
682
 
@override_settings(DATETIME_INPUT_FORMATS=["%I:%M:%S %p %d/%m/%Y", "%I:%M %p %d-%m-%Y"])
683
 
class CustomDateTimeInputFormatsTests(SimpleTestCase):
684
 
    def test_dateTimeField(self):
685
 
        "DateTimeFields can parse dates in the default format"
686
 
        f = forms.DateTimeField()
687
 
        # Parse a date in an unaccepted format; get an error
688
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
689
 
 
690
 
        # Parse a date in a valid format, get a parsed result
691
 
        result = f.clean('1:30:05 PM 21/12/2010')
692
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
693
 
 
694
 
        # Check that the parsed result does a round trip
695
 
        text = f.widget._format_value(result)
696
 
        self.assertEqual(text, '01:30:05 PM 21/12/2010')
697
 
 
698
 
        # Parse a date in a valid, but non-default format, get a parsed result
699
 
        result = f.clean('1:30 PM 21-12-2010')
700
 
        self.assertEqual(result, datetime(2010,12,21,13,30))
701
 
 
702
 
        # Check that the parsed result does a round trip to default format
703
 
        text = f.widget._format_value(result)
704
 
        self.assertEqual(text, "01:30:00 PM 21/12/2010")
705
 
 
706
 
    def test_localized_dateTimeField(self):
707
 
        "Localized DateTimeFields act as unlocalized widgets"
708
 
        f = forms.DateTimeField(localize=True)
709
 
        # Parse a date in an unaccepted format; get an error
710
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
711
 
 
712
 
        # Parse a date in a valid format, get a parsed result
713
 
        result = f.clean('1:30:05 PM 21/12/2010')
714
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
715
 
 
716
 
        # Check that the parsed result does a round trip to the same format
717
 
        text = f.widget._format_value(result)
718
 
        self.assertEqual(text, '01:30:05 PM 21/12/2010')
719
 
 
720
 
        # Parse a date in a valid format, get a parsed result
721
 
        result = f.clean('1:30 PM 21-12-2010')
722
 
        self.assertEqual(result, datetime(2010,12,21,13,30))
723
 
 
724
 
        # Check that the parsed result does a round trip to default format
725
 
        text = f.widget._format_value(result)
726
 
        self.assertEqual(text, "01:30:00 PM 21/12/2010")
727
 
 
728
 
    def test_dateTimeField_with_inputformat(self):
729
 
        "DateTimeFields with manually specified input formats can accept those formats"
730
 
        f = forms.DateTimeField(input_formats=["%m.%d.%Y %H:%M:%S", "%m-%d-%Y %H:%M"])
731
 
        # Parse a date in an unaccepted format; get an error
732
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
733
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
734
 
 
735
 
        # Parse a date in a valid format, get a parsed result
736
 
        result = f.clean('12.21.2010 13:30:05')
737
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
738
 
 
739
 
        # Check that the parsed result does a round trip to the same format
740
 
        text = f.widget._format_value(result)
741
 
        self.assertEqual(text, "01:30:05 PM 21/12/2010")
742
 
 
743
 
        # Parse a date in a valid format, get a parsed result
744
 
        result = f.clean('12-21-2010 13:30')
745
 
        self.assertEqual(result, datetime(2010,12,21,13,30))
746
 
 
747
 
        # Check that the parsed result does a round trip to default format
748
 
        text = f.widget._format_value(result)
749
 
        self.assertEqual(text, "01:30:00 PM 21/12/2010")
750
 
 
751
 
    def test_localized_dateTimeField_with_inputformat(self):
752
 
        "Localized DateTimeFields with manually specified input formats can accept those formats"
753
 
        f = forms.DateTimeField(input_formats=["%m.%d.%Y %H:%M:%S", "%m-%d-%Y %H:%M"], localize=True)
754
 
        # Parse a date in an unaccepted format; get an error
755
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
756
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
757
 
 
758
 
        # Parse a date in a valid format, get a parsed result
759
 
        result = f.clean('12.21.2010 13:30:05')
760
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
761
 
 
762
 
        # # Check that the parsed result does a round trip to the same format
763
 
        text = f.widget._format_value(result)
764
 
        self.assertEqual(text, "01:30:05 PM 21/12/2010")
765
 
 
766
 
        # Parse a date in a valid format, get a parsed result
767
 
        result = f.clean('12-21-2010 13:30')
768
 
        self.assertEqual(result, datetime(2010,12,21,13,30))
769
 
 
770
 
        # Check that the parsed result does a round trip to default format
771
 
        text = f.widget._format_value(result)
772
 
        self.assertEqual(text, "01:30:00 PM 21/12/2010")
773
 
 
774
 
class SimpleDateTimeFormatTests(SimpleTestCase):
775
 
    def test_dateTimeField(self):
776
 
        "DateTimeFields can parse dates in the default format"
777
 
        f = forms.DateTimeField()
778
 
        # Parse a date in an unaccepted format; get an error
779
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
780
 
 
781
 
        # Parse a date in a valid format, get a parsed result
782
 
        result = f.clean('2010-12-21 13:30:05')
783
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
784
 
 
785
 
        # Check that the parsed result does a round trip to the same format
786
 
        text = f.widget._format_value(result)
787
 
        self.assertEqual(text, "2010-12-21 13:30:05")
788
 
 
789
 
        # Parse a date in a valid, but non-default format, get a parsed result
790
 
        result = f.clean('12/21/2010 13:30:05')
791
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
792
 
 
793
 
        # Check that the parsed result does a round trip to default format
794
 
        text = f.widget._format_value(result)
795
 
        self.assertEqual(text, "2010-12-21 13:30:05")
796
 
 
797
 
    def test_localized_dateTimeField(self):
798
 
        "Localized DateTimeFields in a non-localized environment act as unlocalized widgets"
799
 
        f = forms.DateTimeField()
800
 
        # Parse a date in an unaccepted format; get an error
801
 
        self.assertRaises(forms.ValidationError, f.clean, '13:30:05 21.12.2010')
802
 
 
803
 
        # Parse a date in a valid format, get a parsed result
804
 
        result = f.clean('2010-12-21 13:30:05')
805
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
806
 
 
807
 
        # Check that the parsed result does a round trip to the same format
808
 
        text = f.widget._format_value(result)
809
 
        self.assertEqual(text, "2010-12-21 13:30:05")
810
 
 
811
 
        # Parse a date in a valid format, get a parsed result
812
 
        result = f.clean('12/21/2010 13:30:05')
813
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
814
 
 
815
 
        # Check that the parsed result does a round trip to default format
816
 
        text = f.widget._format_value(result)
817
 
        self.assertEqual(text, "2010-12-21 13:30:05")
818
 
 
819
 
    def test_dateTimeField_with_inputformat(self):
820
 
        "DateTimeFields with manually specified input formats can accept those formats"
821
 
        f = forms.DateTimeField(input_formats=["%I:%M:%S %p %d.%m.%Y", "%I:%M %p %d-%m-%Y"])
822
 
        # Parse a date in an unaccepted format; get an error
823
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
824
 
 
825
 
        # Parse a date in a valid format, get a parsed result
826
 
        result = f.clean('1:30:05 PM 21.12.2010')
827
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
828
 
 
829
 
        # Check that the parsed result does a round trip to the same format
830
 
        text = f.widget._format_value(result)
831
 
        self.assertEqual(text, "2010-12-21 13:30:05")
832
 
 
833
 
        # Parse a date in a valid format, get a parsed result
834
 
        result = f.clean('1:30 PM 21-12-2010')
835
 
        self.assertEqual(result, datetime(2010,12,21,13,30))
836
 
 
837
 
        # Check that the parsed result does a round trip to default format
838
 
        text = f.widget._format_value(result)
839
 
        self.assertEqual(text, "2010-12-21 13:30:00")
840
 
 
841
 
    def test_localized_dateTimeField_with_inputformat(self):
842
 
        "Localized DateTimeFields with manually specified input formats can accept those formats"
843
 
        f = forms.DateTimeField(input_formats=["%I:%M:%S %p %d.%m.%Y", "%I:%M %p %d-%m-%Y"], localize=True)
844
 
        # Parse a date in an unaccepted format; get an error
845
 
        self.assertRaises(forms.ValidationError, f.clean, '2010-12-21 13:30:05')
846
 
 
847
 
        # Parse a date in a valid format, get a parsed result
848
 
        result = f.clean('1:30:05 PM 21.12.2010')
849
 
        self.assertEqual(result, datetime(2010,12,21,13,30,5))
850
 
 
851
 
        # Check that the parsed result does a round trip to the same format
852
 
        text = f.widget._format_value(result)
853
 
        self.assertEqual(text, "2010-12-21 13:30:05")
854
 
 
855
 
        # Parse a date in a valid format, get a parsed result
856
 
        result = f.clean('1:30 PM 21-12-2010')
857
 
        self.assertEqual(result, datetime(2010,12,21,13,30))
858
 
 
859
 
        # Check that the parsed result does a round trip to default format
860
 
        text = f.widget._format_value(result)
861
 
        self.assertEqual(text, "2010-12-21 13:30:00")