Debian Codegraph @

tests/tests.py

raw
1 import django
2 import phonenumbers
3 from django import forms
4 from django.core import checks
5 from django.db.models import Model
6 from django.test import SimpleTestCase, TestCase, override_settings
7 from django.utils.encoding import force_str
8
9 from phonenumber_field import formfields, modelfields
10 from phonenumber_field.phonenumber import PhoneNumber, to_python
11
12 from . import models
13 from .forms import ARPhoneNumberForm, CustomPhoneNumberFormField, PhoneNumberForm
14
15 ALGERIAN_PHONE_NUMBER = "+213799136332"
16
17
18 def phone_transform(obj):
19 return (obj.pk, obj.name, obj.phone)
20
21
22 class PhoneNumberFieldTestCase(TestCase):
23 test_number_1 = "+4930123456"
24 equal_number_strings = ["+44 113 8921113", "+441138921113", "tel:+44-113-892-1113"]
25 local_numbers = [("GB", "01606 751 78"), ("DE", "0176/96842671")]
26 storage_numbers = {
27 "E164": ["+44 113 8921113", "+441138921113"],
28 "RFC3966": ["+44 113 8921113", "tel:+44-113-892-1113"],
29 "INTERNATIONAL": ["+44 113 8921113", "+44 113 892 1113"],
30 }
31 invalid_numbers = ["+44 113 892111"]
32
33 def test_str_for_valid_number(self):
34 self.assertEqual(
35 str(PhoneNumber.from_string(self.test_number_1)),
36 self.test_number_1,
37 )
38
39 def test_str_for_invalid_number(self):
40 self.assertEqual(
41 str(to_python("invalid")),
42 "invalid",
43 )
44
45 def test_repr_for_invalid_number(self):
46 self.assertEqual(
47 repr(to_python("invalid")),
48 "InvalidPhoneNumber(raw_input=invalid)",
49 )
50
51 def test_repr_for_valid_number(self):
52 self.assertTrue(
53 repr(PhoneNumber.from_string(self.test_number_1)).startswith(
54 "PhoneNumber("
55 ),
56 )
57
58 def test_valid_numbers_are_valid(self):
59 numbers = [
60 PhoneNumber.from_string(number_string)
61 for number_string in self.equal_number_strings
62 ]
63 self.assertTrue(all(number.is_valid() for number in numbers))
64 numbers = [
65 PhoneNumber.from_string(number_string, region=region)
66 for region, number_string in self.local_numbers
67 ]
68 self.assertTrue(all(number.is_valid() for number in numbers))
69
70 def test_invalid_numbers_are_invalid(self):
71 numbers = [
72 PhoneNumber.from_string(number_string)
73 for number_string in self.invalid_numbers
74 ]
75 self.assertTrue(all(not number.is_valid() for number in numbers))
76
77 def test_same_invalid_numbers_are_equal(self):
78 self.assertEqual(PhoneNumber(raw_input="invalid"), "invalid")
79
80 def test_objects_with_same_number_are_equal(self):
81 numbers = [
82 models.MandatoryPhoneNumber.objects.create(
83 phone_number=number_string
84 ).phone_number
85 for number_string in self.equal_number_strings
86 ]
87 self.assertTrue(
88 all(
89 phonenumbers.is_number_match(n, numbers[0])
90 == phonenumbers.MatchType.EXACT_MATCH
91 for n in numbers
92 )
93 )
94 for number in numbers:
95 self.assertEqual(number, numbers[0])
96 for number_string in self.equal_number_strings:
97 self.assertEqual(number, number_string)
98
99 def test_same_number_has_same_hash(self):
100 numbers = [
101 PhoneNumber.from_string(number_string)
102 for number_string in self.equal_number_strings
103 ]
104 numbers_set = set(numbers)
105 self.assertEqual(len(numbers_set), 1)
106 for number in numbers:
107 self.assertIn(number, numbers_set)
108 self.assertNotIn(self.test_number_1, numbers_set)
109
110 def test_eq_and_ne(self):
111 number_1 = "+411111111"
112 number_2 = "+412222222"
113 one = PhoneNumber.from_string("+411111111")
114 two = PhoneNumber.from_string("+412222222")
115 self.assertNotEqual(one, two)
116 self.assertNotEqual(one, number_2)
117 self.assertNotEqual(number_2, one)
118 self.assertEqual(one, number_1)
119 self.assertEqual(number_1, one)
120
121 def test_blank_field_returns_empty_string(self):
122 model = models.OptionalPhoneNumber()
123 self.assertEqual(model.phone_number, "")
124 model.phone_number = "+49 176 96842671"
125 self.assertIsInstance(model.phone_number, PhoneNumber)
126
127 def test_null_field_returns_none(self):
128 model = models.NullablePhoneNumber()
129 self.assertIsNone(model.phone_number)
130 model.phone_number = self.test_number_1
131 self.assertIsInstance(model.phone_number, PhoneNumber)
132 model.phone_number = phonenumbers.parse(self.test_number_1, keep_raw_input=True)
133 self.assertIsInstance(model.phone_number, PhoneNumber)
134
135 def test_can_assign_string_phone_number(self):
136 opt_phone = models.OptionalPhoneNumber()
137 opt_phone.phone_number = self.test_number_1
138 self.assertIsInstance(opt_phone.phone_number, PhoneNumber)
139 self.assertEqual(opt_phone.phone_number.as_e164, self.test_number_1)
140 opt_phone.full_clean()
141 opt_phone.save()
142 self.assertIsInstance(opt_phone.phone_number, PhoneNumber)
143 self.assertEqual(opt_phone.phone_number.as_e164, self.test_number_1)
144 opt_phone_db = models.OptionalPhoneNumber.objects.get(id=opt_phone.id)
145 self.assertIsInstance(opt_phone_db.phone_number, PhoneNumber)
146 self.assertEqual(opt_phone_db.phone_number.as_e164, self.test_number_1)
147
148 def test_can_assign_phonenumber(self):
149 """
150 Tests assignment phonenumbers.PhoneNumber to field
151 """
152 opt_phone = models.OptionalPhoneNumber()
153 opt_phone.phone_number = phonenumbers.parse(
154 self.test_number_1, keep_raw_input=True
155 )
156 self.assertIsInstance(opt_phone.phone_number, PhoneNumber)
157 self.assertEqual(opt_phone.phone_number.as_e164, self.test_number_1)
158 opt_phone.full_clean()
159 opt_phone.save()
160 self.assertIsInstance(opt_phone.phone_number, PhoneNumber)
161 self.assertEqual(opt_phone.phone_number.as_e164, self.test_number_1)
162 opt_phone_db = models.OptionalPhoneNumber.objects.get(id=opt_phone.id)
163 self.assertIsInstance(opt_phone_db.phone_number, PhoneNumber)
164 self.assertEqual(opt_phone_db.phone_number.as_e164, self.test_number_1)
165
166 def test_raise_on_invalid_values(self):
167 msg = "Can't convert int to PhoneNumber."
168 with self.assertRaisesMessage(TypeError, msg):
169 to_python(42)
170
171 def test_create_with_int(self):
172 msg = "Can't convert int to PhoneNumber."
173 with self.assertRaisesMessage(TypeError, msg):
174 models.MandatoryPhoneNumber.objects.create(
175 phone_number=int(self.test_number_1)
176 )
177
178 def _test_storage_formats(self):
179 """
180 Aggregate of tests to perform for db storage formats
181 """
182 self.test_objects_with_same_number_are_equal()
183 self.test_blank_field_returns_empty_string()
184 self.test_null_field_returns_none()
185 self.test_can_assign_string_phone_number()
186
187 @override_settings(PHONENUMBER_DEFAULT_REGION="DE")
188 def test_storage_formats(self):
189 """
190 Perform aggregate tests for all db storage formats
191 """
192 for frmt in PhoneNumber.format_map:
193 with override_settings(PHONENUMBER_DB_FORMAT=frmt):
194 self._test_storage_formats()
195
196 def test_prep_value(self):
197 """
198 Tests correct db storage value against different setting of
199 PHONENUMBER_DB_FORMAT
200 Required output format is set as string constant to guarantee
201 consistent database storage values
202 """
203 number = modelfields.PhoneNumberField()
204 for frmt in ["E164", "RFC3966", "INTERNATIONAL"]:
205 with override_settings(PHONENUMBER_DB_FORMAT=frmt):
206 self.assertEqual(
207 number.get_prep_value(to_python(self.storage_numbers[frmt][0])),
208 self.storage_numbers[frmt][1],
209 )
210
211 def test_phone_number_form_empty_value(self):
212 form = PhoneNumberForm({"phone_number": ""})
213
214 self.assertTrue(form.is_valid())
215 self.assertDictEqual({"phone_number": None}, form.cleaned_data)
216
217 def test_defer_phone_number_field(self):
218 m = models.MandatoryPhoneNumber.objects.create(phone_number=self.test_number_1)
219 m = models.MandatoryPhoneNumber.objects.defer("phone_number").get(pk=m.pk)
220 self.assertEqual(m.phone_number, self.test_number_1)
221
222 def test_filtering_by_invalid_number_does_not_raise_value_error(self):
223 models.NullablePhoneNumber.objects.filter(phone_number="123")
224
225 def test_filter_by_invalid_type_int_raises_value_error(self):
226 msg = "Can't convert int to PhoneNumber"
227 with self.assertRaisesMessage(TypeError, msg):
228 models.NullablePhoneNumber.objects.filter(phone_number=123).exists()
229
230 def test_filter_by_invalid_number_does_not_match_empty_or_none(self):
231 models.NullablePhoneNumber.objects.create(phone_number="")
232 models.NullablePhoneNumber.objects.create(phone_number=None)
233 self.assertFalse(
234 models.NullablePhoneNumber.objects.filter(phone_number="123").exists()
235 )
236
237 def test_filter_by_invalid_number_does_not_match_partial(self):
238 models.NullablePhoneNumber.objects.create(phone_number="+4930123456")
239 self.assertFalse(
240 models.NullablePhoneNumber.objects.filter(phone_number="123").exists()
241 )
242
243 def test_filter_by_partial_number_of_valid_number_works(self):
244 models.NullablePhoneNumber.objects.create(phone_number="+4923399999")
245 models.NullablePhoneNumber.objects.create(phone_number="+4930123456")
246 self.assertEqual(
247 models.NullablePhoneNumber.objects.filter(
248 phone_number__contains="9999"
249 ).count(),
250 1,
251 )
252 self.assertEqual(
253 models.NullablePhoneNumber.objects.filter(
254 phone_number__contains="123"
255 ).count(),
256 1,
257 )
258
259 def test_values_list(self):
260 num0 = "+33600000000"
261 num1 = "+33611111111"
262 models.MandatoryPhoneNumber.objects.bulk_create(
263 [
264 models.MandatoryPhoneNumber(phone_number=num0),
265 models.MandatoryPhoneNumber(phone_number=num1),
266 ]
267 )
268 number0, number1 = models.MandatoryPhoneNumber.objects.order_by(
269 "phone_number"
270 ).values_list("phone_number", flat=True)
271 self.assertIsInstance(number0, PhoneNumber)
272 self.assertEqual(to_python(num0), number0)
273 self.assertIsInstance(number1, PhoneNumber)
274 self.assertEqual(to_python(num1), number1)
275
276 def test_values_with_null(self):
277 num0 = "+33600000000"
278 models.NullablePhoneNumber.objects.bulk_create(
279 [
280 models.NullablePhoneNumber(phone_number=num0),
281 models.NullablePhoneNumber(phone_number=""),
282 models.NullablePhoneNumber(phone_number=None),
283 ]
284 )
285 number0, number1, number2 = models.NullablePhoneNumber.objects.order_by(
286 "pk"
287 ).values_list("phone_number", flat=True)
288 self.assertIsInstance(number0, PhoneNumber)
289 self.assertEqual(to_python(num0), number0)
290 self.assertIsInstance(number1, str)
291 self.assertEqual(number1, "")
292 self.assertIsNone(number2)
293
294
295 class PhoneNumberFieldAppTest(TestCase):
296 def test_save_field_to_database(self):
297 """Basic Field Test"""
298 tm = models.TestModel()
299 tm.phone = "+41 52 424 2424"
300 tm.full_clean()
301 tm.save()
302 pk = tm.id
303
304 tm = models.TestModel.objects.get(pk=pk)
305 self.assertIsInstance(tm.phone, PhoneNumber)
306 self.assertQuerySetEqual(
307 models.TestModel.objects.all(),
308 [(tm.pk, "", "+41524242424")],
309 transform=phone_transform,
310 )
311
312 @override_settings(PHONENUMBER_DEFAULT_FORMAT="NATIONAL")
313 def test_internal_phone_when_default_format_is_national(self):
314 """Test that the region is not lost in a string conversion."""
315 tm = models.TestModel()
316 tm.phone = "+41 52 424 2424"
317 tm.full_clean()
318 tm.save()
319
320 tm = models.TestModel.objects.get(pk=tm.pk)
321 self.assertIsInstance(tm.phone, PhoneNumber)
322 self.assertQuerySetEqual(
323 models.TestModel.objects.all(),
324 [(tm.pk, "", "+41524242424")],
325 transform=phone_transform,
326 )
327
328 def test_create_with_invalid_number_works(self):
329 obj = models.TestModel.objects.create(phone="invalid")
330 self.assertEqual(obj.phone.raw_input, "invalid")
331 obj = models.TestModel.objects.get(id=obj.id)
332 self.assertEqual(obj.phone.raw_input, "invalid")
333
334 def test_save_invalid_number_works(self):
335 tm = models.TestModel.objects.create(phone="+1 604-333-4444")
336 tm.phone = "invalid"
337 tm.save()
338 tm.refresh_from_db()
339 self.assertEqual(tm.phone.raw_input, "invalid")
340
341 def test_save_change_to_invalid_number_works(self):
342 tm = models.TestModel.objects.create(phone="+1 604-333-4444")
343 tm.phone = "invalid"
344 tm.save(update_fields=["phone"])
345 self.assertEqual(tm.phone.raw_input, "invalid")
346 tm.refresh_from_db()
347 self.assertEqual(tm.phone.raw_input, "invalid")
348
349 def test_queryset_update_to_invalid_number_works(self):
350 tm = models.TestModel.objects.create(phone="+1 604-333-4444")
351 models.TestModel.objects.filter(id=tm.id).update(phone="invalid")
352 tm.refresh_from_db()
353 self.assertEqual(tm.phone.raw_input, "invalid")
354
355 def test_save_blank_phone_to_database(self):
356 """Field Test for when Blank"""
357 tm = models.TestModelPhoneB()
358 tm.save()
359
360 pk = tm.id
361 tm = models.TestModelPhoneB.objects.get(pk=pk)
362 self.assertQuerySetEqual(
363 models.TestModelPhoneB.objects.all(),
364 [(tm.pk, "", "")],
365 transform=phone_transform,
366 )
367
368 def __test_nullable_field_helper(self, TestModel):
369 """Helper method for the next four tests."""
370 tm = TestModel()
371 tm.save()
372
373 pk = tm.id
374 tm = TestModel.objects.get(pk=pk)
375 self.assertIsNone(tm.phone)
376 self.assertQuerySetEqual(
377 TestModel.objects.all(), [(tm.pk, "", None)], transform=phone_transform
378 )
379
380 # ensure that null values do not cause uniqueness conflicts
381 TestModel.objects.create()
382 self.assertEqual(TestModel.objects.count(), 2)
383
384 def test_save_unique_null_phone_to_database(self):
385 """Field Test for when Null & Unique"""
386 self.__test_nullable_field_helper(models.TestModelPhoneNU)
387
388 def test_save_unique_null_blank_phone_to_database(self):
389 """Field Test for when Blank, Null & Unique"""
390 self.__test_nullable_field_helper(models.TestModelPhoneBNU)
391
392 def test_save_unique_null_none_phone_to_database(self):
393 """Field Test for when No Default, Null & Unique"""
394 self.__test_nullable_field_helper(models.TestModelPhoneNDNU)
395
396 def test_save_unique_null_blank_none_phone_to_database(self):
397 """Field Test for when Blank, No Default, Null & Unique"""
398 self.__test_nullable_field_helper(models.TestModelPhoneBNDNU)
399
400 def __test_nullable_default_field_helper(self, TestModel):
401 """Helper method for the next two tests."""
402 tm = TestModel()
403 tm.save()
404
405 pk = tm.id
406 tm = TestModel.objects.get(pk=pk)
407 self.assertQuerySetEqual(
408 TestModel.objects.all(),
409 [(tm.pk, "", "+41524242424")],
410 transform=phone_transform,
411 )
412
413 def test_save_unique_null_default_phone_to_database(self):
414 """Field Test for when Default, Null & Unique"""
415 self.__test_nullable_default_field_helper(models.TestModelPhoneDNU)
416
417 def test_save_unique_null_blank_default_phone_to_database(self):
418 """Field Test for when Blank, Default, Null & Unique"""
419 self.__test_nullable_default_field_helper(models.TestModelPhoneBDNU)
420
421 def __test_nullable_empty_default_field_helper(self, TestModel):
422 """Helper method for the next two tests."""
423 tm = TestModel()
424 tm.save()
425
426 pk = tm.id
427 tm = TestModel.objects.get(pk=pk)
428 self.assertQuerySetEqual(
429 TestModel.objects.all(), [(tm.pk, "", "")], transform=phone_transform
430 )
431
432 def test_save_unique_null_default_empty_phone_to_database(self):
433 """Field Test for when Empty Default, Null & Unique"""
434 self.__test_nullable_empty_default_field_helper(models.TestModelPhoneEDNU)
435
436 def test_save_unique_null_blank_default_empty_phone_to_database(self):
437 """Field Test for when Blank, Empty Default, Null & Unique"""
438 self.__test_nullable_empty_default_field_helper(models.TestModelPhoneBEDNU)
439
440 def test_model_attribute_can_be_accessed_on_class(self):
441 self.assertIsInstance(models.TestModel.phone, modelfields.PhoneNumberDescriptor)
442
443
444 class RegionPhoneNumberFormFieldTest(SimpleTestCase):
445 def test_regional_phone(self):
446 class PhoneNumberForm(forms.Form):
447 canadian_number = formfields.PhoneNumberField(region="CA")
448 french_number = formfields.PhoneNumberField(region="FR")
449
450 form = PhoneNumberForm(
451 {"canadian_number": "604-686-2877", "french_number": "06 12 34 56 78"}
452 )
453
454 self.assertIs(form.is_valid(), True)
455 self.assertEqual("+16046862877", form.cleaned_data["canadian_number"])
456 self.assertEqual("+33612345678", form.cleaned_data["french_number"])
457
458 def test_invalid_region(self):
459 with self.assertRaises(ValueError) as cm:
460 formfields.PhoneNumberField(region="invalid")
461
462 self.assertTrue(
463 force_str(cm.exception).startswith("“invalid” is not a valid region code.")
464 )
465
466 def test_error_message_nationalize_example(self):
467 class PhoneNumberForm(forms.Form):
468 number = formfields.PhoneNumberField(region="CA")
469
470 form = PhoneNumberForm({"number": "invalid"})
471 self.assertIs(form.is_valid(), False)
472 self.assertEqual(
473 form.errors,
474 {
475 "number": [
476 "Enter a valid phone number (e.g. (506) 234-5678) "
477 "or a number with an international call prefix."
478 ]
479 },
480 )
481
482 @override_settings(PHONENUMBER_DEFAULT_REGION="FR")
483 def test_formfield_uses_default_region(self):
484 class PhoneForm(forms.Form):
485 phone_number = formfields.PhoneNumberField()
486
487 form = PhoneForm()
488 self.assertEqual("FR", form.fields["phone_number"].region)
489
490
491 class RegionPhoneNumberModelFieldTest(TestCase):
492 def test_uses_region(self):
493 m = models.FrenchPhoneOwner(cell_number="06 12 34 56 78")
494 self.assertEqual(phonenumbers.parse("+33612345678"), m.cell_number)
495
496 def test_accepts_international_numbers(self):
497 num = "+16042234567"
498 m = models.FrenchPhoneOwner(cell_number=num)
499 self.assertEqual(phonenumbers.parse(num), m.cell_number)
500
501 def test_formfield_uses_region(self):
502 class FrenchPhoneForm(forms.ModelForm):
503 class Meta:
504 model = models.FrenchPhoneOwner
505 fields = ["cell_number"]
506
507 form = FrenchPhoneForm()
508 self.assertEqual("FR", form.fields["cell_number"].region)
509
510 def test_deconstruct_region(self):
511 phone_field = modelfields.PhoneNumberField(region="CH")
512 _name, path, args, kwargs = phone_field.deconstruct()
513 self.assertEqual("phonenumber_field.modelfields.PhoneNumberField", path)
514 self.assertEqual([], args)
515 self.assertEqual({"max_length": 128, "region": "CH"}, kwargs)
516
517 def test_deconstruct_no_region(self):
518 phone_field = modelfields.PhoneNumberField()
519 _name, path, args, kwargs = phone_field.deconstruct()
520 self.assertEqual("phonenumber_field.modelfields.PhoneNumberField", path)
521 self.assertEqual([], args)
522 self.assertEqual({"max_length": 128, "region": None}, kwargs)
523
524 def test_check_region(self):
525 class InvalidRegionModel(Model):
526 phone_field = modelfields.PhoneNumberField(region="invalid")
527
528 errors = InvalidRegionModel.check()
529 self.assertEqual(1, len(errors))
530 error = errors[0]
531 self.assertIsInstance(error, checks.Error)
532 self.assertTrue(error.msg.startswith("“invalid” is not a valid region code."))
533 self.assertEqual(error.obj, InvalidRegionModel._meta.get_field("phone_field"))
534
535 def test_override_form_field(self):
536 phone_number = models.CustomPhoneNumber()
537 model_field = phone_number._meta.get_field("phone_number")
538 self.assertIsInstance(model_field.formfield(), CustomPhoneNumberFormField)
539
540 @override_settings(PHONENUMBER_DEFAULT_REGION="FR")
541 def test_uses_default_region(self):
542 m = models.MandatoryPhoneNumber.objects.create(phone_number="06 12 34 56 78")
543 self.assertEqual(phonenumbers.parse("+33612345678"), m.phone_number)
544
545 @override_settings(PHONENUMBER_DEFAULT_REGION="FR")
546 def test_formfield_uses_default_region(self):
547 class PhoneForm(forms.ModelForm):
548 class Meta:
549 model = models.MandatoryPhoneNumber
550 fields = ["phone_number"]
551
552 form = PhoneForm()
553 self.assertEqual("FR", form.fields["phone_number"].region)
554
555 @override_settings(PHONENUMBER_DEFAULT_REGION="FR")
556 def test_desconstruct_does_not_use_default_region(self):
557 field = modelfields.PhoneNumberField()
558 _name, path, args, kwargs = field.deconstruct()
559 self.assertEqual("phonenumber_field.modelfields.PhoneNumberField", path)
560 self.assertEqual([], args)
561 self.assertEqual({"max_length": 128, "region": None}, kwargs)
562
563 @override_settings(PHONENUMBER_DEFAULT_REGION="FR")
564 def test_region_uses_default_region(self):
565 field = modelfields.PhoneNumberField()
566 self.assertEqual("FR", field.region)
567
568 def test_region_none(self):
569 field = modelfields.PhoneNumberField()
570 self.assertIsNone(field.region)
571
572 def test_algerian_phone_number_in_model(self):
573 m = models.MandatoryPhoneNumber.objects.create(
574 phone_number=ALGERIAN_PHONE_NUMBER
575 )
576 self.assertEqual(phonenumbers.parse(ALGERIAN_PHONE_NUMBER), m.phone_number)
577 self.assertEqual(ALGERIAN_PHONE_NUMBER, m.phone_number)
578
579 def test_region_field_empty(self):
580 obj = models.TestModelRegionAR.objects.create()
581 form = ARPhoneNumberForm(instance=obj)
582 self.assertHTMLEqual(
583 form.as_p(),
584 "<p>"
585 '<label for="id_phone">Phone:</label>'
586 "<input "
587 'type="tel" '
588 'name="phone" '
589 'maxlength="128" '
590 'id="id_phone">'
591 "</p>",
592 )
593
594 def test_region_field_renders_international_as_E164(self):
595 form = ARPhoneNumberForm({"phone": "+32468547825"})
596 self.assertTrue(form.is_valid())
597 self.assertHTMLEqual(
598 form.as_p(),
599 "<p>"
600 '<label for="id_phone">Phone:</label>'
601 "<input "
602 'type="tel" '
603 'name="phone" '
604 'value="+32468547825" '
605 'maxlength="128" '
606 'id="id_phone">'
607 "</p>",
608 )
609
610 def test_region_field_renders_international_as_E164_from_instance(self):
611 obj = models.TestModelRegionAR.objects.create(phone="+32468547825")
612 form = ARPhoneNumberForm(instance=obj)
613 self.assertHTMLEqual(
614 form.as_p(),
615 "<p>"
616 '<label for="id_phone">Phone:</label> '
617 "<input "
618 'type="tel" '
619 'name="phone" '
620 'value="+32468547825" '
621 'maxlength="128" '
622 'id="id_phone">'
623 "</p>",
624 )
625
626 def test_region_field_renders_national_numbers_as_national(self):
627 form = ARPhoneNumberForm({"phone": "01145482368"})
628 self.assertTrue(form.is_valid())
629 self.assertHTMLEqual(
630 form.as_p(),
631 "<p>"
632 '<label for="id_phone">Phone:</label>'
633 "<input "
634 'type="tel" '
635 'name="phone" '
636 'value="011 4548-2368" '
637 'maxlength="128" '
638 'id="id_phone">'
639 "</p>",
640 )
641
642 def test_region_field_renders_national_numbers_as_national_from_instance(self):
643 obj = models.TestModelRegionAR.objects.create(phone="01145482368")
644 form = ARPhoneNumberForm(instance=obj)
645 self.assertHTMLEqual(
646 form.as_p(),
647 "<p>"
648 '<label for="id_phone">Phone:</label> '
649 "<input "
650 'type="tel" '
651 'name="phone" '
652 'value="011 4548-2368" '
653 'maxlength="128" '
654 'id="id_phone">'
655 "</p>",
656 )
657
658 def test_region_field_renders_national_numbers_from_instance_and_form_data(self):
659 obj = models.TestModelRegionAR.objects.create(phone="01145482368")
660 form = ARPhoneNumberForm({"phone": "011 4548-2368"}, instance=obj)
661 self.assertTrue(form.is_valid())
662 self.assertHTMLEqual(
663 form.as_p(),
664 "<p>"
665 '<label for="id_phone">Phone:</label> '
666 "<input "
667 'type="tel" '
668 'name="phone" '
669 'value="011 4548-2368" '
670 'maxlength="128" '
671 'id="id_phone">'
672 "</p>",
673 )
674
675 def test_region_field_renders_invalid_numbers(self):
676 form = ARPhoneNumberForm({"phone": "abcdef"})
677 self.assertFalse(form.is_valid())
678 if django.VERSION >= (5, 2):
679 self.assertHTMLEqual(
680 form.as_p(),
681 '<ul class="errorlist" id="id_phone_error">'
682 "<li>Enter a valid phone number (e.g. 011 2345-6789) "
683 "or a number with an international call prefix.</li>"
684 "</ul>"
685 "<p>"
686 '<label for="id_phone">Phone:</label>'
687 "<input "
688 'type="tel" '
689 'name="phone" '
690 'value="abcdef" '
691 'maxlength="128" '
692 'aria-describedby="id_phone_error" '
693 'aria-invalid="true" '
694 'id="id_phone">'
695 "</p>",
696 )
697 else:
698 aria_invalid = "" if django.VERSION[0] < 5 else 'aria-invalid="true" '
699 self.assertHTMLEqual(
700 form.as_p(),
701 '<ul class="errorlist">'
702 "<li>Enter a valid phone number (e.g. 011 2345-6789) "
703 "or a number with an international call prefix.</li>"
704 "</ul>"
705 "<p>"
706 '<label for="id_phone">Phone:</label>'
707 "<input "
708 'type="tel" '
709 'name="phone" '
710 'value="abcdef" '
711 'maxlength="128" '
712 f"{aria_invalid}"
713 'id="id_phone">'
714 "</p>",
715 )