1 """

     2 A test spanning all the capabilities of all the serializers.

     3 

     4 This class sets up a model for each model field type

     5 (except for image types, because of the PIL dependency).

     6 """

     7 

     8 from django.db import models

     9 from django.contrib.contenttypes import generic

    10 from django.contrib.contenttypes.models import ContentType

    11 from django.contrib.localflavor.us.models import USStateField, PhoneNumberField

    12 

    13 # The following classes are for testing basic data

    14 # marshalling, including NULL values, where allowed.

    15 

    16 class BooleanData(models.Model):

    17     data = models.BooleanField()

    18 

    19 class CharData(models.Model):

    20     data = models.CharField(max_length=30, null=True)

    21 

    22 class DateData(models.Model):

    23     data = models.DateField(null=True)

    24 

    25 class DateTimeData(models.Model):

    26     data = models.DateTimeField(null=True)

    27 

    28 class DecimalData(models.Model):

    29     data = models.DecimalField(null=True, decimal_places=3, max_digits=5)

    30 

    31 class EmailData(models.Model):

    32     data = models.EmailField(null=True)

    33 

    34 class FileData(models.Model):

    35     data = models.FileField(null=True, upload_to='/foo/bar')

    36 

    37 class FilePathData(models.Model):

    38     data = models.FilePathField(null=True)

    39 

    40 class FloatData(models.Model):

    41     data = models.FloatField(null=True)

    42 

    43 class IntegerData(models.Model):

    44     data = models.IntegerField(null=True)

    45 

    46 class BigIntegerData(models.Model):

    47     data = models.BigIntegerField(null=True)

    48 

    49 # class ImageData(models.Model):

    50 #    data = models.ImageField(null=True)

    51 

    52 class IPAddressData(models.Model):

    53     data = models.IPAddressField(null=True)

    54 

    55 class NullBooleanData(models.Model):

    56     data = models.NullBooleanField(null=True)

    57 

    58 class PhoneData(models.Model):

    59     data = PhoneNumberField(null=True)

    60 

    61 class PositiveIntegerData(models.Model):

    62     data = models.PositiveIntegerField(null=True)

    63 

    64 class PositiveSmallIntegerData(models.Model):

    65     data = models.PositiveSmallIntegerField(null=True)

    66 

    67 class SlugData(models.Model):

    68     data = models.SlugField(null=True)

    69 

    70 class SmallData(models.Model):

    71     data = models.SmallIntegerField(null=True)

    72 

    73 class TextData(models.Model):

    74     data = models.TextField(null=True)

    75 

    76 class TimeData(models.Model):

    77     data = models.TimeField(null=True)

    78 

    79 class USStateData(models.Model):

    80     data = USStateField(null=True)

    81 

    82 class XMLData(models.Model):

    83     data = models.XMLField(null=True)

    84 

    85 class Tag(models.Model):

    86     """A tag on an item."""

    87     data = models.SlugField()

    88     content_type = models.ForeignKey(ContentType)

    89     object_id = models.PositiveIntegerField()

    90 

    91     content_object = generic.GenericForeignKey()

    92 

    93     class Meta:

    94         ordering = ["data"]

    95 

    96 class GenericData(models.Model):

    97     data = models.CharField(max_length=30)

    98 

    99     tags = generic.GenericRelation(Tag)

   100 

   101 # The following test classes are all for validation

   102 # of related objects; in particular, forward, backward,

   103 # and self references.

   104 

   105 class Anchor(models.Model):

   106     """This is a model that can be used as

   107     something for other models to point at"""

   108 

   109     data = models.CharField(max_length=30)

   110 

   111     class Meta:

   112         ordering = ('id',)

   113 

   114 class UniqueAnchor(models.Model):

   115     """This is a model that can be used as

   116     something for other models to point at"""

   117 

   118     data = models.CharField(unique=True, max_length=30)

   119 

   120 class FKData(models.Model):

   121     data = models.ForeignKey(Anchor, null=True)

   122 

   123 class M2MData(models.Model):

   124     data = models.ManyToManyField(Anchor, null=True)

   125 

   126 class O2OData(models.Model):

   127     # One to one field can't be null here, since it is a PK.

   128     data = models.OneToOneField(Anchor, primary_key=True)

   129 

   130 class FKSelfData(models.Model):

   131     data = models.ForeignKey('self', null=True)

   132 

   133 class M2MSelfData(models.Model):

   134     data = models.ManyToManyField('self', null=True, symmetrical=False)

   135 

   136 class FKDataToField(models.Model):

   137     data = models.ForeignKey(UniqueAnchor, null=True, to_field='data')

   138 

   139 class FKDataToO2O(models.Model):

   140     data = models.ForeignKey(O2OData, null=True)

   141 

   142 class M2MIntermediateData(models.Model):

   143     data = models.ManyToManyField(Anchor, null=True, through='Intermediate')

   144 

   145 class Intermediate(models.Model):

   146     left = models.ForeignKey(M2MIntermediateData)

   147     right = models.ForeignKey(Anchor)

   148     extra = models.CharField(max_length=30, blank=True, default="doesn't matter")

   149 

   150 # The following test classes are for validating the

   151 # deserialization of objects that use a user-defined

   152 # field as the primary key.

   153 # Some of these data types have been commented out

   154 # because they can't be used as a primary key on one

   155 # or all database backends.

   156 

   157 class BooleanPKData(models.Model):

   158     data = models.BooleanField(primary_key=True)

   159 

   160 class CharPKData(models.Model):

   161     data = models.CharField(max_length=30, primary_key=True)

   162 

   163 # class DatePKData(models.Model):

   164 #    data = models.DateField(primary_key=True)

   165 

   166 # class DateTimePKData(models.Model):

   167 #    data = models.DateTimeField(primary_key=True)

   168 

   169 class DecimalPKData(models.Model):

   170     data = models.DecimalField(primary_key=True, decimal_places=3, max_digits=5)

   171 

   172 class EmailPKData(models.Model):

   173     data = models.EmailField(primary_key=True)

   174 

   175 # class FilePKData(models.Model):

   176 #    data = models.FileField(primary_key=True, upload_to='/foo/bar')

   177 

   178 class FilePathPKData(models.Model):

   179     data = models.FilePathField(primary_key=True)

   180 

   181 class FloatPKData(models.Model):

   182     data = models.FloatField(primary_key=True)

   183 

   184 class IntegerPKData(models.Model):

   185     data = models.IntegerField(primary_key=True)

   186 

   187 # class ImagePKData(models.Model):

   188 #    data = models.ImageField(primary_key=True)

   189 

   190 class IPAddressPKData(models.Model):

   191     data = models.IPAddressField(primary_key=True)

   192 

   193 # This is just a Boolean field with null=True, and we can't test a PK value of NULL.

   194 # class NullBooleanPKData(models.Model):

   195 #     data = models.NullBooleanField(primary_key=True)

   196 

   197 class PhonePKData(models.Model):

   198     data = PhoneNumberField(primary_key=True)

   199 

   200 class PositiveIntegerPKData(models.Model):

   201     data = models.PositiveIntegerField(primary_key=True)

   202 

   203 class PositiveSmallIntegerPKData(models.Model):

   204     data = models.PositiveSmallIntegerField(primary_key=True)

   205 

   206 class SlugPKData(models.Model):

   207     data = models.SlugField(primary_key=True)

   208 

   209 class SmallPKData(models.Model):

   210     data = models.SmallIntegerField(primary_key=True)

   211 

   212 # class TextPKData(models.Model):

   213 #     data = models.TextField(primary_key=True)

   214 

   215 # class TimePKData(models.Model):

   216 #    data = models.TimeField(primary_key=True)

   217 

   218 class USStatePKData(models.Model):

   219     data = USStateField(primary_key=True)

   220 

   221 # class XMLPKData(models.Model):

   222 #     data = models.XMLField(primary_key=True)

   223 

   224 class ComplexModel(models.Model):

   225     field1 = models.CharField(max_length=10)

   226     field2 = models.CharField(max_length=10)

   227     field3 = models.CharField(max_length=10)

   228 

   229 # Tests for handling fields with pre_save functions, or

   230 # models with save functions that modify data

   231 class AutoNowDateTimeData(models.Model):

   232     data = models.DateTimeField(null=True, auto_now=True)

   233 

   234 class ModifyingSaveData(models.Model):

   235     data = models.IntegerField(null=True)

   236 

   237     def save(self):

   238         "A save method that modifies the data in the object"

   239         self.data = 666

   240         super(ModifyingSaveData, self).save(raw)

   241 

   242 # Tests for serialization of models using inheritance.

   243 # Regression for #7202, #7350

   244 class AbstractBaseModel(models.Model):

   245     parent_data = models.IntegerField()

   246     class Meta:

   247         abstract = True

   248 

   249 class InheritAbstractModel(AbstractBaseModel):

   250     child_data = models.IntegerField()

   251 

   252 class BaseModel(models.Model):

   253     parent_data = models.IntegerField()

   254 

   255 class InheritBaseModel(BaseModel):

   256     child_data = models.IntegerField()

   257 

   258 class ExplicitInheritBaseModel(BaseModel):

   259     parent = models.OneToOneField(BaseModel)

   260     child_data = models.IntegerField()

   261 

   262 class LengthModel(models.Model):

   263     data = models.IntegerField()

   264 

   265     def __len__(self):

   266         return self.data