mirror of
https://github.com/django/django.git
synced 2025-07-04 09:49:12 +00:00
[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
This commit is contained in:
Zain Memon
parent
6275888332
commit
82b25800cd
Binary file not shown.
File diff suppressed because it is too large
Load Diff
@ -35,7 +35,7 @@ class GeoWhereNode(WhereNode):
|
||||
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 @@ class GeoWhereNode(WhereNode):
|
||||
# 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
|
||||
|
||||
@ -143,7 +143,7 @@ class GoogleMap(object):
|
||||
@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 @@ class GoogleMapSet(GoogleMap):
|
||||
@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
|
||||
|
||||
@ -231,6 +231,14 @@ class GIcon(object):
|
||||
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
|
||||
|
||||
@ -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()
|
||||
|
||||
@ -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 @@ class RelatedGeoModelTest(unittest.TestCase):
|
||||
# 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 @@ class RelatedGeoModelTest(unittest.TestCase):
|
||||
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():
|
||||
|
||||
@ -192,7 +192,7 @@ def _ogrinspect(data_source, model_name, geom_name='geom', layer_key=0, srid=Non
|
||||
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
|
||||
|
||||
@ -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 @@ class ImageField(FileField):
|
||||
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)
|
||||
|
||||
@ -355,10 +355,11 @@ class QuerySet(object):
|
||||
|
||||
# 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)
|
||||
|
||||
|
||||
@ -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 @@ class CollectedObjects(object):
|
||||
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
|
||||
|
||||
@ -689,7 +689,7 @@ class BaseQuery(object):
|
||||
|
||||
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
|
||||
@ -2362,7 +2362,7 @@ class BaseQuery(object):
|
||||
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.
|
||||
|
||||
@ -584,7 +584,7 @@ class BaseModelFormSet(BaseFormSet):
|
||||
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):
|
||||
|
||||
@ -1175,8 +1175,9 @@ True
|
||||
>>> 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 @@ True
|
||||
>>> 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 @@ True
|
||||
>>> 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 @@ True
|
||||
>>> 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
|
||||
|
||||
@ -536,7 +536,7 @@ class DjangoAdminSettingsDirectory(AdminScriptTestCase):
|
||||
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):
|
||||
|
||||
1
tests/regressiontests/delete_regress/__init__.py
Normal file
1
tests/regressiontests/delete_regress/__init__.py
Normal file
@ -0,0 +1 @@
|
||||
|
||||
61
tests/regressiontests/delete_regress/models.py
Normal file
61
tests/regressiontests/delete_regress/models.py
Normal file
@ -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())
|
||||
@ -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)
|
||||
"""}
|
||||
@ -161,9 +161,9 @@ class FileStoragePathParsing(TestCase):
|
||||
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 @@ class FileStoragePathParsing(TestCase):
|
||||
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):
|
||||
|
||||
BIN
tests/regressiontests/model_fields/4x8.png
Normal file
BIN
tests/regressiontests/model_fields/4x8.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 87 B |
BIN
tests/regressiontests/model_fields/8x4.png
Normal file
BIN
tests/regressiontests/model_fields/8x4.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 87 B |
420
tests/regressiontests/model_fields/imagefield.py
Normal file
420
tests/regressiontests/model_fields/imagefield.py
Normal file
@ -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)
|
||||
@ -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)
|
||||
@ -37,3 +50,91 @@ class BigD(models.Model):
|
||||
|
||||
class BigS(models.Model):
|
||||
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')
|
||||
|
||||
###############################################################################
|
||||
|
||||
@ -6,13 +6,26 @@ from django import forms
|
||||
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 @@ class SlugFieldTests(django.test.TestCase):
|
||||
bs = BigS.objects.create(s = 'slug'*50)
|
||||
bs = BigS.objects.get(pk=bs.pk)
|
||||
self.assertEqual(bs.s, 'slug'*50)
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user