445 lines
13 KiB
Python
445 lines
13 KiB
Python
import json
|
|
import os
|
|
import tempfile
|
|
import uuid
|
|
|
|
from django.contrib.contenttypes.fields import (
|
|
GenericForeignKey, GenericRelation,
|
|
)
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from django.core.files.storage import FileSystemStorage
|
|
from django.core.serializers.json import DjangoJSONEncoder
|
|
from django.db import models
|
|
from django.db.models.fields.files import ImageFieldFile
|
|
from django.utils.translation import gettext_lazy as _
|
|
|
|
try:
|
|
from PIL import Image
|
|
except ImportError:
|
|
Image = None
|
|
|
|
|
|
class Foo(models.Model):
|
|
a = models.CharField(max_length=10)
|
|
d = models.DecimalField(max_digits=5, decimal_places=3)
|
|
|
|
|
|
def get_foo():
|
|
return Foo.objects.get(id=1).pk
|
|
|
|
|
|
class Bar(models.Model):
|
|
b = models.CharField(max_length=10)
|
|
a = models.ForeignKey(Foo, models.CASCADE, default=get_foo, related_name='bars')
|
|
|
|
|
|
class Whiz(models.Model):
|
|
CHOICES = (
|
|
('Group 1', (
|
|
(1, 'First'),
|
|
(2, 'Second'),
|
|
)
|
|
),
|
|
('Group 2', (
|
|
(3, 'Third'),
|
|
(4, 'Fourth'),
|
|
)
|
|
),
|
|
(0, 'Other'),
|
|
(5, _('translated')),
|
|
)
|
|
c = models.IntegerField(choices=CHOICES, null=True)
|
|
|
|
|
|
class WhizDelayed(models.Model):
|
|
c = models.IntegerField(choices=(), null=True)
|
|
|
|
|
|
# Contrived way of adding choices later.
|
|
WhizDelayed._meta.get_field('c').choices = Whiz.CHOICES
|
|
|
|
|
|
class WhizIter(models.Model):
|
|
c = models.IntegerField(choices=iter(Whiz.CHOICES), null=True)
|
|
|
|
|
|
class WhizIterEmpty(models.Model):
|
|
c = models.CharField(choices=iter(()), blank=True, max_length=1)
|
|
|
|
|
|
class Choiceful(models.Model):
|
|
no_choices = models.IntegerField(null=True)
|
|
empty_choices = models.IntegerField(choices=(), null=True)
|
|
with_choices = models.IntegerField(choices=[(1, 'A')], null=True)
|
|
empty_choices_bool = models.BooleanField(choices=())
|
|
empty_choices_text = models.TextField(choices=())
|
|
|
|
|
|
class BigD(models.Model):
|
|
d = models.DecimalField(max_digits=32, decimal_places=30)
|
|
|
|
|
|
class FloatModel(models.Model):
|
|
size = models.FloatField()
|
|
|
|
|
|
class BigS(models.Model):
|
|
s = models.SlugField(max_length=255)
|
|
|
|
|
|
class UnicodeSlugField(models.Model):
|
|
s = models.SlugField(max_length=255, allow_unicode=True)
|
|
|
|
|
|
class AutoModel(models.Model):
|
|
value = models.AutoField(primary_key=True)
|
|
|
|
|
|
class BigAutoModel(models.Model):
|
|
value = models.BigAutoField(primary_key=True)
|
|
|
|
|
|
class SmallAutoModel(models.Model):
|
|
value = models.SmallAutoField(primary_key=True)
|
|
|
|
|
|
class SmallIntegerModel(models.Model):
|
|
value = models.SmallIntegerField()
|
|
|
|
|
|
class IntegerModel(models.Model):
|
|
value = models.IntegerField()
|
|
|
|
|
|
class BigIntegerModel(models.Model):
|
|
value = models.BigIntegerField()
|
|
null_value = models.BigIntegerField(null=True, blank=True)
|
|
|
|
|
|
class PositiveBigIntegerModel(models.Model):
|
|
value = models.PositiveBigIntegerField()
|
|
|
|
|
|
class PositiveSmallIntegerModel(models.Model):
|
|
value = models.PositiveSmallIntegerField()
|
|
|
|
|
|
class PositiveIntegerModel(models.Model):
|
|
value = models.PositiveIntegerField()
|
|
|
|
|
|
class Post(models.Model):
|
|
title = models.CharField(max_length=100)
|
|
body = models.TextField()
|
|
|
|
|
|
class NullBooleanModel(models.Model):
|
|
nbfield = models.BooleanField(null=True, blank=True)
|
|
|
|
|
|
class BooleanModel(models.Model):
|
|
bfield = models.BooleanField()
|
|
string = models.CharField(max_length=10, default='abc')
|
|
|
|
|
|
class DateTimeModel(models.Model):
|
|
d = models.DateField()
|
|
dt = models.DateTimeField()
|
|
t = models.TimeField()
|
|
|
|
|
|
class DurationModel(models.Model):
|
|
field = models.DurationField()
|
|
|
|
|
|
class NullDurationModel(models.Model):
|
|
field = models.DurationField(null=True)
|
|
|
|
|
|
class PrimaryKeyCharModel(models.Model):
|
|
string = models.CharField(max_length=10, primary_key=True)
|
|
|
|
|
|
class FksToBooleans(models.Model):
|
|
"""Model with FKs to models with {Null,}BooleanField's, #15040"""
|
|
bf = models.ForeignKey(BooleanModel, models.CASCADE)
|
|
nbf = models.ForeignKey(NullBooleanModel, models.CASCADE)
|
|
|
|
|
|
class FkToChar(models.Model):
|
|
"""Model with FK to a model with a CharField primary key, #19299"""
|
|
out = models.ForeignKey(PrimaryKeyCharModel, models.CASCADE)
|
|
|
|
|
|
class RenamedField(models.Model):
|
|
modelname = models.IntegerField(name="fieldname", choices=((1, 'One'),))
|
|
|
|
|
|
class VerboseNameField(models.Model):
|
|
id = models.AutoField("verbose pk", primary_key=True)
|
|
field1 = models.BigIntegerField("verbose field1")
|
|
field2 = models.BooleanField("verbose field2", default=False)
|
|
field3 = models.CharField("verbose field3", max_length=10)
|
|
field4 = models.DateField("verbose field4")
|
|
field5 = models.DateTimeField("verbose field5")
|
|
field6 = models.DecimalField("verbose field6", max_digits=6, decimal_places=1)
|
|
field7 = models.EmailField("verbose field7")
|
|
field8 = models.FileField("verbose field8", upload_to="unused")
|
|
field9 = models.FilePathField("verbose field9")
|
|
field10 = models.FloatField("verbose field10")
|
|
# Don't want to depend on Pillow in this test
|
|
# field_image = models.ImageField("verbose field")
|
|
field11 = models.IntegerField("verbose field11")
|
|
field12 = models.GenericIPAddressField("verbose field12", protocol="ipv4")
|
|
field13 = models.PositiveIntegerField("verbose field13")
|
|
field14 = models.PositiveSmallIntegerField("verbose field14")
|
|
field15 = models.SlugField("verbose field15")
|
|
field16 = models.SmallIntegerField("verbose field16")
|
|
field17 = models.TextField("verbose field17")
|
|
field18 = models.TimeField("verbose field18")
|
|
field19 = models.URLField("verbose field19")
|
|
field20 = models.UUIDField("verbose field20")
|
|
field21 = models.DurationField("verbose field21")
|
|
|
|
|
|
class GenericIPAddress(models.Model):
|
|
ip = models.GenericIPAddressField(null=True, protocol='ipv4')
|
|
|
|
|
|
###############################################################################
|
|
# These models aren't used in any test, just here to ensure they validate
|
|
# successfully.
|
|
|
|
# See ticket #16570.
|
|
class DecimalLessThanOne(models.Model):
|
|
d = models.DecimalField(max_digits=3, decimal_places=3)
|
|
|
|
|
|
# See ticket #18389.
|
|
class FieldClassAttributeModel(models.Model):
|
|
field_class = models.CharField
|
|
|
|
###############################################################################
|
|
|
|
|
|
class DataModel(models.Model):
|
|
short_data = models.BinaryField(max_length=10, default=b'\x08')
|
|
data = models.BinaryField()
|
|
|
|
###############################################################################
|
|
# FileField
|
|
|
|
|
|
class Document(models.Model):
|
|
myfile = models.FileField(upload_to='unused', unique=True)
|
|
|
|
|
|
###############################################################################
|
|
# ImageField
|
|
|
|
# If Pillow available, do these tests.
|
|
if Image:
|
|
class TestImageFieldFile(ImageFieldFile):
|
|
"""
|
|
Custom Field File class that records whether or not the underlying file
|
|
was opened.
|
|
"""
|
|
def __init__(self, *args, **kwargs):
|
|
self.was_opened = False
|
|
super().__init__(*args, **kwargs)
|
|
|
|
def open(self):
|
|
self.was_opened = True
|
|
super().open()
|
|
|
|
class TestImageField(models.ImageField):
|
|
attr_class = TestImageFieldFile
|
|
|
|
# Set up a temp directory for file storage.
|
|
temp_storage_dir = tempfile.mkdtemp()
|
|
temp_storage = FileSystemStorage(temp_storage_dir)
|
|
temp_upload_to_dir = os.path.join(temp_storage.location, 'tests')
|
|
|
|
class Person(models.Model):
|
|
"""
|
|
Model that defines an ImageField with no dimension fields.
|
|
"""
|
|
name = models.CharField(max_length=50)
|
|
mugshot = TestImageField(storage=temp_storage, upload_to='tests')
|
|
|
|
class AbstractPersonWithHeight(models.Model):
|
|
"""
|
|
Abstract model that defines an ImageField with only one dimension field
|
|
to make sure the dimension update is correctly run on concrete subclass
|
|
instance post-initialization.
|
|
"""
|
|
mugshot = TestImageField(storage=temp_storage, upload_to='tests',
|
|
height_field='mugshot_height')
|
|
mugshot_height = models.PositiveSmallIntegerField()
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
class PersonWithHeight(AbstractPersonWithHeight):
|
|
"""
|
|
Concrete model that subclass an abstract one with only on dimension
|
|
field.
|
|
"""
|
|
name = models.CharField(max_length=50)
|
|
|
|
class PersonWithHeightAndWidth(models.Model):
|
|
"""
|
|
Model that defines height and width fields after the ImageField.
|
|
"""
|
|
name = models.CharField(max_length=50)
|
|
mugshot = TestImageField(storage=temp_storage, upload_to='tests',
|
|
height_field='mugshot_height',
|
|
width_field='mugshot_width')
|
|
mugshot_height = models.PositiveSmallIntegerField()
|
|
mugshot_width = models.PositiveSmallIntegerField()
|
|
|
|
class PersonDimensionsFirst(models.Model):
|
|
"""
|
|
Model that defines height and width fields before the ImageField.
|
|
"""
|
|
name = models.CharField(max_length=50)
|
|
mugshot_height = models.PositiveSmallIntegerField()
|
|
mugshot_width = models.PositiveSmallIntegerField()
|
|
mugshot = TestImageField(storage=temp_storage, upload_to='tests',
|
|
height_field='mugshot_height',
|
|
width_field='mugshot_width')
|
|
|
|
class PersonTwoImages(models.Model):
|
|
"""
|
|
Model that:
|
|
* Defines two ImageFields
|
|
* Defines the height/width fields before the ImageFields
|
|
* Has a nullable ImageField
|
|
"""
|
|
name = models.CharField(max_length=50)
|
|
mugshot_height = models.PositiveSmallIntegerField()
|
|
mugshot_width = models.PositiveSmallIntegerField()
|
|
mugshot = TestImageField(storage=temp_storage, upload_to='tests',
|
|
height_field='mugshot_height',
|
|
width_field='mugshot_width')
|
|
headshot_height = models.PositiveSmallIntegerField(
|
|
blank=True, null=True)
|
|
headshot_width = models.PositiveSmallIntegerField(
|
|
blank=True, null=True)
|
|
headshot = TestImageField(blank=True, null=True,
|
|
storage=temp_storage, upload_to='tests',
|
|
height_field='headshot_height',
|
|
width_field='headshot_width')
|
|
|
|
|
|
class CustomJSONDecoder(json.JSONDecoder):
|
|
def __init__(self, object_hook=None, *args, **kwargs):
|
|
return super().__init__(object_hook=self.as_uuid, *args, **kwargs)
|
|
|
|
def as_uuid(self, dct):
|
|
if 'uuid' in dct:
|
|
dct['uuid'] = uuid.UUID(dct['uuid'])
|
|
return dct
|
|
|
|
|
|
class JSONModel(models.Model):
|
|
value = models.JSONField()
|
|
|
|
class Meta:
|
|
required_db_features = {'supports_json_field'}
|
|
|
|
|
|
class NullableJSONModel(models.Model):
|
|
value = models.JSONField(blank=True, null=True)
|
|
value_custom = models.JSONField(
|
|
encoder=DjangoJSONEncoder,
|
|
decoder=CustomJSONDecoder,
|
|
null=True,
|
|
)
|
|
|
|
class Meta:
|
|
required_db_features = {'supports_json_field'}
|
|
|
|
|
|
class RelatedJSONModel(models.Model):
|
|
value = models.JSONField()
|
|
json_model = models.ForeignKey(NullableJSONModel, models.CASCADE)
|
|
|
|
class Meta:
|
|
required_db_features = {'supports_json_field'}
|
|
|
|
|
|
class AllFieldsModel(models.Model):
|
|
big_integer = models.BigIntegerField()
|
|
binary = models.BinaryField()
|
|
boolean = models.BooleanField(default=False)
|
|
char = models.CharField(max_length=10)
|
|
date = models.DateField()
|
|
datetime = models.DateTimeField()
|
|
decimal = models.DecimalField(decimal_places=2, max_digits=2)
|
|
duration = models.DurationField()
|
|
email = models.EmailField()
|
|
file_path = models.FilePathField()
|
|
floatf = models.FloatField()
|
|
integer = models.IntegerField()
|
|
generic_ip = models.GenericIPAddressField()
|
|
positive_integer = models.PositiveIntegerField()
|
|
positive_small_integer = models.PositiveSmallIntegerField()
|
|
slug = models.SlugField()
|
|
small_integer = models.SmallIntegerField()
|
|
text = models.TextField()
|
|
time = models.TimeField()
|
|
url = models.URLField()
|
|
uuid = models.UUIDField()
|
|
|
|
fo = models.ForeignObject(
|
|
'self',
|
|
on_delete=models.CASCADE,
|
|
from_fields=['positive_integer'],
|
|
to_fields=['id'],
|
|
related_name='reverse'
|
|
)
|
|
fk = models.ForeignKey(
|
|
'self',
|
|
models.CASCADE,
|
|
related_name='reverse2'
|
|
)
|
|
m2m = models.ManyToManyField('self')
|
|
oto = models.OneToOneField('self', models.CASCADE)
|
|
|
|
object_id = models.PositiveIntegerField()
|
|
content_type = models.ForeignKey(ContentType, models.CASCADE)
|
|
gfk = GenericForeignKey()
|
|
gr = GenericRelation(DataModel)
|
|
|
|
|
|
class ManyToMany(models.Model):
|
|
m2m = models.ManyToManyField('self')
|
|
|
|
|
|
###############################################################################
|
|
|
|
|
|
class UUIDModel(models.Model):
|
|
field = models.UUIDField()
|
|
|
|
|
|
class NullableUUIDModel(models.Model):
|
|
field = models.UUIDField(blank=True, null=True)
|
|
|
|
|
|
class PrimaryKeyUUIDModel(models.Model):
|
|
id = models.UUIDField(primary_key=True, default=uuid.uuid4)
|
|
|
|
|
|
class RelatedToUUIDModel(models.Model):
|
|
uuid_fk = models.ForeignKey('PrimaryKeyUUIDModel', models.CASCADE)
|
|
|
|
|
|
class UUIDChild(PrimaryKeyUUIDModel):
|
|
pass
|
|
|
|
|
|
class UUIDGrandchild(UUIDChild):
|
|
pass
|