Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

274 lines (228 sloc) 9.353 kb
from django.db import models
from easy_thumbnails import files, fields, signals, signal_handlers
from easy_thumbnails.alias import aliases
from easy_thumbnails.conf import settings
from easy_thumbnails import test
class Profile(models.Model):
avatar = fields.ThumbnailerField(upload_to='avatars')
logo = models.FileField(upload_to='avatars')
class Meta:
app_label = 'some_app'
class BaseTest(test.BaseTest):
create_file = False
def setUp(self):
super(BaseTest, self).setUp()
settings.THUMBNAIL_ALIASES = {
'': {
'large': {'size': (500, 500)},
'medium': {'size': (300, 300)},
'small': {'size': (100, 100)},
},
'some_app.Profile': {
'large': {'size': (200, 200)},
'banner': {'size': (600, 80), 'crop': True},
},
'some_app.Profile.avatar': {
'avatar': {'size': (80, 80), 'crop': True},
'small': {'size': (20, 20), 'crop': True},
},
'other_app': {
'sidebar': {'size': (150, 250)},
}
}
self.__aliases = aliases._aliases
aliases._aliases = {}
aliases.populate_from_settings()
if self.create_file:
self.storage = test.TemporaryStorage()
# Save a test image.
self.create_image(self.storage, 'avatars/test.jpg')
# Set the test model to use the current temporary storage.
Profile._meta.get_field('avatar').storage = self.storage
Profile._meta.get_field('avatar').thumbnail_storage = self.storage
def tearDown(self):
aliases._aliases = self.__aliases
if self.create_file:
self.storage.delete_temporary_storage()
super(BaseTest, self).tearDown()
class AliasTest(BaseTest):
def test_global(self):
self.assertEqual(aliases.get('invalid'), None)
self.assertEqual(aliases.get('small'), {'size': (100, 100)})
self.assertEqual(aliases.get('avatar'), None)
self.assertEqual(aliases.get('banner'), None)
def test_target(self):
self.assertEqual(
aliases.get('avatar', target='some_app.Profile.avatar'),
{'size': (80, 80), 'crop': True})
self.assertEqual(
aliases.get('small', target='some_app.Profile.avatar'),
{'size': (20, 20), 'crop': True})
def test_partial_target(self):
self.assertEqual(
aliases.get('banner', target='some_app.Profile.avatar'),
{'size': (600, 80), 'crop': True})
self.assertEqual(
aliases.get('banner', target='some_app.Profile'),
{'size': (600, 80), 'crop': True})
self.assertEqual(aliases.get('banner', target='some_app'), None)
def test_target_fallback(self):
# Unknown target.
self.assertEqual(
aliases.get('small', target='some_app.Profile.not_avatar'),
{'size': (100, 100)})
# Known target with no matching alias (but a matching global alias).
self.assertEqual(
aliases.get('medium', target='some_app.Profile.avatar'),
{'size': (300, 300)})
# Known target with no matching alias.
self.assertEqual(
aliases.get('invalid', target='some_app.Profile.avatar'),
None)
def test_all(self):
self.assertEqual(
aliases.all(),
{
'large': {'size': (500, 500)},
'medium': {'size': (300, 300)},
'small': {'size': (100, 100)},
})
self.assertEqual(
aliases.all('unknown_app'),
{
'large': {'size': (500, 500)},
'medium': {'size': (300, 300)},
'small': {'size': (100, 100)},
})
self.assertEqual(
aliases.all('some_app.Profile'),
{
'banner': {'size': (600, 80), 'crop': True},
'large': {'size': (200, 200)},
'medium': {'size': (300, 300)},
'small': {'size': (100, 100)},
})
self.assertEqual(
aliases.all('some_app.Profile.avatar'),
{
'avatar': {'size': (80, 80), 'crop': True},
'banner': {'size': (600, 80), 'crop': True},
'large': {'size': (200, 200)},
'medium': {'size': (300, 300)},
'small': {'crop': True, 'size': (20, 20)},
})
def test_all_no_global(self):
self.assertEqual(
aliases.all('some_app.Profile', include_global=False),
{
'banner': {'size': (600, 80), 'crop': True},
'large': {'size': (200, 200)},
})
self.assertEqual(
aliases.all('some_app.Profile.avatar', include_global=False),
{
'avatar': {'size': (80, 80), 'crop': True},
'banner': {'size': (600, 80), 'crop': True},
'large': {'size': (200, 200)},
'small': {'crop': True, 'size': (20, 20)},
})
class AliasThumbnailerTest(BaseTest):
create_file = True
def test_thumbnailer(self):
thumbnailer = files.get_thumbnailer(self.storage, 'avatars/test.jpg')
thumbnailer.thumbnail_storage = self.storage
thumb = thumbnailer['small']
self.assertEqual((thumb.width, thumb.height), (100, 75))
def test_thumbnailer_fieldfile(self):
profile = Profile(avatar='avatars/test.jpg')
thumbnailer = files.get_thumbnailer(profile.avatar)
thumb = thumbnailer['small']
self.assertEqual((thumb.width, thumb.height), (20, 20))
class GenerationBase(BaseTest):
create_file = True
def get_signal_handler(self):
return NotImplementedError("Subclasses should return the handler")
def setUp(self):
super(GenerationBase, self).setUp()
signals.saved_file.connect(self.get_signal_handler(), sender=Profile)
# Fix the standard storage to use the test's temporary location.
settings.MEDIA_ROOT = self.storage.temporary_location
def tearDown(self):
signals.saved_file.disconnect(
self.get_signal_handler(), sender=Profile)
super(GenerationBase, self).tearDown()
def fake_save(self, instance):
cls = instance.__class__
models.signals.pre_save.send(sender=cls, instance=instance)
for field in cls._meta.fields:
if isinstance(field, models.FileField):
getattr(instance, field.name)._committed = True
models.signals.post_save.send(sender=cls, instance=instance)
return self.storage.listdir('avatars')[1]
class GenerationTest(GenerationBase):
"""
Test the ``generate_aliases`` signal handler behaviour.
"""
def get_signal_handler(self):
return signal_handlers.generate_aliases
def test_empty(self):
"""
Thumbnails are not generated if there isn't anything to generate...
"""
profile = Profile(avatar=None)
files = self.fake_save(profile)
self.assertEqual(len(files), 1)
def test_no_change(self):
"""
Thumbnails are only generated when the file is modified.
"""
profile = Profile(avatar='avatars/test.jpg')
files = self.fake_save(profile)
self.assertEqual(len(files), 1)
def test_changed(self):
"""
When a file is modified, thumbnails are built for all matching
non-global aliases.
"""
profile = Profile(avatar='avatars/test.jpg')
profile.avatar._committed = False
files = self.fake_save(profile)
# 1 source, 4 thumbs.
self.assertEqual(len(files), 5)
def test_deleted(self):
profile = Profile(avatar='avatars/test.jpg')
profile.avatar.delete(save=False)
files = self.fake_save(profile)
self.assertEqual(len(files), 0)
def test_standard_filefield(self):
profile = Profile(avatar='avatars/test.jpg')
# Attach a File object to the FileField descriptor, emulating an
# upload.
profile.logo = self.storage.open(
self.create_image(self.storage, 'avatars/second.jpg'))
list_files = self.fake_save(profile)
# 2 source, 2 thumbs.
self.assertEqual(len(list_files), 4)
class GlobalGenerationTest(GenerationBase):
"""
Test the ``generate_aliases_global`` signal handler behaviour.
"""
def get_signal_handler(self):
return signal_handlers.generate_aliases_global
def test_no_change(self):
"""
Thumbnails are only generated when the file is modified.
"""
profile = Profile(avatar='avatars/test.jpg')
files = self.fake_save(profile)
self.assertEqual(len(files), 1)
def test_changed(self):
"""
When a file is modified, thumbnails are built for all matching and
project-wide aliases.
"""
profile = Profile(avatar='avatars/test.jpg')
profile.avatar._committed = False
files = self.fake_save(profile)
# 1 source, 4 specific thumbs, 1 project-wide thumb.
self.assertEqual(len(files), 6)
Jump to Line
Something went wrong with that request. Please try again.