PageRenderTime 100ms CodeModel.GetById 10ms app.highlight 83ms RepoModel.GetById 2ms app.codeStats 1ms

/tests/regressiontests/forms/tests/input_formats.py

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