Debian Codegraph @

tests/test_formfields.py

raw
1 from unittest import mock
2
3 import django
4 import phonenumbers
5 from django import forms
6 from django.core.exceptions import ImproperlyConfigured
7 from django.test import SimpleTestCase, override_settings
8 from django.utils import translation
9 from django.utils.functional import lazy
10 from phonenumbers import COUNTRY_CODES_FOR_NON_GEO_REGIONS
11
12 from phonenumber_field.formfields import PhoneNumberField, SplitPhoneNumberField
13 from phonenumber_field.phonenumber import PhoneNumber
14 from phonenumber_field.validators import validate_phonenumber
15 from tests.models import (
16 NullablePhoneNumber,
17 PhoneNumberWithMaxLengthDefault,
18 PhoneNumberWithMaxLengthNullable,
19 )
20
21 ALGERIAN_PHONE_NUMBER = "+213799136332"
22
23
24 class PhoneNumberFormFieldTest(SimpleTestCase):
25 def test_error_message(self):
26 class PhoneNumberForm(forms.Form):
27 number = PhoneNumberField()
28
29 form = PhoneNumberForm({"number": "invalid"})
30 self.assertIs(form.is_valid(), False)
31 self.assertEqual(
32 form.errors, {"number": ["Enter a valid phone number (e.g. +12125552368)."]}
33 )
34
35 @override_settings(PHONENUMBER_DEFAULT_REGION="FR")
36 def test_error_message_uses_default_region(self):
37 class PhoneNumberForm(forms.Form):
38 number = PhoneNumberField()
39
40 form = PhoneNumberForm({"number": "invalid"})
41 self.assertIs(form.is_valid(), False)
42 self.assertEqual(
43 form.errors,
44 {
45 "number": [
46 "Enter a valid phone number (e.g. 01 23 45 67 89) "
47 "or a number with an international call prefix."
48 ]
49 },
50 )
51
52 def test_override_error_message(self):
53 class MyPhoneNumberField(PhoneNumberField):
54 default_error_messages = {"invalid": "MY INVALID MESSAGE!"}
55
56 class PhoneNumberForm(forms.Form):
57 number = MyPhoneNumberField()
58
59 form = PhoneNumberForm({"number": "invalid"})
60 self.assertIs(form.is_valid(), False)
61 self.assertEqual(form.errors, {"number": ["MY INVALID MESSAGE!"]})
62
63 def test_override_error_message_inline(self):
64 class PhoneNumberForm(forms.Form):
65 number = PhoneNumberField(
66 error_messages={"invalid": "MY INLINE INVALID MESSAGE!"}
67 )
68
69 form = PhoneNumberForm({"number": "invalid"})
70 self.assertIs(form.is_valid(), False)
71 self.assertEqual(form.errors, {"number": ["MY INLINE INVALID MESSAGE!"]})
72
73 def test_algerian_phone_number_in_form(self):
74 class PhoneNumberForm(forms.Form):
75 number = PhoneNumberField()
76
77 form = PhoneNumberForm({"number": ALGERIAN_PHONE_NUMBER})
78 self.assertTrue(form.is_valid())
79 self.assertEqual(ALGERIAN_PHONE_NUMBER, form.cleaned_data["number"])
80
81 def test_error_message_lazy(self):
82 def fail_gettext(msgid):
83 raise Exception("gettext was called unexpectedly.")
84
85 with mock.patch(
86 "phonenumber_field.formfields.pgettext_lazy",
87 side_effect=lazy(fail_gettext, str),
88 ):
89 PhoneNumberField()
90
91 def test_override_widget(self):
92 class MyPhoneNumberField(PhoneNumberField):
93 widget = forms.TextInput
94
95 class TestForm(forms.Form):
96 phone = MyPhoneNumberField(region="FR")
97
98 form = TestForm({"phone": "+33612345678"})
99 self.assertIs(form.is_valid(), True)
100 self.assertHTMLEqual(
101 form.as_p(),
102 """
103 <p>
104 <label for="id_phone">Phone:</label>
105 <input id="id_phone" name="phone" required type="tel" value="+33612345678">
106 </p>
107 """,
108 )
109
110 @override_settings(PHONENUMBER_DEFAULT_REGION="FR")
111 def test_widget_uses_default_region(self):
112 class TestForm(forms.Form):
113 phone = PhoneNumberField()
114
115 form = TestForm({"phone": "+33612345678"})
116 self.assertIs(form.is_valid(), True)
117 self.assertHTMLEqual(
118 form.as_p(),
119 """
120 <p>
121 <label for="id_phone">Phone:</label>
122 <input
123 id="id_phone"
124 name="phone"
125 required
126 type="tel"
127 value="06 12 34 56 78">
128 </p>
129 """,
130 )
131
132 def test_invalid_phone_number(self):
133 class PhoneNumberForm(forms.Form):
134 number = PhoneNumberField()
135
136 form = PhoneNumberForm({"number": "+11234567890"})
137 self.assertIs(form.is_valid(), False)
138 self.assertEqual(
139 form.errors, {"number": ["Enter a valid phone number (e.g. +12125552368)."]}
140 )
141
142 def test_validate_shortcode(self):
143 class ShortCodePhoneNumberField(PhoneNumberField):
144 default_validators = [validate_phonenumber]
145
146 class TestForm(forms.Form):
147 phone = ShortCodePhoneNumberField(region="FR")
148
149 form = TestForm({"phone": "1010"})
150 self.assertIs(form.is_valid(), True)
151
152
153 class SplitPhoneNumberFormFieldTest(SimpleTestCase):
154 def example_number(self, region_code: str) -> PhoneNumber:
155 number = phonenumbers.example_number(region_code)
156 e164 = phonenumbers.format_number(number, phonenumbers.PhoneNumberFormat.E164)
157 return PhoneNumber.from_string(e164, region=region_code)
158
159 def test_initial_empty(self):
160 class TestForm(forms.Form):
161 phone = SplitPhoneNumberField(region="CN")
162
163 rendered = str(TestForm())
164 self.assertIn('<option value="">---------</option>', rendered)
165 self.assertIn('<option value="CN" selected>China +86</option>', rendered)
166
167 @override_settings(PHONENUMBER_DEFAULT_REGION="CN")
168 def test_uses_default_region_as_initial(self):
169 class TestForm(forms.Form):
170 phone = SplitPhoneNumberField()
171
172 rendered = str(TestForm())
173 self.assertIn('<option value="">---------</option>', rendered)
174 self.assertIn('<option value="CN" selected>China +86</option>', rendered)
175
176 def test_no_initial(self):
177 class TestForm(forms.Form):
178 phone = SplitPhoneNumberField()
179
180 rendered = str(TestForm())
181 self.assertIn('<option value="" selected>---------</option>', rendered)
182 self.assertIn('<option value="CN">China +86</option>', rendered)
183 for prefix in COUNTRY_CODES_FOR_NON_GEO_REGIONS:
184 self.assertNotIn(f"+{prefix}", rendered)
185
186 def test_initial(self):
187 class TestForm(forms.Form):
188 phone = SplitPhoneNumberField()
189
190 rendered = str(
191 TestForm(initial={"phone": PhoneNumber.from_string("+33612345678")})
192 )
193 self.assertIn('<option value="">---------</option>', rendered)
194 self.assertIn('<option value="FR" selected>France +33</option>', rendered)
195 self.assertIn(
196 '<input type="tel" name="phone_1" value="612345678" '
197 'required id="id_phone_1">',
198 rendered,
199 )
200
201 def test_invalid_phone_number(self):
202 class TestForm(forms.Form):
203 phone = SplitPhoneNumberField()
204
205 form = TestForm({"phone_0": "US", "phone_1": "1234567890"})
206 self.assertIs(form.is_valid(), False)
207 self.assertEqual(
208 form.errors,
209 {"phone": ["Enter a valid phone number (e.g. (201) 555-0123)."]},
210 )
211
212 @override_settings(USE_I18N=True)
213 def test_after_translation_deactivate_all(self):
214 class TestForm(forms.Form):
215 phone = SplitPhoneNumberField()
216
217 translation.deactivate_all()
218 rendered = str(TestForm())
219 self.assertIn(
220 '<select name="phone_0" required id="id_phone_0">'
221 '<option value="" selected>---------</option>',
222 rendered,
223 )
224
225 def test_example_numbers(self):
226 example_numbers = (
227 self.example_number("US"),
228 self.example_number("CA"),
229 self.example_number("GB"),
230 self.example_number("GG"),
231 self.example_number("PL"),
232 self.example_number("IT"),
233 )
234 tests = [
235 (
236 {
237 "phone_0": phonenumbers.region_code_for_number(number),
238 "phone_1": phonenumbers.national_significant_number(number),
239 },
240 number,
241 )
242 for number in example_numbers
243 ]
244
245 class TestForm(forms.Form):
246 phone = SplitPhoneNumberField()
247
248 for data, expected in tests:
249 with self.subTest(data):
250 form = TestForm(data=data)
251 self.assertIs(form.is_valid(), True)
252 self.assertEqual(form.cleaned_data, {"phone": expected})
253
254 def test_empty_region(self):
255 class TestForm(forms.Form):
256 phone = SplitPhoneNumberField()
257
258 invalid_national_number = "8876543210"
259 form = TestForm(data={"phone_0": "", "phone_1": invalid_national_number})
260 self.assertFalse(form.is_valid())
261 rendered_form = form.as_ul()
262 if django.VERSION >= (5, 2):
263 self.assertInHTML(
264 """<ul class="errorlist" id="id_phone_error">
265 <li>This field is required.</li>
266 </ul>
267 """,
268 rendered_form,
269 )
270 else:
271 self.assertInHTML(
272 '<ul class="errorlist"><li>This field is required.</li></ul>',
273 rendered_form,
274 )
275 aria_invalid = "" if django.VERSION[0] < 5 else 'aria-invalid="true" '
276 # Keeps national number input.
277 self.assertInHTML(
278 '<input type="tel" name="phone_1" '
279 f'value="{invalid_national_number}" {aria_invalid} required '
280 'id="id_phone_1">',
281 rendered_form,
282 count=1,
283 )
284 self.assertInHTML(
285 '<option value="" selected>---------</option>',
286 rendered_form,
287 count=1,
288 )
289
290 def test_empty_national_number(self):
291 class TestForm(forms.Form):
292 phone = SplitPhoneNumberField()
293
294 form = TestForm(data={"phone_0": "CA", "phone_1": ""})
295 self.assertFalse(form.is_valid())
296 rendered_form = form.as_ul()
297 if django.VERSION >= (5, 2):
298 self.assertInHTML(
299 """
300 <ul class="errorlist" id="id_phone_error">
301 <li>This field is required.</li>
302 </ul>
303 """,
304 rendered_form,
305 )
306 else:
307 self.assertInHTML(
308 '<ul class="errorlist"><li>This field is required.</li></ul>',
309 rendered_form,
310 )
311 aria_invalid = "" if django.VERSION[0] < 5 else 'aria-invalid="true" '
312 self.assertInHTML(
313 f'<input type="tel" name="phone_1" {aria_invalid} '
314 'required id="id_phone_1">',
315 rendered_form,
316 count=1,
317 )
318
319 def test_not_required_empty_data(self):
320 class TestForm(forms.Form):
321 phone = SplitPhoneNumberField(required=False)
322
323 form = TestForm(data={"phone_0": "", "phone_1": ""})
324 self.assertIs(form.is_valid(), True)
325 self.assertEqual(form.cleaned_data["phone"], "")
326
327 def test_no_region(self):
328 class TestForm(forms.Form):
329 phone = SplitPhoneNumberField()
330
331 form = TestForm(data={"phone_1": "654321"})
332 self.assertFalse(form.is_valid())
333 rendered_form = form.as_ul()
334 if django.VERSION >= (5, 2):
335 self.assertInHTML(
336 """
337 <ul class="errorlist" id="id_phone_error">
338 <li>This field is required.</li>
339 </ul>
340 """,
341 rendered_form,
342 )
343 else:
344 self.assertInHTML(
345 '<ul class="errorlist"><li>This field is required.</li></ul>',
346 rendered_form,
347 )
348 aria_invalid = "" if django.VERSION[0] < 5 else 'aria-invalid="true" '
349 self.assertInHTML(
350 f'<input type="tel" name="phone_1" value="654321" {aria_invalid} '
351 'required id="id_phone_1">',
352 rendered_form,
353 count=1,
354 )
355 self.assertInHTML(
356 '<option value="" selected>---------</option>',
357 rendered_form,
358 count=1,
359 )
360
361 def test_no_national_number(self):
362 class TestForm(forms.Form):
363 phone = SplitPhoneNumberField()
364
365 form = TestForm(data={"phone_0": "CA"})
366 self.assertFalse(form.is_valid())
367 rendered_form = form.as_ul()
368 if django.VERSION >= (5, 2):
369 self.assertInHTML(
370 """
371 <ul class="errorlist" id="id_phone_error">
372 <li>This field is required.</li>
373 </ul>
374 """,
375 rendered_form,
376 count=1,
377 )
378 else:
379 self.assertInHTML(
380 '<ul class="errorlist"><li>This field is required.</li></ul>',
381 rendered_form,
382 count=1,
383 )
384 aria_invalid = "" if django.VERSION[0] < 5 else 'aria-invalid="true" '
385 self.assertInHTML(
386 f'<input type="tel" name="phone_1" {aria_invalid} '
387 'required id="id_phone_1">',
388 rendered_form,
389 count=1,
390 )
391
392 def test_not_required_no_data(self):
393 class TestForm(forms.Form):
394 phone = SplitPhoneNumberField(required=False)
395
396 form = TestForm(data={})
397 self.assertIs(form.is_valid(), True)
398 self.assertEqual(form.cleaned_data["phone"], "")
399
400 def test_not_required_empty_value(self):
401 class TestForm(forms.Form):
402 phone = SplitPhoneNumberField(required=False)
403 phone_none = SplitPhoneNumberField(required=False, empty_value=None)
404
405 form = TestForm(data={})
406 self.assertIs(form.is_valid(), True)
407 self.assertEqual(form.cleaned_data["phone"], "")
408 self.assertIsNone(form.cleaned_data["phone_none"])
409
410 def test_keeps_region_with_invalid_national_number(self):
411 class TestForm(forms.Form):
412 phone = SplitPhoneNumberField()
413
414 form = TestForm(data={"phone_0": "CA", "phone_1": "0000"})
415 self.assertFalse(form.is_valid())
416 rendered_form = str(form)
417 if django.VERSION >= (5, 2):
418 self.assertInHTML(
419 """
420 <ul class="errorlist" id="id_phone_error">
421 <li>Enter a valid phone number (e.g. (506) 234-5678).</li>
422 </ul>
423 """,
424 rendered_form,
425 count=1,
426 )
427 else:
428 self.assertInHTML(
429 '<ul class="errorlist">'
430 "<li>Enter a valid phone number (e.g. (506) 234-5678).</li></ul>",
431 rendered_form,
432 )
433 aria_invalid = "" if django.VERSION[0] < 5 else 'aria-invalid="true" '
434 self.assertInHTML(
435 f'<input type="tel" name="phone_1" value="0000" {aria_invalid} '
436 'required id="id_phone_1">',
437 rendered_form,
438 count=1,
439 )
440 self.assertInHTML(
441 '<option value="CA" selected>Canada +1</option>',
442 rendered_form,
443 count=1,
444 )
445
446 def test_maxlength_not_in_select(self):
447 # Regression test for #490
448 class TestForm(forms.Form):
449 phone = SplitPhoneNumberField()
450
451 rendered = str(TestForm())
452 self.assertIn('<select name="phone_0" required id="id_phone_0">', rendered)
453
454 def test_custom_attrs(self):
455 class SplitPhoneNumberFieldWithClass(SplitPhoneNumberField):
456 def prefix_field(self):
457 prefix_field = super().prefix_field()
458 prefix_field.widget.attrs["class"] = "prefix-input"
459 return prefix_field
460
461 def number_field(self):
462 number_field = super().number_field()
463 number_field.widget.attrs["class"] = "number-input"
464 return number_field
465
466 class TestForm(forms.Form):
467 phone = SplitPhoneNumberFieldWithClass()
468
469 rendered = str(TestForm())
470 self.assertIn(
471 '<select name="phone_0" class="prefix-input" required id="id_phone_0">',
472 rendered,
473 )
474 self.assertInHTML(
475 '<input type="tel" name="phone_1" class="number-input"'
476 'required id="id_phone_1">',
477 rendered,
478 count=1,
479 )
480
481 def test_custom_choices(self):
482 class SplitPhoneNumberFieldWithCountries(SplitPhoneNumberField):
483 def prefix_field(self):
484 return forms.ChoiceField(choices=[("FR", "France"), ("BE", "Belgium")])
485
486 class TestForm(forms.Form):
487 phone = SplitPhoneNumberFieldWithCountries()
488
489 form = TestForm()
490 if django.VERSION[0] < 4:
491 self.assertHTMLEqual(
492 str(form.as_p()),
493 """
494 <p>
495 <label for="id_phone_0">Phone:</label>
496 <select id="id_phone_0" name="phone_0" required>
497 <option value="FR">France</option>
498 <option value="BE">Belgium</option>
499 </select>
500 <input id="id_phone_1" name="phone_1" required type="tel">
501 </p>
502 """,
503 )
504 else:
505 self.assertHTMLEqual(
506 form.as_div(),
507 """
508 <div>
509 <fieldset>
510 <legend>
511 Phone:
512 </legend>
513 <select id="id_phone_0" name="phone_0" required>
514 <option value="FR">France</option>
515 <option value="BE">Belgium</option>
516 </select>
517 <input id="id_phone_1" name="phone_1" required type="tel">
518 </fieldset>
519 </div>
520 """,
521 )
522
523 def test_invalid_region(self):
524 class PhoneNumberForm(forms.Form):
525 number = SplitPhoneNumberField()
526
527 form = PhoneNumberForm({"number_0": "NONEXISTENT", "number_1": "+33612345678"})
528 self.assertIs(form.is_valid(), False)
529 self.assertEqual(
530 form.errors,
531 {
532 "number": [
533 "Select a valid choice. "
534 "NONEXISTENT is not one of the available choices."
535 ]
536 },
537 )
538
539 @override_settings(PHONENUMBER_DEFAULT_REGION="FR")
540 def test_input_not_cleared_on_other_field_error(self):
541 class PhoneNumberForm(forms.Form):
542 name = forms.CharField(min_length=4, max_length=100)
543 number = SplitPhoneNumberField(required=False)
544
545 form = PhoneNumberForm({"name": "a", "number_0": "FR", "number_1": "612345678"})
546 self.assertIs(form.is_valid(), False)
547 self.assertEqual(
548 form.errors,
549 {"name": ["Ensure this value has at least 4 characters (it has 1)."]},
550 )
551 form_html = form.as_p()
552 if django.VERSION >= (5, 2):
553 self.assertInHTML(
554 """
555 <ul class="errorlist" id="id_name_error">
556 <li>
557 Ensure this value has at least 4 characters (it has 1).
558 </li>
559 </ul>
560 <p>
561 <label for="id_name">Name:</label>
562 <input
563 id="id_name"
564 maxlength="100"
565 minlength="4"
566 name="name"
567 aria-describedby="id_name_error"
568 aria-invalid="true"
569 required
570 type="text"
571 value="a">
572 </p>
573 """,
574 form_html,
575 count=1,
576 )
577 else:
578 aria_invalid = "" if django.VERSION[0] < 5 else 'aria-invalid="true" '
579 self.assertInHTML(
580 f"""
581 <ul class="errorlist">
582 <li>
583 Ensure this value has at least 4 characters (it has 1).
584 </li>
585 </ul>
586 <p>
587 <label for="id_name">Name:</label>
588 <input
589 id="id_name"
590 maxlength="100"
591 minlength="4"
592 name="name"
593 {aria_invalid}
594 required
595 type="text"
596 value="a">
597 </p>
598 """,
599 form_html,
600 count=1,
601 )
602 self.assertInHTML(
603 '<option selected value="FR">France +33</option>',
604 form_html,
605 count=1,
606 )
607 self.assertInHTML(
608 '<input id="id_number_1" name="number_1" type="tel" value="612345678">',
609 form_html,
610 count=1,
611 )
612
613 def test_without_babel(self):
614 import phonenumber_field.formfields
615
616 babel = phonenumber_field.formfields.babel
617
618 def restore_babel():
619 phonenumber_field.formfields.babel = babel
620
621 self.addCleanup(restore_babel)
622 phonenumber_field.formfields.babel = None
623 with self.assertRaises(ImproperlyConfigured):
624 SplitPhoneNumberField()
625
626 def test_error_message_is_localized(self):
627 class PhoneNumberForm(forms.Form):
628 number = SplitPhoneNumberField()
629
630 form = PhoneNumberForm({"number_0": "FR", "number_1": "1"})
631 if django.VERSION >= (5, 2):
632 self.assertIn(
633 '<ul class="errorlist" id="id_number_error"><li>'
634 "Enter a valid phone number (e.g. 01 23 45 67 89)."
635 "</li></ul>",
636 str(form),
637 )
638 else:
639 self.assertIn(
640 '<ul class="errorlist"><li>'
641 "Enter a valid phone number (e.g. 01 23 45 67 89)."
642 "</li></ul>",
643 str(form),
644 )
645
646 def test_customize_invalid_error_message(self):
647 class CustomSplitPhoneNumberField(SplitPhoneNumberField):
648 def invalid_error_message(self):
649 return "My message using {example_number}."
650
651 class TestForm(forms.Form):
652 phone = CustomSplitPhoneNumberField()
653
654 form = TestForm({"phone_0": "FR", "phone_1": "1"})
655 if django.VERSION >= (5, 2):
656 self.assertInHTML(
657 """
658 <ul class="errorlist" id="id_phone_error">
659 <li>My message using 01 23 45 67 89.</li>
660 </ul>
661 """,
662 str(form),
663 count=1,
664 )
665 else:
666 self.assertIn(
667 '<ul class="errorlist"><li>My message using 01 23 45 67 89.</li></ul>',
668 str(form),
669 )
670
671 def test_clean_handles_invalid_input(self):
672 data = [
673 # require_all_fields, phone_data, error_message
674 (True, {"phone_0": "", "phone_1": "1234"}, "This field is required."),
675 (True, {}, "This field is required."),
676 (True, {"phone_1": "1234"}, "This field is required."),
677 (
678 True,
679 {"phone_0": "invalid", "phone_1": "1234"},
680 "Select a valid choice. invalid is not one of the available choices.",
681 ),
682 (False, {"phone_0": "", "phone_1": "1234"}, "Enter a complete value."),
683 (False, {}, "This field is required."),
684 (False, {"phone_1": "1234"}, "Enter a complete value."),
685 (
686 False,
687 {"phone_0": "invalid", "phone_1": "1234"},
688 "Select a valid choice. invalid is not one of the available choices.",
689 ),
690 ]
691 for all_fields_required, phone_data, error_message in data:
692 with self.subTest(
693 f"require_all_fields={all_fields_required},"
694 f"{phone_data=},"
695 f"{error_message=}"
696 ):
697
698 class TestForm(forms.Form):
699 phone = SplitPhoneNumberField(
700 require_all_fields=all_fields_required
701 )
702
703 form = TestForm(phone_data)
704 self.assertIs(form.is_valid(), False)
705 self.assertEqual(form.errors["phone"], [error_message])
706
707 def test_validate_shortcode(self):
708 class ShortCodeSplitPhoneNumberField(SplitPhoneNumberField):
709 default_validators = [validate_phonenumber]
710
711 class TestForm(forms.Form):
712 phone = ShortCodeSplitPhoneNumberField()
713
714 form = TestForm({"phone_0": "FR", "phone_1": "1010"})
715 self.assertIs(form.is_valid(), True)
716
717 def test_formfield_with_maxlength_null(self):
718 class TestForm(forms.Form):
719 def __init__(self, *args, **kwargs):
720 super().__init__(*args, **kwargs)
721 self.fields = forms.fields_for_model(
722 NullablePhoneNumber,
723 ["phone_number"],
724 field_classes={"phone_number": SplitPhoneNumberField},
725 )
726
727 form = TestForm(data={"phone_number_0": "FR", "phone_number_1": "612345678"})
728 self.assertIs(form.is_valid(), True)
729 self.assertEqual(form.cleaned_data["phone_number"], "+33612345678")
730
731 def test_formfield_with_max_length_default(self):
732 def make_form(model):
733 class TestForm(forms.Form):
734 def __init__(self, *args, **kwargs):
735 super().__init__(*args, **kwargs)
736 self.fields = forms.fields_for_model(
737 model,
738 ["phone"],
739 field_classes={"phone": SplitPhoneNumberField},
740 )
741
742 return TestForm
743
744 for model, empty_value in [
745 (PhoneNumberWithMaxLengthDefault, ""),
746 (PhoneNumberWithMaxLengthNullable, None),
747 ]:
748 TestForm = make_form(model)
749
750 with self.subTest("no data", model=model):
751 form = TestForm(data={})
752 self.assertIs(form.is_valid(), True)
753 self.assertEqual(form.cleaned_data["phone"], empty_value)
754
755 with self.subTest("empty phone number", model=model):
756 form = TestForm(data={"phone_0": "", "phone_1": ""})
757 self.assertIs(form.is_valid(), True)
758 self.assertEqual(form.cleaned_data["phone"], empty_value)
759
760 with self.subTest("phone number within max_length", model=model):
761 form = TestForm(data={"phone_0": "AU", "phone_1": "0444444444"})
762 self.assertIs(form.is_valid(), True)
763 self.assertEqual(form.cleaned_data["phone"], "+61444444444")
764
765 with self.subTest("phone number exceeding max_length", model=model):
766 form = TestForm(data={"phone_0": "FR", "phone_1": "33612345678"})
767 self.assertIs(form.is_valid(), False)
768 self.assertEqual(
769 form.errors,
770 {
771 "phone": [
772 "Ensure this value has no more than 12 characters, "
773 "“6 12 34 56 78” is 13 characters long."
774 ],
775 },
776 )