mirror of
https://github.com/django/django.git
synced 2025-10-31 09:41:08 +00:00
4971a9afe5
Thanks Claude Paroz for the review. Co-authored-by: Nina Menezes <77671865+nmenezes0@users.noreply.github.com>
906 lines
35 KiB
Python
906 lines
35 KiB
Python
import re
|
||
import types
|
||
from datetime import datetime, timedelta
|
||
from decimal import Decimal
|
||
from unittest import TestCase, mock
|
||
|
||
from django.core.exceptions import ValidationError
|
||
from django.core.files.base import ContentFile
|
||
from django.core.validators import (
|
||
BaseValidator,
|
||
DecimalValidator,
|
||
DomainNameValidator,
|
||
EmailValidator,
|
||
FileExtensionValidator,
|
||
MaxLengthValidator,
|
||
MaxValueValidator,
|
||
MinLengthValidator,
|
||
MinValueValidator,
|
||
ProhibitNullCharactersValidator,
|
||
RegexValidator,
|
||
StepValueValidator,
|
||
URLValidator,
|
||
int_list_validator,
|
||
validate_comma_separated_integer_list,
|
||
validate_domain_name,
|
||
validate_email,
|
||
validate_image_file_extension,
|
||
validate_integer,
|
||
validate_ipv4_address,
|
||
validate_ipv6_address,
|
||
validate_ipv46_address,
|
||
validate_slug,
|
||
validate_unicode_slug,
|
||
)
|
||
from django.test import SimpleTestCase
|
||
|
||
try:
|
||
from PIL import Image # noqa
|
||
except ImportError:
|
||
PILLOW_IS_INSTALLED = False
|
||
else:
|
||
PILLOW_IS_INSTALLED = True
|
||
|
||
NOW = datetime.now()
|
||
EXTENDED_SCHEMES = ["http", "https", "ftp", "ftps", "git", "file", "git+ssh"]
|
||
|
||
VALID_URLS = [
|
||
"http://www.djangoproject.com/",
|
||
"HTTP://WWW.DJANGOPROJECT.COM/",
|
||
"http://localhost/",
|
||
"http://example.com/",
|
||
"http://example.com:0",
|
||
"http://example.com:0/",
|
||
"http://example.com:65535",
|
||
"http://example.com:65535/",
|
||
"http://example.com./",
|
||
"http://www.example.com/",
|
||
"http://www.example.com:8000/test",
|
||
"http://valid-with-hyphens.com/",
|
||
"http://subdomain.example.com/",
|
||
"http://a.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||
"http://200.8.9.10/",
|
||
"http://200.8.9.10:8000/test",
|
||
"http://su--b.valid-----hyphens.com/",
|
||
"http://example.com?something=value",
|
||
"http://example.com/index.php?something=value&another=value2",
|
||
"https://example.com/",
|
||
"ftp://example.com/",
|
||
"ftps://example.com/",
|
||
"http://foo.com/blah_blah",
|
||
"http://foo.com/blah_blah/",
|
||
"http://foo.com/blah_blah_(wikipedia)",
|
||
"http://foo.com/blah_blah_(wikipedia)_(again)",
|
||
"http://www.example.com/wpstyle/?p=364",
|
||
"https://www.example.com/foo/?bar=baz&inga=42&quux",
|
||
"http://✪df.ws/123",
|
||
"http://userid@example.com",
|
||
"http://userid@example.com/",
|
||
"http://userid@example.com:8080",
|
||
"http://userid@example.com:8080/",
|
||
"http://userid@example.com:65535",
|
||
"http://userid@example.com:65535/",
|
||
"http://userid:@example.com",
|
||
"http://userid:@example.com/",
|
||
"http://userid:@example.com:8080",
|
||
"http://userid:@example.com:8080/",
|
||
"http://userid:password@example.com",
|
||
"http://userid:password@example.com/",
|
||
"http://userid:password@example.com:8",
|
||
"http://userid:password@example.com:8/",
|
||
"http://userid:password@example.com:8080",
|
||
"http://userid:password@example.com:8080/",
|
||
"http://userid:password@example.com:65535",
|
||
"http://userid:password@example.com:65535/",
|
||
"https://userid:paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||
"aaaaaaaaaaaaaaaaaaaaaaaaassword@example.com",
|
||
"https://userid:paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||
"aaaaaaaaaaaaaaaaaaaassword@example.com:8080",
|
||
"https://useridddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
|
||
"ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
|
||
"ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
|
||
"dddddddddddddddddddddd:password@example.com",
|
||
"https://useridddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
|
||
"ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
|
||
"ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
|
||
"ddddddddddddddddd:password@example.com:8080",
|
||
"http://userid:password" + "d" * 2000 + "@example.aaaaaaaaaaaaa.com",
|
||
"http://142.42.1.1/",
|
||
"http://142.42.1.1:8080/",
|
||
"http://➡.ws/䨹",
|
||
"http://⌘.ws",
|
||
"http://⌘.ws/",
|
||
"http://foo.com/blah_(wikipedia)#cite-1",
|
||
"http://foo.com/blah_(wikipedia)_blah#cite-1",
|
||
"http://foo.com/unicode_(✪)_in_parens",
|
||
"http://foo.com/(something)?after=parens",
|
||
"http://☺.damowmow.com/",
|
||
"http://djangoproject.com/events/#&product=browser",
|
||
"http://j.mp",
|
||
"ftp://foo.bar/baz",
|
||
"http://foo.bar/?q=Test%20URL-encoded%20stuff",
|
||
"http://مثال.إختبار",
|
||
"http://例子.测试",
|
||
"http://उदाहरण.परीक्षा",
|
||
"http://-.~_!$&'()*+,;=%40:80%2f@example.com",
|
||
"http://xn--7sbb4ac0ad0be6cf.xn--p1ai",
|
||
"http://1337.net",
|
||
"http://a.b-c.de",
|
||
"http://223.255.255.254",
|
||
"ftps://foo.bar/",
|
||
"http://10.1.1.254",
|
||
"http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html",
|
||
"http://[::192.9.5.5]/ipng",
|
||
"http://[::ffff:192.9.5.5]/ipng",
|
||
"http://[::1]:8080/",
|
||
"http://0.0.0.0/",
|
||
"http://255.255.255.255",
|
||
"http://224.0.0.0",
|
||
"http://224.1.1.1",
|
||
"http://111.112.113.114/",
|
||
"http://88.88.88.88/",
|
||
"http://11.12.13.14/",
|
||
"http://10.20.30.40/",
|
||
"http://1.2.3.4/",
|
||
"http://127.0.01.09.home.lan",
|
||
"http://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ex"
|
||
"ample.com",
|
||
"http://example.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||
"aaaaa.com",
|
||
"http://example.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||
"http://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaa"
|
||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaa"
|
||
"aaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaa"
|
||
"aaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||
"http://dashintld.c-m",
|
||
"http://multipledashintld.a-b-c",
|
||
"http://evenmoredashintld.a---c",
|
||
"http://dashinpunytld.xn---c",
|
||
]
|
||
|
||
INVALID_URLS = [
|
||
None,
|
||
56,
|
||
"no_scheme",
|
||
"foo",
|
||
"http://",
|
||
"http://example",
|
||
"http://example.",
|
||
"http://example.com:-1",
|
||
"http://example.com:-1/",
|
||
"http://example.com:000000080",
|
||
"http://example.com:000000080/",
|
||
"http://.com",
|
||
"http://invalid-.com",
|
||
"http://-invalid.com",
|
||
"http://invalid.com-",
|
||
"http://invalid.-com",
|
||
"http://inv-.alid-.com",
|
||
"http://inv-.-alid.com",
|
||
"file://localhost/path",
|
||
"git://example.com/",
|
||
"http://.",
|
||
"http://..",
|
||
"http://../",
|
||
"http://?",
|
||
"http://??",
|
||
"http://??/",
|
||
"http://#",
|
||
"http://##",
|
||
"http://##/",
|
||
"http://foo.bar?q=Spaces should be encoded",
|
||
"//",
|
||
"//a",
|
||
"///a",
|
||
"///",
|
||
"http:///a",
|
||
"foo.com",
|
||
"rdar://1234",
|
||
"h://test",
|
||
"http:// shouldfail.com",
|
||
":// should fail",
|
||
"http://foo.bar/foo(bar)baz quux",
|
||
"http://-error-.invalid/",
|
||
"http://dashinpunytld.trailingdot.xn--.",
|
||
"http://dashinpunytld.xn---",
|
||
"http://-a.b.co",
|
||
"http://a.b-.co",
|
||
"http://a.-b.co",
|
||
"http://a.b-.c.co",
|
||
"http:/",
|
||
"http://",
|
||
"http://",
|
||
"http://1.1.1.1.1",
|
||
"http://123.123.123",
|
||
"http://3628126748",
|
||
"http://123",
|
||
"http://000.000.000.000",
|
||
"http://016.016.016.016",
|
||
"http://192.168.000.001",
|
||
"http://01.2.3.4",
|
||
"http://01.2.3.4",
|
||
"http://1.02.3.4",
|
||
"http://1.2.03.4",
|
||
"http://1.2.3.04",
|
||
"http://.www.foo.bar/",
|
||
"http://.www.foo.bar./",
|
||
"http://[::1:2::3]:8/",
|
||
"http://[::1:2::3]:8080/",
|
||
"http://[]",
|
||
"http://[]:8080",
|
||
"http://example..com/",
|
||
"http://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.e"
|
||
"xample.com",
|
||
"http://example.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||
"aaaaaa.com",
|
||
"http://example.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||
"aaaaaa",
|
||
"http://example." + ("a" * 63 + ".") * 1000 + "com",
|
||
"http://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaa."
|
||
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaa"
|
||
"aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa"
|
||
"aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaa",
|
||
"https://test.[com",
|
||
"http://@example.com",
|
||
"http://:@example.com",
|
||
"http://:bar@example.com",
|
||
"http://foo@bar@example.com",
|
||
"http://foo/bar@example.com",
|
||
"http://foo:bar:baz@example.com",
|
||
"http://foo:bar@baz@example.com",
|
||
"http://foo:bar/baz@example.com",
|
||
"http://invalid-.com/?m=foo@example.com",
|
||
# Newlines and tabs are not accepted.
|
||
"http://www.djangoproject.com/\n",
|
||
"http://[::ffff:192.9.5.5]\n",
|
||
"http://www.djangoproject.com/\r",
|
||
"http://[::ffff:192.9.5.5]\r",
|
||
"http://www.django\rproject.com/",
|
||
"http://[::\rffff:192.9.5.5]",
|
||
"http://\twww.djangoproject.com/",
|
||
"http://\t[::ffff:192.9.5.5]",
|
||
# Trailing junk does not take forever to reject.
|
||
"http://www.asdasdasdasdsadfm.com.br ",
|
||
"http://www.asdasdasdasdsadfm.com.br z",
|
||
]
|
||
|
||
TEST_DATA = [
|
||
# (validator, value, expected),
|
||
(validate_integer, "42", None),
|
||
(validate_integer, "-42", None),
|
||
(validate_integer, -42, None),
|
||
(validate_integer, -42.5, ValidationError),
|
||
(validate_integer, None, ValidationError),
|
||
(validate_integer, "a", ValidationError),
|
||
(validate_integer, "\n42", ValidationError),
|
||
(validate_integer, "42\n", ValidationError),
|
||
(validate_email, "email@here.com", None),
|
||
(validate_email, "weirder-email@here.and.there.com", None),
|
||
(validate_email, "email@[127.0.0.1]", None),
|
||
(validate_email, "email@[2001:dB8::1]", None),
|
||
(validate_email, "email@[2001:dB8:0:0:0:0:0:1]", None),
|
||
(validate_email, "email@[::fffF:127.0.0.1]", None),
|
||
(validate_email, "example@valid-----hyphens.com", None),
|
||
(validate_email, "example@valid-with-hyphens.com", None),
|
||
(validate_email, "test@domain.with.idn.tld.उदाहरण.परीक्षा", None),
|
||
(validate_email, "email@localhost", None),
|
||
(EmailValidator(allowlist=["localdomain"]), "email@localdomain", None),
|
||
(validate_email, '"test@test"@example.com', None),
|
||
(validate_email, "example@atm.%s" % ("a" * 63), None),
|
||
(validate_email, "example@%s.atm" % ("a" * 63), None),
|
||
(validate_email, "example@%s.%s.atm" % ("a" * 63, "b" * 10), None),
|
||
(validate_email, "example@atm.%s" % ("a" * 64), ValidationError),
|
||
(validate_email, "example@%s.atm.%s" % ("b" * 64, "a" * 63), ValidationError),
|
||
(validate_email, "example@%scom" % (("a" * 63 + ".") * 100), ValidationError),
|
||
(validate_email, None, ValidationError),
|
||
(validate_email, "", ValidationError),
|
||
(validate_email, "abc", ValidationError),
|
||
(validate_email, "abc@", ValidationError),
|
||
(validate_email, "abc@bar", ValidationError),
|
||
(validate_email, "a @x.cz", ValidationError),
|
||
(validate_email, "abc@.com", ValidationError),
|
||
(validate_email, "something@@somewhere.com", ValidationError),
|
||
(validate_email, "email@127.0.0.1", ValidationError),
|
||
(validate_email, "email@[127.0.0.256]", ValidationError),
|
||
(validate_email, "email@[2001:db8::12345]", ValidationError),
|
||
(validate_email, "email@[2001:db8:0:0:0:0:1]", ValidationError),
|
||
(validate_email, "email@[::ffff:127.0.0.256]", ValidationError),
|
||
(validate_email, "email@[2001:dg8::1]", ValidationError),
|
||
(validate_email, "email@[2001:dG8:0:0:0:0:0:1]", ValidationError),
|
||
(validate_email, "email@[::fTzF:127.0.0.1]", ValidationError),
|
||
(validate_email, "example@invalid-.com", ValidationError),
|
||
(validate_email, "example@-invalid.com", ValidationError),
|
||
(validate_email, "example@invalid.com-", ValidationError),
|
||
(validate_email, "example@inv-.alid-.com", ValidationError),
|
||
(validate_email, "example@inv-.-alid.com", ValidationError),
|
||
(validate_email, 'test@example.com\n\n<script src="x.js">', ValidationError),
|
||
# Quoted-string format (CR not allowed)
|
||
(validate_email, '"\\\011"@here.com', None),
|
||
(validate_email, '"\\\012"@here.com', ValidationError),
|
||
(validate_email, "trailingdot@shouldfail.com.", ValidationError),
|
||
# Max length of domain name labels is 63 characters per RFC 1034.
|
||
(validate_email, "a@%s.us" % ("a" * 63), None),
|
||
(validate_email, "a@%s.us" % ("a" * 64), ValidationError),
|
||
# Trailing newlines in username or domain not allowed
|
||
(validate_email, "a@b.com\n", ValidationError),
|
||
(validate_email, "a\n@b.com", ValidationError),
|
||
(validate_email, '"test@test"\n@example.com', ValidationError),
|
||
(validate_email, "a@[127.0.0.1]\n", ValidationError),
|
||
(validate_slug, "slug-ok", None),
|
||
(validate_slug, "longer-slug-still-ok", None),
|
||
(validate_slug, "--------", None),
|
||
(validate_slug, "nohyphensoranything", None),
|
||
(validate_slug, "a", None),
|
||
(validate_slug, "1", None),
|
||
(validate_slug, "a1", None),
|
||
(validate_slug, "", ValidationError),
|
||
(validate_slug, " text ", ValidationError),
|
||
(validate_slug, " ", ValidationError),
|
||
(validate_slug, "some@mail.com", ValidationError),
|
||
(validate_slug, "你好", ValidationError),
|
||
(validate_slug, "你 好", ValidationError),
|
||
(validate_slug, "\n", ValidationError),
|
||
(validate_slug, "trailing-newline\n", ValidationError),
|
||
(validate_unicode_slug, "slug-ok", None),
|
||
(validate_unicode_slug, "longer-slug-still-ok", None),
|
||
(validate_unicode_slug, "--------", None),
|
||
(validate_unicode_slug, "nohyphensoranything", None),
|
||
(validate_unicode_slug, "a", None),
|
||
(validate_unicode_slug, "1", None),
|
||
(validate_unicode_slug, "a1", None),
|
||
(validate_unicode_slug, "你好", None),
|
||
(validate_unicode_slug, "", ValidationError),
|
||
(validate_unicode_slug, " text ", ValidationError),
|
||
(validate_unicode_slug, " ", ValidationError),
|
||
(validate_unicode_slug, "some@mail.com", ValidationError),
|
||
(validate_unicode_slug, "\n", ValidationError),
|
||
(validate_unicode_slug, "你 好", ValidationError),
|
||
(validate_unicode_slug, "trailing-newline\n", ValidationError),
|
||
(validate_ipv4_address, "1.1.1.1", None),
|
||
(validate_ipv4_address, "255.0.0.0", None),
|
||
(validate_ipv4_address, "0.0.0.0", None),
|
||
(validate_ipv4_address, "256.1.1.1", ValidationError),
|
||
(validate_ipv4_address, "25.1.1.", ValidationError),
|
||
(validate_ipv4_address, "25,1,1,1", ValidationError),
|
||
(validate_ipv4_address, "25.1 .1.1", ValidationError),
|
||
(validate_ipv4_address, "1.1.1.1\n", ValidationError),
|
||
(validate_ipv4_address, "٧.2٥.3٣.243", ValidationError),
|
||
# Leading zeros are forbidden to avoid ambiguity with the octal notation.
|
||
(validate_ipv4_address, "000.000.000.000", ValidationError),
|
||
(validate_ipv4_address, "016.016.016.016", ValidationError),
|
||
(validate_ipv4_address, "192.168.000.001", ValidationError),
|
||
(validate_ipv4_address, "01.2.3.4", ValidationError),
|
||
(validate_ipv4_address, "01.2.3.4", ValidationError),
|
||
(validate_ipv4_address, "1.02.3.4", ValidationError),
|
||
(validate_ipv4_address, "1.2.03.4", ValidationError),
|
||
(validate_ipv4_address, "1.2.3.04", ValidationError),
|
||
# validate_ipv6_address uses django.utils.ipv6, which
|
||
# is tested in much greater detail in its own testcase
|
||
(validate_ipv6_address, "fe80::1", None),
|
||
(validate_ipv6_address, "::1", None),
|
||
(validate_ipv6_address, "1:2:3:4:5:6:7:8", None),
|
||
(validate_ipv6_address, "1:2", ValidationError),
|
||
(validate_ipv6_address, "::zzz", ValidationError),
|
||
(validate_ipv6_address, "12345::", ValidationError),
|
||
(validate_ipv46_address, "1.1.1.1", None),
|
||
(validate_ipv46_address, "255.0.0.0", None),
|
||
(validate_ipv46_address, "0.0.0.0", None),
|
||
(validate_ipv46_address, "fe80::1", None),
|
||
(validate_ipv46_address, "::1", None),
|
||
(validate_ipv46_address, "1:2:3:4:5:6:7:8", None),
|
||
(validate_ipv46_address, "256.1.1.1", ValidationError),
|
||
(validate_ipv46_address, "25.1.1.", ValidationError),
|
||
(validate_ipv46_address, "25,1,1,1", ValidationError),
|
||
(validate_ipv46_address, "25.1 .1.1", ValidationError),
|
||
(validate_ipv46_address, "1:2", ValidationError),
|
||
(validate_ipv46_address, "::zzz", ValidationError),
|
||
(validate_ipv46_address, "12345::", ValidationError),
|
||
# Leading zeros are forbidden to avoid ambiguity with the octal notation.
|
||
(validate_ipv46_address, "000.000.000.000", ValidationError),
|
||
(validate_ipv46_address, "016.016.016.016", ValidationError),
|
||
(validate_ipv46_address, "192.168.000.001", ValidationError),
|
||
(validate_ipv46_address, "01.2.3.4", ValidationError),
|
||
(validate_ipv46_address, "01.2.3.4", ValidationError),
|
||
(validate_ipv46_address, "1.02.3.4", ValidationError),
|
||
(validate_ipv46_address, "1.2.03.4", ValidationError),
|
||
(validate_ipv46_address, "1.2.3.04", ValidationError),
|
||
(validate_comma_separated_integer_list, "1", None),
|
||
(validate_comma_separated_integer_list, "12", None),
|
||
(validate_comma_separated_integer_list, "1,2", None),
|
||
(validate_comma_separated_integer_list, "1,2,3", None),
|
||
(validate_comma_separated_integer_list, "10,32", None),
|
||
(validate_comma_separated_integer_list, "", ValidationError),
|
||
(validate_comma_separated_integer_list, "a", ValidationError),
|
||
(validate_comma_separated_integer_list, "a,b,c", ValidationError),
|
||
(validate_comma_separated_integer_list, "1, 2, 3", ValidationError),
|
||
(validate_comma_separated_integer_list, ",", ValidationError),
|
||
(validate_comma_separated_integer_list, "1,2,3,", ValidationError),
|
||
(validate_comma_separated_integer_list, "1,2,", ValidationError),
|
||
(validate_comma_separated_integer_list, ",1", ValidationError),
|
||
(validate_comma_separated_integer_list, "1,,2", ValidationError),
|
||
(int_list_validator(sep="."), "1.2.3", None),
|
||
(int_list_validator(sep=".", allow_negative=True), "1.2.3", None),
|
||
(int_list_validator(allow_negative=True), "-1,-2,3", None),
|
||
(int_list_validator(allow_negative=True), "1,-2,-12", None),
|
||
(int_list_validator(), "-1,2,3", ValidationError),
|
||
(int_list_validator(sep="."), "1,2,3", ValidationError),
|
||
(int_list_validator(sep="."), "1.2.3\n", ValidationError),
|
||
(MaxValueValidator(10), 10, None),
|
||
(MaxValueValidator(10), -10, None),
|
||
(MaxValueValidator(10), 0, None),
|
||
(MaxValueValidator(NOW), NOW, None),
|
||
(MaxValueValidator(NOW), NOW - timedelta(days=1), None),
|
||
(MaxValueValidator(0), 1, ValidationError),
|
||
(MaxValueValidator(NOW), NOW + timedelta(days=1), ValidationError),
|
||
(MinValueValidator(-10), -10, None),
|
||
(MinValueValidator(-10), 10, None),
|
||
(MinValueValidator(-10), 0, None),
|
||
(MinValueValidator(NOW), NOW, None),
|
||
(MinValueValidator(NOW), NOW + timedelta(days=1), None),
|
||
(MinValueValidator(0), -1, ValidationError),
|
||
(MinValueValidator(NOW), NOW - timedelta(days=1), ValidationError),
|
||
# limit_value may be a callable.
|
||
(MinValueValidator(lambda: 1), 0, ValidationError),
|
||
(MinValueValidator(lambda: 1), 1, None),
|
||
(StepValueValidator(3), 0, None),
|
||
(MaxLengthValidator(10), "", None),
|
||
(MaxLengthValidator(10), 10 * "x", None),
|
||
(MaxLengthValidator(10), 15 * "x", ValidationError),
|
||
(MinLengthValidator(10), 15 * "x", None),
|
||
(MinLengthValidator(10), 10 * "x", None),
|
||
(MinLengthValidator(10), "", ValidationError),
|
||
(StepValueValidator(3), 1, ValidationError),
|
||
(StepValueValidator(3), 8, ValidationError),
|
||
(StepValueValidator(3), 9, None),
|
||
(StepValueValidator(2), 4, None),
|
||
(StepValueValidator(2, offset=1), 3, None),
|
||
(StepValueValidator(2, offset=1), 4, ValidationError),
|
||
(StepValueValidator(0.001), 0.55, None),
|
||
(StepValueValidator(0.001), 0.5555, ValidationError),
|
||
(StepValueValidator(0.001, offset=0.0005), 0.5555, None),
|
||
(StepValueValidator(0.001, offset=0.0005), 0.555, ValidationError),
|
||
(StepValueValidator(Decimal(0.02)), 0.88, None),
|
||
(StepValueValidator(Decimal(0.02)), Decimal(0.88), None),
|
||
(StepValueValidator(Decimal(0.02)), Decimal(0.77), ValidationError),
|
||
(StepValueValidator(Decimal(0.02), offset=Decimal(0.01)), Decimal(0.77), None),
|
||
(StepValueValidator(Decimal(2.0), offset=Decimal(0.1)), Decimal(0.1), None),
|
||
(
|
||
StepValueValidator(Decimal(0.02), offset=Decimal(0.01)),
|
||
Decimal(0.88),
|
||
ValidationError,
|
||
),
|
||
(StepValueValidator(Decimal("1.2"), offset=Decimal("2.2")), Decimal("3.4"), None),
|
||
(
|
||
StepValueValidator(Decimal("1.2"), offset=Decimal("2.2")),
|
||
Decimal("1.2"),
|
||
ValidationError,
|
||
),
|
||
(
|
||
StepValueValidator(Decimal("-1.2"), offset=Decimal("2.2")),
|
||
Decimal("1.1"),
|
||
ValidationError,
|
||
),
|
||
(
|
||
StepValueValidator(Decimal("-1.2"), offset=Decimal("2.2")),
|
||
Decimal("1.0"),
|
||
None,
|
||
),
|
||
(URLValidator(EXTENDED_SCHEMES), "file://localhost/path", None),
|
||
(URLValidator(EXTENDED_SCHEMES), "git://example.com/", None),
|
||
(
|
||
URLValidator(EXTENDED_SCHEMES),
|
||
"git+ssh://git@github.com/example/hg-git.git",
|
||
None,
|
||
),
|
||
(URLValidator(EXTENDED_SCHEMES), "git://-invalid.com", ValidationError),
|
||
(BaseValidator(True), True, None),
|
||
(BaseValidator(True), False, ValidationError),
|
||
(RegexValidator(), "", None),
|
||
(RegexValidator(), "x1x2", None),
|
||
(RegexValidator("[0-9]+"), "xxxxxx", ValidationError),
|
||
(RegexValidator("[0-9]+"), "1234", None),
|
||
(RegexValidator(re.compile("[0-9]+")), "1234", None),
|
||
(RegexValidator(".*"), "", None),
|
||
(RegexValidator(re.compile(".*")), "", None),
|
||
(RegexValidator(".*"), "xxxxx", None),
|
||
(RegexValidator("x"), "y", ValidationError),
|
||
(RegexValidator(re.compile("x")), "y", ValidationError),
|
||
(RegexValidator("x", inverse_match=True), "y", None),
|
||
(RegexValidator(re.compile("x"), inverse_match=True), "y", None),
|
||
(RegexValidator("x", inverse_match=True), "x", ValidationError),
|
||
(RegexValidator(re.compile("x"), inverse_match=True), "x", ValidationError),
|
||
(RegexValidator("x", flags=re.IGNORECASE), "y", ValidationError),
|
||
(RegexValidator("a"), "A", ValidationError),
|
||
(RegexValidator("a", flags=re.IGNORECASE), "A", None),
|
||
(
|
||
FileExtensionValidator(["txt"]),
|
||
ContentFile("contents", name="fileWithUnsupportedExt.jpg"),
|
||
ValidationError,
|
||
),
|
||
(
|
||
FileExtensionValidator(["txt"]),
|
||
ContentFile("contents", name="fileWithUnsupportedExt.JPG"),
|
||
ValidationError,
|
||
),
|
||
(
|
||
FileExtensionValidator(["txt"]),
|
||
ContentFile("contents", name="fileWithNoExtension"),
|
||
ValidationError,
|
||
),
|
||
(
|
||
FileExtensionValidator([""]),
|
||
ContentFile("contents", name="fileWithAnExtension.txt"),
|
||
ValidationError,
|
||
),
|
||
(
|
||
FileExtensionValidator([]),
|
||
ContentFile("contents", name="file.txt"),
|
||
ValidationError,
|
||
),
|
||
(
|
||
FileExtensionValidator([""]),
|
||
ContentFile("contents", name="fileWithNoExtension"),
|
||
None,
|
||
),
|
||
(FileExtensionValidator(["txt"]), ContentFile("contents", name="file.txt"), None),
|
||
(FileExtensionValidator(["txt"]), ContentFile("contents", name="file.TXT"), None),
|
||
(FileExtensionValidator(["TXT"]), ContentFile("contents", name="file.txt"), None),
|
||
(FileExtensionValidator(), ContentFile("contents", name="file.jpg"), None),
|
||
(DecimalValidator(max_digits=2, decimal_places=2), Decimal("0.99"), None),
|
||
(
|
||
DecimalValidator(max_digits=2, decimal_places=1),
|
||
Decimal("0.99"),
|
||
ValidationError,
|
||
),
|
||
(DecimalValidator(max_digits=3, decimal_places=1), Decimal("999"), ValidationError),
|
||
(DecimalValidator(max_digits=4, decimal_places=1), Decimal("999"), None),
|
||
(
|
||
DecimalValidator(max_digits=20, decimal_places=2),
|
||
Decimal("742403889818000000"),
|
||
None,
|
||
),
|
||
(DecimalValidator(20, 2), Decimal("7.42403889818E+17"), None),
|
||
(
|
||
DecimalValidator(max_digits=20, decimal_places=2),
|
||
Decimal("7424742403889818000000"),
|
||
ValidationError,
|
||
),
|
||
(DecimalValidator(max_digits=5, decimal_places=2), Decimal("7304E-1"), None),
|
||
(
|
||
DecimalValidator(max_digits=5, decimal_places=2),
|
||
Decimal("7304E-3"),
|
||
ValidationError,
|
||
),
|
||
(DecimalValidator(max_digits=5, decimal_places=5), Decimal("70E-5"), None),
|
||
(
|
||
DecimalValidator(max_digits=5, decimal_places=5),
|
||
Decimal("70E-6"),
|
||
ValidationError,
|
||
),
|
||
(DecimalValidator(max_digits=2, decimal_places=1), Decimal("0E+1"), None),
|
||
# 'Enter a number.' errors
|
||
*[
|
||
(
|
||
DecimalValidator(decimal_places=2, max_digits=10),
|
||
Decimal(value),
|
||
ValidationError,
|
||
)
|
||
for value in (
|
||
"NaN",
|
||
"-NaN",
|
||
"+NaN",
|
||
"sNaN",
|
||
"-sNaN",
|
||
"+sNaN",
|
||
"Inf",
|
||
"-Inf",
|
||
"+Inf",
|
||
"Infinity",
|
||
"-Infinity",
|
||
"+Infinity",
|
||
)
|
||
],
|
||
(validate_image_file_extension, ContentFile("contents", name="file.jpg"), None),
|
||
(validate_image_file_extension, ContentFile("contents", name="file.png"), None),
|
||
(validate_image_file_extension, ContentFile("contents", name="file.PNG"), None),
|
||
(
|
||
validate_image_file_extension,
|
||
ContentFile("contents", name="file.txt"),
|
||
ValidationError,
|
||
),
|
||
(
|
||
validate_image_file_extension,
|
||
ContentFile("contents", name="file"),
|
||
ValidationError,
|
||
),
|
||
(ProhibitNullCharactersValidator(), "\x00something", ValidationError),
|
||
(ProhibitNullCharactersValidator(), "something", None),
|
||
(ProhibitNullCharactersValidator(), None, None),
|
||
(validate_domain_name, "000000.org", None),
|
||
(validate_domain_name, "python.org", None),
|
||
(validate_domain_name, "python.co.uk", None),
|
||
(validate_domain_name, "python.tk", None),
|
||
(validate_domain_name, "domain.with.idn.tld.उदाहरण.परीक्ष", None),
|
||
(validate_domain_name, "ıçğü.com", None),
|
||
(validate_domain_name, "xn--7ca6byfyc.com", None),
|
||
(validate_domain_name, "hg.python.org", None),
|
||
(validate_domain_name, "python.xyz", None),
|
||
(validate_domain_name, "djangoproject.com", None),
|
||
(validate_domain_name, "DJANGOPROJECT.COM", None),
|
||
(validate_domain_name, "spam.eggs", None),
|
||
(validate_domain_name, "python-python.com", None),
|
||
(validate_domain_name, "python.name.uk", None),
|
||
(validate_domain_name, "python.tips", None),
|
||
(validate_domain_name, "http://例子.测试", None),
|
||
(validate_domain_name, "http://dashinpunytld.xn---c", None),
|
||
(validate_domain_name, "python..org", ValidationError),
|
||
(validate_domain_name, "python-.org", ValidationError),
|
||
(validate_domain_name, "too-long-name." * 20 + "com", ValidationError),
|
||
(validate_domain_name, "stupid-name试", ValidationError),
|
||
(validate_domain_name, "255.0.0.0", ValidationError),
|
||
(validate_domain_name, "fe80::1", ValidationError),
|
||
(validate_domain_name, "1:2:3:4:5:6:7:8", ValidationError),
|
||
(DomainNameValidator(accept_idna=False), "non-idna-domain-name-passes.com", None),
|
||
(
|
||
DomainNameValidator(accept_idna=False),
|
||
"domain.with.idn.tld.उदाहरण.परीक्ष",
|
||
ValidationError,
|
||
),
|
||
(DomainNameValidator(accept_idna=False), "ıçğü.com", ValidationError),
|
||
(DomainNameValidator(accept_idna=False), "not-domain-name", ValidationError),
|
||
]
|
||
|
||
# Add valid and invalid URL tests.
|
||
# This only tests the validator without extended schemes.
|
||
TEST_DATA.extend((URLValidator(), url, None) for url in VALID_URLS)
|
||
TEST_DATA.extend((URLValidator(), url, ValidationError) for url in INVALID_URLS)
|
||
|
||
|
||
class TestValidators(SimpleTestCase):
|
||
def test_validators(self):
|
||
for validator, value, expected in TEST_DATA:
|
||
name = (
|
||
validator.__name__
|
||
if isinstance(validator, types.FunctionType)
|
||
else validator.__class__.__name__
|
||
)
|
||
exception_expected = expected is not None and issubclass(
|
||
expected, Exception
|
||
)
|
||
with self.subTest(name, value=value):
|
||
if (
|
||
validator is validate_image_file_extension
|
||
and not PILLOW_IS_INSTALLED
|
||
):
|
||
self.skipTest(
|
||
"Pillow is required to test validate_image_file_extension."
|
||
)
|
||
if exception_expected:
|
||
with self.assertRaises(expected):
|
||
validator(value)
|
||
else:
|
||
self.assertEqual(expected, validator(value))
|
||
|
||
def test_single_message(self):
|
||
v = ValidationError("Not Valid")
|
||
self.assertEqual(str(v), "['Not Valid']")
|
||
self.assertEqual(repr(v), "ValidationError(['Not Valid'])")
|
||
|
||
def test_message_list(self):
|
||
v = ValidationError(["First Problem", "Second Problem"])
|
||
self.assertEqual(str(v), "['First Problem', 'Second Problem']")
|
||
self.assertEqual(
|
||
repr(v), "ValidationError(['First Problem', 'Second Problem'])"
|
||
)
|
||
|
||
def test_message_dict(self):
|
||
v = ValidationError({"first": ["First Problem"]})
|
||
self.assertEqual(str(v), "{'first': ['First Problem']}")
|
||
self.assertEqual(repr(v), "ValidationError({'first': ['First Problem']})")
|
||
|
||
def test_regex_validator_flags(self):
|
||
msg = "If the flags are set, regex must be a regular expression string."
|
||
with self.assertRaisesMessage(TypeError, msg):
|
||
RegexValidator(re.compile("a"), flags=re.IGNORECASE)
|
||
|
||
def test_max_length_validator_message(self):
|
||
v = MaxLengthValidator(
|
||
16, message='"%(value)s" has more than %(limit_value)d characters.'
|
||
)
|
||
with self.assertRaisesMessage(
|
||
ValidationError, '"djangoproject.com" has more than 16 characters.'
|
||
):
|
||
v("djangoproject.com")
|
||
|
||
|
||
class TestValidatorEquality(TestCase):
|
||
"""
|
||
Validators have valid equality operators (#21638)
|
||
"""
|
||
|
||
def test_regex_equality(self):
|
||
self.assertEqual(
|
||
RegexValidator(r"^(?:[a-z0-9.-]*)://"),
|
||
RegexValidator(r"^(?:[a-z0-9.-]*)://"),
|
||
)
|
||
self.assertNotEqual(
|
||
RegexValidator(r"^(?:[a-z0-9.-]*)://"),
|
||
RegexValidator(r"^(?:[0-9.-]*)://"),
|
||
)
|
||
self.assertEqual(
|
||
RegexValidator(r"^(?:[a-z0-9.-]*)://", "oh noes", "invalid"),
|
||
RegexValidator(r"^(?:[a-z0-9.-]*)://", "oh noes", "invalid"),
|
||
)
|
||
self.assertNotEqual(
|
||
RegexValidator(r"^(?:[a-z0-9.-]*)://", "oh", "invalid"),
|
||
RegexValidator(r"^(?:[a-z0-9.-]*)://", "oh noes", "invalid"),
|
||
)
|
||
self.assertNotEqual(
|
||
RegexValidator(r"^(?:[a-z0-9.-]*)://", "oh noes", "invalid"),
|
||
RegexValidator(r"^(?:[a-z0-9.-]*)://"),
|
||
)
|
||
|
||
self.assertNotEqual(
|
||
RegexValidator("", flags=re.IGNORECASE),
|
||
RegexValidator(""),
|
||
)
|
||
|
||
self.assertNotEqual(
|
||
RegexValidator(""),
|
||
RegexValidator("", inverse_match=True),
|
||
)
|
||
|
||
def test_regex_equality_nocache(self):
|
||
pattern = r"^(?:[a-z0-9.-]*)://"
|
||
left = RegexValidator(pattern)
|
||
re.purge()
|
||
right = RegexValidator(pattern)
|
||
|
||
self.assertEqual(
|
||
left,
|
||
right,
|
||
)
|
||
|
||
def test_regex_equality_blank(self):
|
||
self.assertEqual(
|
||
RegexValidator(),
|
||
RegexValidator(),
|
||
)
|
||
|
||
def test_email_equality(self):
|
||
self.assertEqual(
|
||
EmailValidator(),
|
||
EmailValidator(),
|
||
)
|
||
self.assertNotEqual(
|
||
EmailValidator(message="BAD EMAIL"),
|
||
EmailValidator(),
|
||
)
|
||
self.assertEqual(
|
||
EmailValidator(message="BAD EMAIL", code="bad"),
|
||
EmailValidator(message="BAD EMAIL", code="bad"),
|
||
)
|
||
self.assertEqual(
|
||
EmailValidator(allowlist=["127.0.0.1", "localhost"]),
|
||
EmailValidator(allowlist=["localhost", "127.0.0.1"]),
|
||
)
|
||
|
||
def test_basic_equality(self):
|
||
self.assertEqual(
|
||
MaxValueValidator(44),
|
||
MaxValueValidator(44),
|
||
)
|
||
self.assertEqual(MaxValueValidator(44), mock.ANY)
|
||
self.assertEqual(
|
||
StepValueValidator(0.003),
|
||
StepValueValidator(0.003),
|
||
)
|
||
self.assertNotEqual(
|
||
MaxValueValidator(44),
|
||
MinValueValidator(44),
|
||
)
|
||
self.assertNotEqual(
|
||
MinValueValidator(45),
|
||
MinValueValidator(11),
|
||
)
|
||
self.assertNotEqual(
|
||
StepValueValidator(3),
|
||
StepValueValidator(2),
|
||
)
|
||
|
||
def test_decimal_equality(self):
|
||
self.assertEqual(
|
||
DecimalValidator(1, 2),
|
||
DecimalValidator(1, 2),
|
||
)
|
||
self.assertNotEqual(
|
||
DecimalValidator(1, 2),
|
||
DecimalValidator(1, 1),
|
||
)
|
||
self.assertNotEqual(
|
||
DecimalValidator(1, 2),
|
||
DecimalValidator(2, 2),
|
||
)
|
||
self.assertNotEqual(
|
||
DecimalValidator(1, 2),
|
||
MinValueValidator(11),
|
||
)
|
||
|
||
def test_file_extension_equality(self):
|
||
self.assertEqual(FileExtensionValidator(), FileExtensionValidator())
|
||
self.assertEqual(
|
||
FileExtensionValidator(["txt"]), FileExtensionValidator(["txt"])
|
||
)
|
||
self.assertEqual(
|
||
FileExtensionValidator(["TXT"]), FileExtensionValidator(["txt"])
|
||
)
|
||
self.assertEqual(
|
||
FileExtensionValidator(["TXT", "png"]),
|
||
FileExtensionValidator(["txt", "png"]),
|
||
)
|
||
self.assertEqual(
|
||
FileExtensionValidator(["jpg", "png", "txt"]),
|
||
FileExtensionValidator(["txt", "jpg", "png"]),
|
||
)
|
||
self.assertEqual(
|
||
FileExtensionValidator(["txt"]),
|
||
FileExtensionValidator(["txt"], code="invalid_extension"),
|
||
)
|
||
self.assertNotEqual(
|
||
FileExtensionValidator(["txt"]), FileExtensionValidator(["png"])
|
||
)
|
||
self.assertNotEqual(
|
||
FileExtensionValidator(["txt"]), FileExtensionValidator(["png", "jpg"])
|
||
)
|
||
self.assertNotEqual(
|
||
FileExtensionValidator(["txt"]),
|
||
FileExtensionValidator(["txt"], code="custom_code"),
|
||
)
|
||
self.assertNotEqual(
|
||
FileExtensionValidator(["txt"]),
|
||
FileExtensionValidator(["txt"], message="custom error message"),
|
||
)
|
||
|
||
def test_prohibit_null_characters_validator_equality(self):
|
||
self.assertEqual(
|
||
ProhibitNullCharactersValidator(message="message", code="code"),
|
||
ProhibitNullCharactersValidator(message="message", code="code"),
|
||
)
|
||
self.assertEqual(
|
||
ProhibitNullCharactersValidator(), ProhibitNullCharactersValidator()
|
||
)
|
||
self.assertNotEqual(
|
||
ProhibitNullCharactersValidator(message="message1", code="code"),
|
||
ProhibitNullCharactersValidator(message="message2", code="code"),
|
||
)
|
||
self.assertNotEqual(
|
||
ProhibitNullCharactersValidator(message="message", code="code1"),
|
||
ProhibitNullCharactersValidator(message="message", code="code2"),
|
||
)
|
||
|
||
def test_domain_name_equality(self):
|
||
self.assertEqual(
|
||
DomainNameValidator(),
|
||
DomainNameValidator(),
|
||
)
|
||
self.assertNotEqual(
|
||
DomainNameValidator(),
|
||
EmailValidator(),
|
||
)
|
||
self.assertNotEqual(
|
||
DomainNameValidator(),
|
||
DomainNameValidator(code="custom_code"),
|
||
)
|
||
self.assertEqual(
|
||
DomainNameValidator(message="custom error message"),
|
||
DomainNameValidator(message="custom error message"),
|
||
)
|
||
self.assertNotEqual(
|
||
DomainNameValidator(message="custom error message"),
|
||
DomainNameValidator(message="custom error message", code="custom_code"),
|
||
)
|