Skip to content
Browse files

[soc2009/admin-ui] Merging trunk r10924 into my branch.

git-svn-id: http://code.djangoproject.com/svn/django/branches/soc2009/admin-ui@10925 bcc190cf-cafb-0310-a4f2-bffc1f526a37
  • Loading branch information...
1 parent 6275888 commit 82b25800cdb8be78e8cfc95cca41e01a418ecc9c @zain zain committed
View
BIN django/conf/locale/es_AR/LC_MESSAGES/django.mo
Binary file not shown.
View
774 django/conf/locale/es_AR/LC_MESSAGES/django.po
499 additions, 275 deletions not shown because the diff is too large. Please use a local Git client to view these changes.
View
4 django/contrib/gis/db/models/sql/where.py
@@ -35,7 +35,7 @@ def add(self, data, connector):
return super(WhereNode, self).add(data, connector)
obj, lookup_type, value = data
- alias, col, field = obj.alias, obj.col, obj.field
+ col, field = obj.col, obj.field
if not hasattr(field, "geom_type"):
# Not a geographic field, so call `WhereNode.add`.
@@ -76,7 +76,7 @@ def add(self, data, connector):
# the `get_geo_where_clause` to construct the appropriate
# spatial SQL when `make_atom` is called.
annotation = GeoAnnotation(field, value, where)
- return super(WhereNode, self).add(((alias, col, field.db_type()), lookup_type, annotation, params), connector)
+ return super(WhereNode, self).add(((obj.alias, col, field.db_type()), lookup_type, annotation, params), connector)
def make_atom(self, child, qn):
obj, lookup_type, value_annot, params = child
View
6 django/contrib/gis/maps/google/gmap.py
@@ -143,7 +143,7 @@ def xhtml(self):
@property
def icons(self):
"Returns a sequence of GIcon objects in this map."
- return [marker.icon for marker in self.markers if marker.icon]
+ return set([marker.icon for marker in self.markers if marker.icon])
class GoogleMapSet(GoogleMap):
@@ -221,6 +221,6 @@ def onload(self):
@property
def icons(self):
"Returns a sequence of all icons in each map of the set."
- icons = []
- for map in self.maps: icons.extend(map.icons)
+ icons = set()
+ for map in self.maps: icons |= map.icons
return icons
View
8 django/contrib/gis/maps/google/overlays.py
@@ -231,6 +231,14 @@ def __init__(self, varname, image=None, iconsize=None,
self.iconanchor = iconanchor
self.infowindowanchor = infowindowanchor
+ def __cmp__(self, other):
+ return cmp(self.varname, other.varname)
+
+ def __hash__(self):
+ # XOR with hash of GIcon type so that hash('varname') won't
+ # equal hash(GIcon('varname')).
+ return hash(self.__class__) ^ hash(self.varname)
+
class GMarker(GOverlayBase):
"""
A Python wrapper for the Google GMarker object. For more information
View
10 django/contrib/gis/tests/relatedapp/models.py
@@ -32,3 +32,13 @@ class Parcel(models.Model):
border2 = models.PolygonField(srid=2276)
objects = models.GeoManager()
def __unicode__(self): return self.name
+
+# These use the GeoManager but do not have any geographic fields.
+class Author(models.Model):
+ name = models.CharField(max_length=100)
+ objects = models.GeoManager()
+
+class Book(models.Model):
+ title = models.CharField(max_length=100)
+ author = models.ForeignKey(Author, related_name='books')
+ objects = models.GeoManager()
View
34 django/contrib/gis/tests/relatedapp/tests.py
@@ -1,10 +1,10 @@
import os, unittest
from django.contrib.gis.geos import *
from django.contrib.gis.db.backend import SpatialBackend
-from django.contrib.gis.db.models import F, Extent, Union
+from django.contrib.gis.db.models import Count, Extent, F, Union
from django.contrib.gis.tests.utils import no_mysql, no_oracle, no_spatialite
from django.conf import settings
-from models import City, Location, DirectoryEntry, Parcel
+from models import City, Location, DirectoryEntry, Parcel, Book, Author
cities = (('Aurora', 'TX', -97.516111, 33.058333),
('Roswell', 'NM', -104.528056, 33.387222),
@@ -196,8 +196,8 @@ def test09_pk_relations(self):
# ID values do not match their City ID values.
loc1 = Location.objects.create(point='POINT (-95.363151 29.763374)')
loc2 = Location.objects.create(point='POINT (-96.801611 32.782057)')
- dallas = City.objects.create(name='Dallas', location=loc2)
- houston = City.objects.create(name='Houston', location=loc1)
+ dallas = City.objects.create(name='Dallas', state='TX', location=loc2)
+ houston = City.objects.create(name='Houston', state='TX', location=loc1)
# The expected ID values -- notice the last two location IDs
# are out of order. We want to make sure that the related
@@ -231,6 +231,32 @@ def test11_geoquery_pickle(self):
q = pickle.loads(q_str)
self.assertEqual(GeoQuery, q.__class__)
+ def test12_count(self):
+ "Testing `Count` aggregate use with the `GeoManager`. See #11087."
+ # Creating a new City, 'Fort Worth', that uses the same location
+ # as Dallas.
+ dallas = City.objects.get(name='Dallas')
+ ftworth = City.objects.create(name='Fort Worth', state='TX', location=dallas.location)
+
+ # Count annotation should be 2 for the Dallas location now.
+ loc = Location.objects.annotate(num_cities=Count('city')).get(id=dallas.location.id)
+ self.assertEqual(2, loc.num_cities)
+
+ # Creating some data for the Book/Author non-geo models that
+ # use GeoManager. See #11087.
+ tp = Author.objects.create(name='Trevor Paglen')
+ Book.objects.create(title='Torture Taxi', author=tp)
+ Book.objects.create(title='I Could Tell You But Then You Would Have to be Destroyed by Me', author=tp)
+ Book.objects.create(title='Blank Spots on the Map', author=tp)
+ wp = Author.objects.create(name='William Patry')
+ Book.objects.create(title='Patry on Copyright', author=wp)
+
+ # Should only be one author (Trevor Paglen) returned by this query, and
+ # the annotation should have 3 for the number of books.
+ qs = Author.objects.annotate(num_books=Count('books')).filter(num_books__gt=1)
+ self.assertEqual(1, len(qs))
+ self.assertEqual(3, qs[0].num_books)
+
# TODO: Related tests for KML, GML, and distance lookups.
def suite():
View
56 django/contrib/gis/utils/ogrinspect.py
@@ -12,12 +12,12 @@
def mapping(data_source, geom_name='geom', layer_key=0, multi_geom=False):
"""
- Given a DataSource, generates a dictionary that may be used
+ Given a DataSource, generates a dictionary that may be used
for invoking the LayerMapping utility.
Keyword Arguments:
`geom_name` => The name of the geometry field to use for the model.
-
+
`layer_key` => The key for specifying which layer in the DataSource to use;
defaults to 0 (the first layer). May be an integer index or a string
identifier for the layer.
@@ -31,7 +31,7 @@ def mapping(data_source, geom_name='geom', layer_key=0, multi_geom=False):
pass
else:
raise TypeError('Data source parameter must be a string or a DataSource object.')
-
+
# Creating the dictionary.
_mapping = {}
@@ -52,32 +52,32 @@ def ogrinspect(*args, **kwargs):
model name this function will generate a GeoDjango model.
Usage:
-
+
>>> from django.contrib.gis.utils import ogrinspect
>>> ogrinspect('/path/to/shapefile.shp','NewModel')
-
+
...will print model definition to stout
-
+
or put this in a python script and use to redirect the output to a new
model like:
-
+
$ python generate_model.py > myapp/models.py
-
- # generate_model.py
+
+ # generate_model.py
from django.contrib.gis.utils import ogrinspect
shp_file = 'data/mapping_hacks/world_borders.shp'
model_name = 'WorldBorders'
print ogrinspect(shp_file, model_name, multi_geom=True, srid=4326,
geom_name='shapes', blank=True)
-
+
Required Arguments
`datasource` => string or DataSource object to file pointer
-
+
`model name` => string of name of new model class to create
-
+
Optional Keyword Arguments
- `geom_name` => For specifying the model name for the Geometry Field.
+ `geom_name` => For specifying the model name for the Geometry Field.
Otherwise will default to `geom`
`layer_key` => The key for specifying which layer in the DataSource to use;
@@ -86,24 +86,24 @@ def ogrinspect(*args, **kwargs):
`srid` => The SRID to use for the Geometry Field. If it can be determined,
the SRID of the datasource is used.
-
+
`multi_geom` => Boolean (default: False) - specify as multigeometry.
-
+
`name_field` => String - specifies a field name to return for the
`__unicode__` function (which will be generated if specified).
-
- `imports` => Boolean (default: True) - set to False to omit the
- `from django.contrib.gis.db import models` code from the
+
+ `imports` => Boolean (default: True) - set to False to omit the
+ `from django.contrib.gis.db import models` code from the
autogenerated models thus avoiding duplicated imports when building
more than one model by batching ogrinspect()
-
+
`decimal` => Boolean or sequence (default: False). When set to True
all generated model fields corresponding to the `OFTReal` type will
be `DecimalField` instead of `FloatField`. A sequence of specific
field names to generate as `DecimalField` may also be used.
`blank` => Boolean or sequence (default: False). When set to True all
- generated model fields will have `blank=True`. If the user wants to
+ generated model fields will have `blank=True`. If the user wants to
give specific fields to have blank, then a list/tuple of OGR field
names may be used.
@@ -111,13 +111,13 @@ def ogrinspect(*args, **kwargs):
model fields will have `null=True`. If the user wants to specify
give specific fields to have null, then a list/tuple of OGR field
names may be used.
-
+
Note: This routine calls the _ogrinspect() helper to do the heavy lifting.
"""
return '\n'.join(s for s in _ogrinspect(*args, **kwargs))
def _ogrinspect(data_source, model_name, geom_name='geom', layer_key=0, srid=None,
- multi_geom=False, name_field=None, imports=True,
+ multi_geom=False, name_field=None, imports=True,
decimal=False, blank=False, null=False):
"""
Helper routine for `ogrinspect` that generates GeoDjango models corresponding
@@ -140,7 +140,7 @@ def _ogrinspect(data_source, model_name, geom_name='geom', layer_key=0, srid=Non
# keyword arguments.
def process_kwarg(kwarg):
if isinstance(kwarg, (list, tuple)):
- return [s.lower() for s in kwarg]
+ return [s.lower() for s in kwarg]
elif kwarg:
return [s.lower() for s in ogr_fields]
else:
@@ -164,18 +164,18 @@ def get_kwargs_str(field_name):
yield ''
yield 'class %s(models.Model):' % model_name
-
+
for field_name, width, precision, field_type in izip(ogr_fields, layer.field_widths, layer.field_precisions, layer.field_types):
# The model field name.
mfield = field_name.lower()
if mfield[-1:] == '_': mfield += 'field'
-
+
# Getting the keyword args string.
kwargs_str = get_kwargs_str(field_name)
if field_type is OFTReal:
# By default OFTReals are mapped to `FloatField`, however, they
- # may also be mapped to `DecimalField` if specified in the
+ # may also be mapped to `DecimalField` if specified in the
# `decimal` keyword.
if field_name.lower() in decimal_fields:
yield ' %s = models.DecimalField(max_digits=%d, decimal_places=%d%s)' % (mfield, width, precision, kwargs_str)
@@ -192,8 +192,8 @@ def get_kwargs_str(field_name):
elif field_type is OFTDate:
yield ' %s = models.TimeField(%s)' % (mfield, kwargs_str[2:])
else:
- raise TypeError('Unknown field type %s in %s' % (fld_type, mfield))
-
+ raise TypeError('Unknown field type %s in %s' % (field_type, mfield))
+
# TODO: Autodetection of multigeometry types (see #7218).
gtype = layer.geom_type
if multi_geom and gtype.num in (1, 2, 3):
View
133 django/db/models/fields/files.py
@@ -142,13 +142,13 @@ class FileDescriptor(object):
"""
The descriptor for the file attribute on the model instance. Returns a
FieldFile when accessed so you can do stuff like::
-
+
>>> instance.file.size
-
+
Assigns a file object on assignment so you can do::
-
+
>>> instance.file = File(...)
-
+
"""
def __init__(self, field):
self.field = field
@@ -156,9 +156,9 @@ def __init__(self, field):
def __get__(self, instance=None, owner=None):
if instance is None:
raise AttributeError(
- "The '%s' attribute can only be accessed from %s instances."
+ "The '%s' attribute can only be accessed from %s instances."
% (self.field.name, owner.__name__))
-
+
# This is slightly complicated, so worth an explanation.
# instance.file`needs to ultimately return some instance of `File`,
# probably a subclass. Additionally, this returned object needs to have
@@ -168,8 +168,8 @@ def __get__(self, instance=None, owner=None):
# peek below you can see that we're not. So depending on the current
# value of the field we have to dynamically construct some sort of
# "thing" to return.
-
- # The instance dict contains whatever was originally assigned
+
+ # The instance dict contains whatever was originally assigned
# in __set__.
file = instance.__dict__[self.field.name]
@@ -186,14 +186,14 @@ def __get__(self, instance=None, owner=None):
# Other types of files may be assigned as well, but they need to have
# the FieldFile interface added to the. Thus, we wrap any other type of
- # File inside a FieldFile (well, the field's attr_class, which is
+ # File inside a FieldFile (well, the field's attr_class, which is
# usually FieldFile).
elif isinstance(file, File) and not isinstance(file, FieldFile):
file_copy = self.field.attr_class(instance, self.field, file.name)
file_copy.file = file
file_copy._committed = False
instance.__dict__[self.field.name] = file_copy
-
+
# Finally, because of the (some would say boneheaded) way pickle works,
# the underlying FieldFile might not actually itself have an associated
# file. So we need to reset the details of the FieldFile in those cases.
@@ -201,7 +201,7 @@ def __get__(self, instance=None, owner=None):
file.instance = instance
file.field = self.field
file.storage = self.field.storage
-
+
# That was fun, wasn't it?
return instance.__dict__[self.field.name]
@@ -212,7 +212,7 @@ class FileField(Field):
# The class to wrap instance attributes in. Accessing the file object off
# the instance will always return an instance of attr_class.
attr_class = FieldFile
-
+
# The descriptor to use for accessing the attribute off of the class.
descriptor_class = FileDescriptor
@@ -300,40 +300,20 @@ class ImageFileDescriptor(FileDescriptor):
assigning the width/height to the width_field/height_field, if appropriate.
"""
def __set__(self, instance, value):
+ previous_file = instance.__dict__.get(self.field.name)
super(ImageFileDescriptor, self).__set__(instance, value)
-
- # The rest of this method deals with width/height fields, so we can
- # bail early if neither is used.
- if not self.field.width_field and not self.field.height_field:
- return
-
- # We need to call the descriptor's __get__ to coerce this assigned
- # value into an instance of the right type (an ImageFieldFile, in this
- # case).
- value = self.__get__(instance)
-
- if not value:
- return
-
- # Get the image dimensions, making sure to leave the file in the same
- # state (opened or closed) that we got it in. However, we *don't* rewind
- # the file pointer if the file is already open. This is in keeping with
- # most Python standard library file operations that leave it up to the
- # user code to reset file pointers after operations that move it.
- from django.core.files.images import get_image_dimensions
- close = value.closed
- value.open()
- try:
- width, height = get_image_dimensions(value)
- finally:
- if close:
- value.close()
-
- # Update the width and height fields
- if self.field.width_field:
- setattr(value.instance, self.field.width_field, width)
- if self.field.height_field:
- setattr(value.instance, self.field.height_field, height)
+
+ # To prevent recalculating image dimensions when we are instantiating
+ # an object from the database (bug #11084), only update dimensions if
+ # the field had a value before this assignment. Since the default
+ # value for FileField subclasses is an instance of field.attr_class,
+ # previous_file will only be None when we are called from
+ # Model.__init__(). The ImageField.update_dimension_fields method
+ # hooked up to the post_init signal handles the Model.__init__() cases.
+ # Assignment happening outside of Model.__init__() will trigger the
+ # update right here.
+ if previous_file is not None:
+ self.field.update_dimension_fields(instance, force=True)
class ImageFieldFile(ImageFile, FieldFile):
def delete(self, save=True):
@@ -350,6 +330,69 @@ def __init__(self, verbose_name=None, name=None, width_field=None, height_field=
self.width_field, self.height_field = width_field, height_field
FileField.__init__(self, verbose_name, name, **kwargs)
+ def contribute_to_class(self, cls, name):
+ super(ImageField, self).contribute_to_class(cls, name)
+ # Attach update_dimension_fields so that dimension fields declared
+ # after their corresponding image field don't stay cleared by
+ # Model.__init__, see bug #11196.
+ signals.post_init.connect(self.update_dimension_fields, sender=cls)
+
+ def update_dimension_fields(self, instance, force=False, *args, **kwargs):
+ """
+ Updates field's width and height fields, if defined.
+
+ This method is hooked up to model's post_init signal to update
+ dimensions after instantiating a model instance. However, dimensions
+ won't be updated if the dimensions fields are already populated. This
+ avoids unnecessary recalculation when loading an object from the
+ database.
+
+ Dimensions can be forced to update with force=True, which is how
+ ImageFileDescriptor.__set__ calls this method.
+ """
+ # Nothing to update if the field doesn't have have dimension fields.
+ has_dimension_fields = self.width_field or self.height_field
+ if not has_dimension_fields:
+ return
+
+ # getattr will call the ImageFileDescriptor's __get__ method, which
+ # coerces the assigned value into an instance of self.attr_class
+ # (ImageFieldFile in this case).
+ file = getattr(instance, self.attname)
+
+ # Nothing to update if we have no file and not being forced to update.
+ if not file and not force:
+ return
+
+ dimension_fields_filled = not(
+ (self.width_field and not getattr(instance, self.width_field))
+ or (self.height_field and not getattr(instance, self.height_field))
+ )
+ # When both dimension fields have values, we are most likely loading
+ # data from the database or updating an image field that already had
+ # an image stored. In the first case, we don't want to update the
+ # dimension fields because we are already getting their values from the
+ # database. In the second case, we do want to update the dimensions
+ # fields and will skip this return because force will be True since we
+ # were called from ImageFileDescriptor.__set__.
+ if dimension_fields_filled and not force:
+ return
+
+ # file should be an instance of ImageFieldFile or should be None.
+ if file:
+ width = file.width
+ height = file.height
+ else:
+ # No file, so clear dimensions fields.
+ width = None
+ height = None
+
+ # Update the width and height fields.
+ if self.width_field:
+ setattr(instance, self.width_field, width)
+ if self.height_field:
+ setattr(instance, self.height_field, height)
+
def formfield(self, **kwargs):
defaults = {'form_class': forms.ImageField}
defaults.update(kwargs)
View
3 django/db/models/query.py
@@ -355,10 +355,11 @@ def delete(self):
# Delete objects in chunks to prevent the list of related objects from
# becoming too long.
+ seen_objs = None
while 1:
# Collect all the objects to be deleted in this chunk, and all the
# objects that are related to the objects that are to be deleted.
- seen_objs = CollectedObjects()
+ seen_objs = CollectedObjects(seen_objs)
for object in del_query[:CHUNK_SIZE]:
object._collect_sub_objects(seen_objs)
View
15 django/db/models/query_utils.py
@@ -32,11 +32,21 @@ class CollectedObjects(object):
This is used for the database object deletion routines so that we can
calculate the 'leaf' objects which should be deleted first.
+
+ previously_seen is an optional argument. It must be a CollectedObjects
+ instance itself; any previously_seen collected object will be blocked from
+ being added to this instance.
"""
- def __init__(self):
+ def __init__(self, previously_seen=None):
self.data = {}
self.children = {}
+ if previously_seen:
+ self.blocked = previously_seen.blocked
+ for cls, seen in previously_seen.data.items():
+ self.blocked.setdefault(cls, SortedDict()).update(seen)
+ else:
+ self.blocked = {}
def add(self, model, pk, obj, parent_model, nullable=False):
"""
@@ -53,6 +63,9 @@ def add(self, model, pk, obj, parent_model, nullable=False):
Returns True if the item already existed in the structure and
False otherwise.
"""
+ if pk in self.blocked.get(model, {}):
+ return True
+
d = self.data.setdefault(model, SortedDict())
retval = pk in d
d[pk] = obj
View
8 django/db/models/sql/query.py
@@ -689,7 +689,7 @@ def get_columns(self, with_aliases=False):
If 'with_aliases' is true, any column names that are duplicated
(without the table names) are given unique aliases. This is needed in
- some cases to avoid ambiguitity with nested queries.
+ some cases to avoid ambiguity with nested queries.
"""
qn = self.quote_name_unless_alias
qn2 = self.connection.ops.quote_name
@@ -1303,7 +1303,7 @@ def setup_inherited_models(self):
opts = self.model._meta
root_alias = self.tables[0]
seen = {None: root_alias}
-
+
# Skip all proxy to the root proxied model
proxied_model = get_proxied_model(opts)
@@ -1732,7 +1732,7 @@ def setup_joins(self, names, opts, alias, dupe_multis, allow_many=True,
raise MultiJoin(pos + 1)
if model:
# The field lives on a base class of the current model.
- # Skip the chain of proxy to the concrete proxied model
+ # Skip the chain of proxy to the concrete proxied model
proxied_model = get_proxied_model(opts)
for int_model in opts.get_base_chain(model):
@@ -2362,7 +2362,7 @@ def execute_sql(self, result_type=MULTI):
return cursor
if result_type == SINGLE:
if self.ordering_aliases:
- return cursor.fetchone()[:-len(results.ordering_aliases)]
+ return cursor.fetchone()[:-len(self.ordering_aliases)]
return cursor.fetchone()
# The MULTI case.
View
2 django/forms/models.py
@@ -584,7 +584,7 @@ def get_unique_error_message(self, unique_check):
else:
return ugettext("Please correct the duplicate data for %(field)s, "
"which must be unique.") % {
- "field": get_text_list(unique_check, _("and")),
+ "field": get_text_list(unique_check, unicode(_("and"))),
}
def get_date_error_message(self, date_check):
View
21 tests/modeltests/model_forms/models.py
@@ -1175,8 +1175,9 @@ def __unicode__(self):
>>> instance.height
16
-# Delete the current file since this is not done by Django.
->>> instance.image.delete()
+# Delete the current file since this is not done by Django, but don't save
+# because the dimension fields are not null=True.
+>>> instance.image.delete(save=False)
>>> f = ImageFileForm(data={'description': u'An image'}, files={'image': SimpleUploadedFile('test.png', image_data)})
>>> f.is_valid()
@@ -1207,9 +1208,9 @@ def __unicode__(self):
>>> instance.width
16
-# Delete the current image since this is not done by Django.
-
->>> instance.image.delete()
+# Delete the current file since this is not done by Django, but don't save
+# because the dimension fields are not null=True.
+>>> instance.image.delete(save=False)
# Override the file by uploading a new one.
@@ -1224,8 +1225,9 @@ def __unicode__(self):
>>> instance.width
48
-# Delete the current file since this is not done by Django.
->>> instance.image.delete()
+# Delete the current file since this is not done by Django, but don't save
+# because the dimension fields are not null=True.
+>>> instance.image.delete(save=False)
>>> instance.delete()
>>> f = ImageFileForm(data={'description': u'Changed it'}, files={'image': SimpleUploadedFile('test2.png', image_data2)})
@@ -1239,8 +1241,9 @@ def __unicode__(self):
>>> instance.width
48
-# Delete the current file since this is not done by Django.
->>> instance.image.delete()
+# Delete the current file since this is not done by Django, but don't save
+# because the dimension fields are not null=True.
+>>> instance.image.delete(save=False)
>>> instance.delete()
# Test the non-required ImageField
View
2 tests/regressiontests/admin_scripts/tests.py
@@ -536,7 +536,7 @@ def test_setup_environ(self):
args = ['startapp','settings_test']
out, err = self.run_django_admin(args,'settings')
self.assertNoOutput(err)
- self.assertTrue(os.path.exists(os.path.join(test_dir, 'settings_test')))
+ self.assert_(os.path.exists(os.path.join(test_dir, 'settings_test')))
shutil.rmtree(os.path.join(test_dir, 'settings_test'))
def test_builtin_command(self):
View
1 tests/regressiontests/delete_regress/__init__.py
@@ -0,0 +1 @@
+
View
61 tests/regressiontests/delete_regress/models.py
@@ -0,0 +1,61 @@
+from django.conf import settings
+from django.db import models, backend, connection, transaction
+from django.db.models import sql, query
+from django.test import TransactionTestCase
+
+class Book(models.Model):
+ pagecount = models.IntegerField()
+
+# Can't run this test under SQLite, because you can't
+# get two connections to an in-memory database.
+if settings.DATABASE_ENGINE != 'sqlite3':
+ class DeleteLockingTest(TransactionTestCase):
+ def setUp(self):
+ # Create a second connection to the database
+ self.conn2 = backend.DatabaseWrapper({
+ 'DATABASE_HOST': settings.DATABASE_HOST,
+ 'DATABASE_NAME': settings.DATABASE_NAME,
+ 'DATABASE_OPTIONS': settings.DATABASE_OPTIONS,
+ 'DATABASE_PASSWORD': settings.DATABASE_PASSWORD,
+ 'DATABASE_PORT': settings.DATABASE_PORT,
+ 'DATABASE_USER': settings.DATABASE_USER,
+ 'TIME_ZONE': settings.TIME_ZONE,
+ })
+
+ # Put both DB connections into managed transaction mode
+ transaction.enter_transaction_management()
+ transaction.managed(True)
+ self.conn2._enter_transaction_management(True)
+
+ def tearDown(self):
+ # Close down the second connection.
+ transaction.leave_transaction_management()
+ self.conn2.close()
+
+ def test_concurrent_delete(self):
+ "Deletes on concurrent transactions don't collide and lock the database. Regression for #9479"
+
+ # Create some dummy data
+ b1 = Book(id=1, pagecount=100)
+ b2 = Book(id=2, pagecount=200)
+ b3 = Book(id=3, pagecount=300)
+ b1.save()
+ b2.save()
+ b3.save()
+
+ transaction.commit()
+
+ self.assertEquals(3, Book.objects.count())
+
+ # Delete something using connection 2.
+ cursor2 = self.conn2.cursor()
+ cursor2.execute('DELETE from delete_regress_book WHERE id=1')
+ self.conn2._commit();
+
+ # Now perform a queryset delete that covers the object
+ # deleted in connection 2. This causes an infinite loop
+ # under MySQL InnoDB unless we keep track of already
+ # deleted objects.
+ Book.objects.filter(pagecount__lt=250).delete()
+ transaction.commit()
+ self.assertEquals(1, Book.objects.count())
View
93 tests/regressiontests/file_storage/models.py
@@ -1,93 +0,0 @@
-import os
-import tempfile
-import shutil
-from django.db import models
-from django.core.files.storage import FileSystemStorage
-from django.core.files.base import ContentFile
-
-# Test for correct behavior of width_field/height_field.
-# Of course, we can't run this without PIL.
-
-try:
- # Checking for the existence of Image is enough for CPython, but
- # for PyPy, you need to check for the underlying modules
- from PIL import Image, _imaging
-except ImportError:
- Image = None
-
-# If we have PIL, do these tests
-if Image:
- temp_storage_dir = tempfile.mkdtemp()
- temp_storage = FileSystemStorage(temp_storage_dir)
-
- class Person(models.Model):
- name = models.CharField(max_length=50)
- mugshot = models.ImageField(storage=temp_storage, upload_to='tests',
- height_field='mug_height',
- width_field='mug_width')
- mug_height = models.PositiveSmallIntegerField()
- mug_width = models.PositiveSmallIntegerField()
-
- __test__ = {'API_TESTS': """
->>> from django.core.files import File
->>> image_data = open(os.path.join(os.path.dirname(__file__), "test.png"), 'rb').read()
->>> p = Person(name="Joe")
->>> p.mugshot.save("mug", ContentFile(image_data))
->>> p.mugshot.width
-16
->>> p.mugshot.height
-16
->>> p.mug_height
-16
->>> p.mug_width
-16
-
-# Bug #9786: Ensure '==' and '!=' work correctly.
->>> image_data = open(os.path.join(os.path.dirname(__file__), "test1.png"), 'rb').read()
->>> p1 = Person(name="Bob")
->>> p1.mugshot.save("mug", ContentFile(image_data))
->>> p2 = Person.objects.get(name="Joe")
->>> p.mugshot == p2.mugshot
-True
->>> p.mugshot != p2.mugshot
-False
->>> p.mugshot != p1.mugshot
-True
-
-Bug #9508: Similarly to the previous test, make sure hash() works as expected
-(equal items must hash to the same value).
->>> hash(p.mugshot) == hash(p2.mugshot)
-True
-
-# Bug #8175: correctly delete files that have been removed off the file system.
->>> import os
->>> p2 = Person(name="Fred")
->>> p2.mugshot.save("shot", ContentFile(image_data))
->>> os.remove(p2.mugshot.path)
->>> p2.delete()
-
-# Bug #8534: FileField.size should not leave the file open.
->>> p3 = Person(name="Joan")
->>> p3.mugshot.save("shot", ContentFile(image_data))
-
-# Get a "clean" model instance
->>> p3 = Person.objects.get(name="Joan")
-
-# It won't have an opened file.
->>> p3.mugshot.closed
-True
-
-# After asking for the size, the file should still be closed.
->>> _ = p3.mugshot.size
->>> p3.mugshot.closed
-True
-
-# Make sure that wrapping the file in a file still works
->>> p3.mugshot.file.open()
->>> p = Person.objects.create(name="Bob The Builder", mugshot=File(p3.mugshot.file))
->>> p.save()
->>> p3.mugshot.file.close()
-
-# Delete all test files
->>> shutil.rmtree(temp_storage_dir)
-"""}
View
12 tests/regressiontests/file_storage/tests.py
@@ -161,9 +161,9 @@ def test_directory_with_dot(self):
self.storage.save('dotted.path/test', ContentFile("1"))
self.storage.save('dotted.path/test', ContentFile("2"))
- self.assertFalse(os.path.exists(os.path.join(self.storage_dir, 'dotted_.path')))
- self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/test')))
- self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/test_')))
+ self.failIf(os.path.exists(os.path.join(self.storage_dir, 'dotted_.path')))
+ self.assert_(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/test')))
+ self.assert_(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/test_')))
def test_first_character_dot(self):
"""
@@ -173,13 +173,13 @@ def test_first_character_dot(self):
self.storage.save('dotted.path/.test', ContentFile("1"))
self.storage.save('dotted.path/.test', ContentFile("2"))
- self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test')))
+ self.assert_(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test')))
# Before 2.6, a leading dot was treated as an extension, and so
# underscore gets added to beginning instead of end.
if sys.version_info < (2, 6):
- self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/_.test')))
+ self.assert_(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/_.test')))
else:
- self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test_')))
+ self.assert_(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test_')))
if Image is not None:
class DimensionClosingBug(TestCase):
View
BIN tests/regressiontests/model_fields/4x8.png
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
View
BIN tests/regressiontests/model_fields/8x4.png
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
View
420 tests/regressiontests/model_fields/imagefield.py
@@ -0,0 +1,420 @@
+import os
+import shutil
+
+from django.core.files import File
+from django.core.files.base import ContentFile
+from django.core.files.images import ImageFile
+from django.test import TestCase
+
+from models import Image, Person, PersonWithHeight, PersonWithHeightAndWidth, \
+ PersonDimensionsFirst, PersonTwoImages, TestImageFieldFile
+
+
+# If PIL available, do these tests.
+if Image:
+
+ from models import temp_storage_dir
+
+
+ class ImageFieldTestMixin(object):
+ """
+ Mixin class to provide common functionality to ImageField test classes.
+ """
+
+ # Person model to use for tests.
+ PersonModel = PersonWithHeightAndWidth
+ # File class to use for file instances.
+ File = ImageFile
+
+ def setUp(self):
+ """
+ Creates a pristine temp directory (or deletes and recreates if it
+ already exists) that the model uses as its storage directory.
+
+ Sets up two ImageFile instances for use in tests.
+ """
+ if os.path.exists(temp_storage_dir):
+ shutil.rmtree(temp_storage_dir)
+ os.mkdir(temp_storage_dir)
+
+ file_path1 = os.path.join(os.path.dirname(__file__), "4x8.png")
+ self.file1 = self.File(open(file_path1, 'rb'))
+
+ file_path2 = os.path.join(os.path.dirname(__file__), "8x4.png")
+ self.file2 = self.File(open(file_path2, 'rb'))
+
+ def tearDown(self):
+ """
+ Removes temp directory and all its contents.
+ """
+ shutil.rmtree(temp_storage_dir)
+
+ def check_dimensions(self, instance, width, height,
+ field_name='mugshot'):
+ """
+ Asserts that the given width and height values match both the
+ field's height and width attributes and the height and width fields
+ (if defined) the image field is caching to.
+
+ Note, this method will check for dimension fields named by adding
+ "_width" or "_height" to the name of the ImageField. So, the
+ models used in these tests must have their fields named
+ accordingly.
+
+ By default, we check the field named "mugshot", but this can be
+ specified by passing the field_name parameter.
+ """
+ field = getattr(instance, field_name)
+ # Check height/width attributes of field.
+ if width is None and height is None:
+ self.assertRaises(ValueError, getattr, field, 'width')
+ self.assertRaises(ValueError, getattr, field, 'height')
+ else:
+ self.assertEqual(field.width, width)
+ self.assertEqual(field.height, height)
+
+ # Check height/width fields of model, if defined.
+ width_field_name = field_name + '_width'
+ if hasattr(instance, width_field_name):
+ self.assertEqual(getattr(instance, width_field_name), width)
+ height_field_name = field_name + '_height'
+ if hasattr(instance, height_field_name):
+ self.assertEqual(getattr(instance, height_field_name), height)
+
+
+ class ImageFieldTests(ImageFieldTestMixin, TestCase):
+ """
+ Tests for ImageField that don't need to be run with each of the
+ different test model classes.
+ """
+
+ def test_equal_notequal_hash(self):
+ """
+ Bug #9786: Ensure '==' and '!=' work correctly.
+ Bug #9508: make sure hash() works as expected (equal items must
+ hash to the same value).
+ """
+ # Create two Persons with different mugshots.
+ p1 = self.PersonModel(name="Joe")
+ p1.mugshot.save("mug", self.file1)
+ p2 = self.PersonModel(name="Bob")
+ p2.mugshot.save("mug", self.file2)
+ self.assertEqual(p1.mugshot == p2.mugshot, False)
+ self.assertEqual(p1.mugshot != p2.mugshot, True)
+
+ # Test again with an instance fetched from the db.
+ p1_db = self.PersonModel.objects.get(name="Joe")
+ self.assertEqual(p1_db.mugshot == p2.mugshot, False)
+ self.assertEqual(p1_db.mugshot != p2.mugshot, True)
+
+ # Instance from db should match the local instance.
+ self.assertEqual(p1_db.mugshot == p1.mugshot, True)
+ self.assertEqual(hash(p1_db.mugshot), hash(p1.mugshot))
+ self.assertEqual(p1_db.mugshot != p1.mugshot, False)
+
+ def test_instantiate_missing(self):
+ """
+ If the underlying file is unavailable, still create instantiate the
+ object without error.
+ """
+ p = self.PersonModel(name="Joan")
+ p.mugshot.save("shot", self.file1)
+ p = self.PersonModel.objects.get(name="Joan")
+ path = p.mugshot.path
+ shutil.move(path, path + '.moved')
+ p2 = self.PersonModel.objects.get(name="Joan")
+
+ def test_delete_when_missing(self):
+ """
+ Bug #8175: correctly delete an object where the file no longer
+ exists on the file system.
+ """
+ p = self.PersonModel(name="Fred")
+ p.mugshot.save("shot", self.file1)
+ os.remove(p.mugshot.path)
+ p.delete()
+
+ def test_size_method(self):
+ """
+ Bug #8534: FileField.size should not leave the file open.
+ """
+ p = self.PersonModel(name="Joan")
+ p.mugshot.save("shot", self.file1)
+
+ # Get a "clean" model instance
+ p = self.PersonModel.objects.get(name="Joan")
+ # It won't have an opened file.
+ self.assertEqual(p.mugshot.closed, True)
+
+ # After asking for the size, the file should still be closed.
+ _ = p.mugshot.size
+ self.assertEqual(p.mugshot.closed, True)
+
+ def test_pickle(self):
+ """
+ Tests that ImageField can be pickled, unpickled, and that the
+ image of the unpickled version is the same as the original.
+ """
+ import pickle
+
+ p = Person(name="Joe")
+ p.mugshot.save("mug", self.file1)
+ dump = pickle.dumps(p)
+
+ p2 = Person(name="Bob")
+ p2.mugshot = self.file1
+
+ loaded_p = pickle.loads(dump)
+ self.assertEqual(p.mugshot, loaded_p.mugshot)
+
+
+ class ImageFieldTwoDimensionsTests(ImageFieldTestMixin, TestCase):
+ """
+ Tests behavior of an ImageField and its dimensions fields.
+ """
+
+ def test_constructor(self):
+ """
+ Tests assigning an image field through the model's constructor.
+ """
+ p = self.PersonModel(name='Joe', mugshot=self.file1)
+ self.check_dimensions(p, 4, 8)
+ p.save()
+ self.check_dimensions(p, 4, 8)
+
+ def test_image_after_constructor(self):
+ """
+ Tests behavior when image is not passed in constructor.
+ """
+ p = self.PersonModel(name='Joe')
+ # TestImageField value will default to being an instance of its
+ # attr_class, a TestImageFieldFile, with name == None, which will
+ # cause it to evaluate as False.
+ self.assertEqual(isinstance(p.mugshot, TestImageFieldFile), True)
+ self.assertEqual(bool(p.mugshot), False)
+
+ # Test setting a fresh created model instance.
+ p = self.PersonModel(name='Joe')
+ p.mugshot = self.file1
+ self.check_dimensions(p, 4, 8)
+
+ def test_create(self):
+ """
+ Tests assigning an image in Manager.create().
+ """
+ p = self.PersonModel.objects.create(name='Joe', mugshot=self.file1)
+ self.check_dimensions(p, 4, 8)
+
+ def test_default_value(self):
+ """
+ Tests that the default value for an ImageField is an instance of
+ the field's attr_class (TestImageFieldFile in this case) with no
+ name (name set to None).
+ """
+ p = self.PersonModel()
+ self.assertEqual(isinstance(p.mugshot, TestImageFieldFile), True)
+ self.assertEqual(bool(p.mugshot), False)
+
+ def test_assignment_to_None(self):
+ """
+ Tests that assigning ImageField to None clears dimensions.
+ """
+ p = self.PersonModel(name='Joe', mugshot=self.file1)
+ self.check_dimensions(p, 4, 8)
+
+ # If image assigned to None, dimension fields should be cleared.
+ p.mugshot = None
+ self.check_dimensions(p, None, None)
+
+ p.mugshot = self.file2
+ self.check_dimensions(p, 8, 4)
+
+ def test_field_save_and_delete_methods(self):
+ """
+ Tests assignment using the field's save method and deletion using
+ the field's delete method.
+ """
+ p = self.PersonModel(name='Joe')
+ p.mugshot.save("mug", self.file1)
+ self.check_dimensions(p, 4, 8)
+
+ # A new file should update dimensions.
+ p.mugshot.save("mug", self.file2)
+ self.check_dimensions(p, 8, 4)
+
+ # Field and dimensions should be cleared after a delete.
+ p.mugshot.delete(save=False)
+ self.assertEqual(p.mugshot, None)
+ self.check_dimensions(p, None, None)
+
+ def test_dimensions(self):
+ """
+ Checks that dimensions are updated correctly in various situations.
+ """
+ p = self.PersonModel(name='Joe')
+
+ # Dimensions should get set if file is saved.
+ p.mugshot.save("mug", self.file1)
+ self.check_dimensions(p, 4, 8)
+
+ # Test dimensions after fetching from database.
+ p = self.PersonModel.objects.get(name='Joe')
+ # Bug 11084: Dimensions should not get recalculated if file is
+ # coming from the database. We test this by checking if the file
+ # was opened.
+ self.assertEqual(p.mugshot.was_opened, False)
+ self.check_dimensions(p, 4, 8)
+ # After checking dimensions on the image field, the file will have
+ # opened.
+ self.assertEqual(p.mugshot.was_opened, True)
+ # Dimensions should now be cached, and if we reset was_opened and
+ # check dimensions again, the file should not have opened.
+ p.mugshot.was_opened = False
+ self.check_dimensions(p, 4, 8)
+ self.assertEqual(p.mugshot.was_opened, False)
+
+ # If we assign a new image to the instance, the dimensions should
+ # update.
+ p.mugshot = self.file2
+ self.check_dimensions(p, 8, 4)
+ # Dimensions were recalculated, and hence file should have opened.
+ self.assertEqual(p.mugshot.was_opened, True)
+
+
+ class ImageFieldNoDimensionsTests(ImageFieldTwoDimensionsTests):
+ """
+ Tests behavior of an ImageField with no dimension fields.
+ """
+
+ PersonModel = Person
+
+
+ class ImageFieldOneDimensionTests(ImageFieldTwoDimensionsTests):
+ """
+ Tests behavior of an ImageField with one dimensions field.
+ """
+
+ PersonModel = PersonWithHeight
+
+
+ class ImageFieldDimensionsFirstTests(ImageFieldTwoDimensionsTests):
+ """
+ Tests behavior of an ImageField where the dimensions fields are
+ defined before the ImageField.
+ """
+
+ PersonModel = PersonDimensionsFirst
+
+
+ class ImageFieldUsingFileTests(ImageFieldTwoDimensionsTests):
+ """
+ Tests behavior of an ImageField when assigning it a File instance
+ rather than an ImageFile instance.
+ """
+
+ PersonModel = PersonDimensionsFirst
+ File = File
+
+
+ class TwoImageFieldTests(ImageFieldTestMixin, TestCase):
+ """
+ Tests a model with two ImageFields.
+ """
+
+ PersonModel = PersonTwoImages
+
+ def test_constructor(self):
+ p = self.PersonModel(mugshot=self.file1, headshot=self.file2)
+ self.check_dimensions(p, 4, 8, 'mugshot')
+ self.check_dimensions(p, 8, 4, 'headshot')
+ p.save()
+ self.check_dimensions(p, 4, 8, 'mugshot')
+ self.check_dimensions(p, 8, 4, 'headshot')
+
+ def test_create(self):
+ p = self.PersonModel.objects.create(mugshot=self.file1,
+ headshot=self.file2)
+ self.check_dimensions(p, 4, 8)
+ self.check_dimensions(p, 8, 4, 'headshot')
+
+ def test_assignment(self):
+ p = self.PersonModel()
+ self.check_dimensions(p, None, None, 'mugshot')
+ self.check_dimensions(p, None, None, 'headshot')
+
+ p.mugshot = self.file1
+ self.check_dimensions(p, 4, 8, 'mugshot')
+ self.check_dimensions(p, None, None, 'headshot')
+ p.headshot = self.file2
+ self.check_dimensions(p, 4, 8, 'mugshot')
+ self.check_dimensions(p, 8, 4, 'headshot')
+
+ # Clear the ImageFields one at a time.
+ p.mugshot = None
+ self.check_dimensions(p, None, None, 'mugshot')
+ self.check_dimensions(p, 8, 4, 'headshot')
+ p.headshot = None
+ self.check_dimensions(p, None, None, 'mugshot')
+ self.check_dimensions(p, None, None, 'headshot')
+
+ def test_field_save_and_delete_methods(self):
+ p = self.PersonModel(name='Joe')
+ p.mugshot.save("mug", self.file1)
+ self.check_dimensions(p, 4, 8, 'mugshot')
+ self.check_dimensions(p, None, None, 'headshot')
+ p.headshot.save("head", self.file2)
+ self.check_dimensions(p, 4, 8, 'mugshot')
+ self.check_dimensions(p, 8, 4, 'headshot')
+
+ # We can use save=True when deleting the image field with null=True
+ # dimension fields and the other field has an image.
+ p.headshot.delete(save=True)
+ self.check_dimensions(p, 4, 8, 'mugshot')
+ self.check_dimensions(p, None, None, 'headshot')
+ p.mugshot.delete(save=False)
+ self.check_dimensions(p, None, None, 'mugshot')
+ self.check_dimensions(p, None, None, 'headshot')
+
+ def test_dimensions(self):
+ """
+ Checks that dimensions are updated correctly in various situations.
+ """
+ p = self.PersonModel(name='Joe')
+
+ # Dimensions should get set for the saved file.
+ p.mugshot.save("mug", self.file1)
+ p.headshot.save("head", self.file2)
+ self.check_dimensions(p, 4, 8, 'mugshot')
+ self.check_dimensions(p, 8, 4, 'headshot')
+
+ # Test dimensions after fetching from database.
+ p = self.PersonModel.objects.get(name='Joe')
+ # Bug 11084: Dimensions should not get recalculated if file is
+ # coming from the database. We test this by checking if the file
+ # was opened.
+ self.assertEqual(p.mugshot.was_opened, False)
+ self.assertEqual(p.headshot.was_opened, False)
+ self.check_dimensions(p, 4, 8,'mugshot')
+ self.check_dimensions(p, 8, 4, 'headshot')
+ # After checking dimensions on the image fields, the files will
+ # have been opened.
+ self.assertEqual(p.mugshot.was_opened, True)
+ self.assertEqual(p.headshot.was_opened, True)
+ # Dimensions should now be cached, and if we reset was_opened and
+ # check dimensions again, the file should not have opened.
+ p.mugshot.was_opened = False
+ p.headshot.was_opened = False
+ self.check_dimensions(p, 4, 8,'mugshot')
+ self.check_dimensions(p, 8, 4, 'headshot')
+ self.assertEqual(p.mugshot.was_opened, False)
+ self.assertEqual(p.headshot.was_opened, False)
+
+ # If we assign a new image to the instance, the dimensions should
+ # update.
+ p.mugshot = self.file2
+ p.headshot = self.file1
+ self.check_dimensions(p, 8, 4, 'mugshot')
+ self.check_dimensions(p, 4, 8, 'headshot')
+ # Dimensions were recalculated, and hence file should have opened.
+ self.assertEqual(p.mugshot.was_opened, True)
+ self.assertEqual(p.headshot.was_opened, True)
View
107 tests/regressiontests/model_fields/models.py
@@ -1,10 +1,23 @@
-from django.db import models
+import os
+import tempfile
try:
import decimal
except ImportError:
from django.utils import _decimal as decimal # Python 2.3 fallback
+try:
+ # Checking for the existence of Image is enough for CPython, but for PyPy,
+ # you need to check for the underlying modules.
+ from PIL import Image, _imaging
+except ImportError:
+ Image = None
+
+from django.core.files.storage import FileSystemStorage
+from django.db import models
+from django.db.models.fields.files import ImageFieldFile, ImageField
+
+
class Foo(models.Model):
a = models.CharField(max_length=10)
d = models.DecimalField(max_digits=5, decimal_places=3)
@@ -31,9 +44,97 @@ class Whiz(models.Model):
(0,'Other'),
)
c = models.IntegerField(choices=CHOICES, null=True)
-
+
class BigD(models.Model):
d = models.DecimalField(max_digits=38, decimal_places=30)
class BigS(models.Model):
- s = models.SlugField(max_length=255)
+ s = models.SlugField(max_length=255)
+
+
+###############################################################################
+# ImageField
+
+# If PIL 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(TestImageFieldFile, self).__init__(*args,**kwargs)
+ def open(self):
+ self.was_opened = True
+ super(TestImageFieldFile, self).open()
+
+ class TestImageField(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 PersonWithHeight(models.Model):
+ """
+ Model that defines an ImageField with only one dimension field.
+ """
+ name = models.CharField(max_length=50)
+ mugshot = TestImageField(storage=temp_storage, upload_to='tests',
+ height_field='mugshot_height')
+ mugshot_height = models.PositiveSmallIntegerField()
+
+ 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 nullalble 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')
+
+###############################################################################
View
16 tests/regressiontests/model_fields/tests.py
@@ -6,13 +6,26 @@
from django.db import models
from django.core.exceptions import ValidationError
-from models import Foo, Bar, Whiz, BigD, BigS
+from models import Foo, Bar, Whiz, BigD, BigS, Image
try:
from decimal import Decimal
except ImportError:
from django.utils._decimal import Decimal
+
+# If PIL available, do these tests.
+if Image:
+ from imagefield import \
+ ImageFieldTests, \
+ ImageFieldTwoDimensionsTests, \
+ ImageFieldNoDimensionsTests, \
+ ImageFieldOneDimensionTests, \
+ ImageFieldDimensionsFirstTests, \
+ ImageFieldUsingFileTests, \
+ TwoImageFieldTests
+
+
class DecimalFieldTests(django.test.TestCase):
def test_to_python(self):
f = models.DecimalField(max_digits=4, decimal_places=2)
@@ -131,4 +144,3 @@ def test_slugfield_max_length(self):
bs = BigS.objects.create(s = 'slug'*50)
bs = BigS.objects.get(pk=bs.pk)
self.assertEqual(bs.s, 'slug'*50)
-

0 comments on commit 82b2580

Please sign in to comment.
Something went wrong with that request. Please try again.