def test_register_backend(self):
"""
Tests basic usage of register_backend
"""
Image.register_backend(self.FakeBackend)
self.assertEqual(Image.backends, [self.FakeBackend])
def test_switches_backend(self):
"""
Tests that calling an operation will switch backend if the current
backend doesn't support it
"""
def say_hello(backend):
return "Hello world!"
self.FakeBackend.operations = {
'say_hello': say_hello,
}
def say_goodbye(backend):
return "Goodbye!"
self.AnotherFakeBackend.operations = {
'say_goodbye': say_goodbye,
}
image = Image(self.FakeBackend(), 'jpeg')
self.assertIsInstance(image.backend, self.FakeBackend)
image.say_goodbye()
self.assertIsInstance(image.backend, self.AnotherFakeBackend)
image.say_hello()
self.assertIsInstance(image.backend, self.FakeBackend)
def test_register_backend(self):
"""
Tests basic usage of register_backend
"""
Image.register_backend(self.FakeBackend)
self.assertEqual(Image.backends, [self.FakeBackend])
def test_save_as_foo(self):
image = Image()
image.save_as_jpeg = mock.MagicMock()
with self.assertRaises(ValueError):
image.save("foo", "outfile")
self.assertFalse(image.save_as_jpeg.mock_calls)
def test_register_backend_removes_duplicates(self):
"""
Tests register_backend won't insert the same backend more than once
"""
Image.register_backend(self.FakeBackend)
Image.register_backend(self.FakeBackend)
self.assertEqual(Image.backends, [self.FakeBackend])
def test_save_as_foo(self):
image = Image()
image.save_as_jpeg = mock.MagicMock()
with self.assertRaises(ValueError):
image.save("foo", "outfile")
self.assertFalse(image.save_as_jpeg.mock_calls)
def test_register_backend_removes_duplicates(self):
"""
Tests register_backend won't insert the same backend more than once
"""
Image.register_backend(self.FakeBackend)
Image.register_backend(self.FakeBackend)
self.assertEqual(Image.backends, [self.FakeBackend])
def test_register_backend_multiple(self):
"""
Tests register_backend can register multiple backends
"""
Image.register_backend(self.FakeBackend)
Image.register_backend(self.AnotherFakeBackend)
self.assertEqual(Image.backends, [self.FakeBackend, self.AnotherFakeBackend])
def test_raises_error_on_invalid_header(self):
import imghdr
f = io.BytesIO()
f.write(b'Not an image')
f.seek(0)
with self.assertRaises(UnrecognisedImageFormatError) as e:
Image.open(f)
def test_raises_error_on_invalid_header(self):
import imghdr
f = io.BytesIO()
f.write(b'Not an image')
f.seek(0)
with self.assertRaises(UnrecognisedImageFormatError) as e:
Image.open(f)
def test_register_backend_multiple(self):
"""
Tests register_backend can register multiple backends
"""
Image.register_backend(self.FakeBackend)
Image.register_backend(self.AnotherFakeBackend)
self.assertEqual(Image.backends,
[self.FakeBackend, self.AnotherFakeBackend])
def test_register_loader(self):
"""
Tests basic usage of register_loader
"""
Image.register_loader('jpeg', self.FakeBackend)
self.assertEqual(Image.loaders, {
'jpeg': [
(0, self.FakeBackend),
],
})
def has_jpeg_support():
wagtail_jpg = os.path.join(os.path.dirname(__file__), 'check_files', 'wagtail.jpg')
succeeded = True
with open(wagtail_jpg, 'rb') as f:
try:
Image.open(f)
except (IOError, Image.LoaderError):
succeeded = False
return succeeded
def has_jpeg_support():
wagtail_jpg = os.path.join(os.path.dirname(__file__), 'check_files', 'wagtail.jpg')
succeeded = True
with open(wagtail_jpg, 'rb') as f:
try:
Image.open(f)
except (IOError, Image.LoaderError):
succeeded = False
return succeeded
def test_register_loader_priority(self):
"""
Tests that register_loader saves priority
"""
Image.register_loader('jpeg', self.FakeBackend, priority=100)
self.assertEqual(Image.loaders, {
'jpeg': [
(100, self.FakeBackend),
],
})
def test_register_loader_priority(self):
"""
Tests that register_loader saves priority
"""
Image.register_loader('jpeg', self.FakeBackend, priority=100)
self.assertEqual(Image.loaders, {
'jpeg': [
(100, self.FakeBackend),
],
})
def test_register_loader(self):
"""
Tests basic usage of register_loader
"""
Image.register_loader('jpeg', self.FakeBackend)
self.assertEqual(Image.loaders, {
'jpeg': [
(0, self.FakeBackend),
],
})
def has_png_support():
tuiuiu_png = os.path.join(os.path.dirname(__file__), 'check_files',
'tuiuiu.png')
succeeded = True
with open(tuiuiu_png, 'rb') as f:
try:
Image.open(f)
except (IOError, Image.LoaderError):
succeeded = False
return succeeded
def has_png_support():
wagtail_png = os.path.join(os.path.dirname(__file__), "check_files",
"wagtail.png")
succeeded = True
with open(wagtail_png, "rb") as f:
try:
Image.open(f)
except (IOError, Image.LoaderError):
succeeded = False
return succeeded
def test_image_format_detection(self):
Image.loaders = {
'png': [
(0, self.FakeBackend),
],
'jpeg': [
(100, self.AnotherFakeBackend),
],
}
self.assertIsInstance(Image.open('tests/images/transparent.png').backend, self.FakeBackend)
self.assertIsInstance(Image.open('tests/images/flower.jpg').backend, self.AnotherFakeBackend)
def test_register_loader_priority_multiple(self):
"""
Tests that register_loader keeps the loaders list sorted by priority
"""
Image.register_loader('jpeg', self.FakeBackend, priority=100)
Image.register_loader('jpeg', self.AnotherFakeBackend, priority=200)
self.assertEqual(Image.loaders, {
'jpeg': [
(100, self.FakeBackend),
(200, self.AnotherFakeBackend),
],
})
def test_register_loader_priority_multiple(self):
"""
Tests that register_loader keeps the loaders list sorted by priority
"""
Image.register_loader('jpeg', self.FakeBackend, priority=100)
Image.register_loader('jpeg', self.AnotherFakeBackend, priority=200)
self.assertEqual(Image.loaders, {
'jpeg': [
(100, self.FakeBackend),
(200, self.AnotherFakeBackend),
],
})
def test_register_loader_different_extension_at_same_time_with_priority(self):
"""
Tests that register_loader saves priority when using multipe extensions
"""
Image.register_loader(['jpeg', 'gif'], self.FakeBackend, priority=100)
self.assertEqual(Image.loaders, {
'jpeg': [
(100, self.FakeBackend),
],
'gif': [
(100, self.FakeBackend),
],
})
def test_image_detect_stream(self):
Image.loaders = {
'png': [
(0, self.FakeBackend),
],
'jpeg': [
(100, self.AnotherFakeBackend),
],
}
with open('tests/images/transparent.png', 'rb') as f:
self.assertIsInstance(Image.open(f).backend, self.FakeBackend)
with open('tests/images/flower.jpg', 'rb') as f:
self.assertIsInstance(Image.open(f).backend, self.AnotherFakeBackend)
def test_register_loader_priority_same(self):
"""
Tests that new loaders are placed after loaders that have the same
priority
"""
Image.register_loader('jpeg', self.FakeBackend)
Image.register_loader('jpeg', self.AnotherFakeBackend)
self.assertEqual(Image.loaders, {
'jpeg': [
(0, self.FakeBackend),
(0, self.AnotherFakeBackend),
],
})
def test_register_loader_priority_same(self):
"""
Tests that new loaders are placed after loaders that have the same
priority
"""
Image.register_loader('jpeg', self.FakeBackend)
Image.register_loader('jpeg', self.AnotherFakeBackend)
self.assertEqual(Image.loaders, {
'jpeg': [
(0, self.FakeBackend),
(0, self.AnotherFakeBackend),
],
})
def test_register_loader_different_extension_at_same_time_tuple(self):
"""
Tests that a single backend can be assigned to load two extensions with
a single call to register_loader using a tuple
"""
Image.register_loader(('jpeg', 'gif'), self.FakeBackend)
self.assertEqual(Image.loaders, {
'jpeg': [
(0, self.FakeBackend),
],
'gif': [
(0, self.FakeBackend),
],
})
def test_register_loader_different_extension_at_same_time_tuple(self):
"""
Tests that a single backend can be assigned to load two extensions with
a single call to register_loader using a tuple
"""
Image.register_loader(('jpeg', 'gif'), self.FakeBackend)
self.assertEqual(Image.loaders, {
'jpeg': [
(0, self.FakeBackend),
],
'gif': [
(0, self.FakeBackend),
],
})
def test_return_value_gets_passed_back(self):
"""
Tests that the return value of the underlying function gets passed back
to the caller
"""
def myop(backend):
return "Hello world!"
self.FakeBackend.operations = {
'test': myop,
}
image = Image(self.FakeBackend(), 'jpeg')
self.assertEqual(image.test(), "Hello world!")
def test_return_value_gets_passed_back(self):
"""
Tests that the return value of the underlying function gets passed back
to the caller
"""
def myop(backend):
return "Hello world!"
self.FakeBackend.operations = {
'test': myop,
}
image = Image(self.FakeBackend(), 'jpeg')
self.assertEqual(image.test(), "Hello world!")
def test_image_detect_stream(self):
Image.loaders = {
'png': [
(0, self.FakeBackend),
],
'jpeg': [
(100, self.AnotherFakeBackend),
],
}
with open('tests/images/transparent.png', 'rb') as f:
self.assertIsInstance(Image.open(f).backend, self.FakeBackend)
with open('tests/images/flower.jpg', 'rb') as f:
self.assertIsInstance(
Image.open(f).backend, self.AnotherFakeBackend)
def test_register_loader_different_extension(self):
"""
Tests that register_loader stores loaders for different extensions
separately
"""
Image.register_loader('jpeg', self.FakeBackend)
Image.register_loader('gif', self.FakeBackend)
self.assertEqual(Image.loaders, {
'jpeg': [
(0, self.FakeBackend),
],
'gif': [
(0, self.FakeBackend),
],
})
def test_register_loader_priority_multiple_other_way(self):
"""
Tests that register_loader keeps the loaders list sorted by priority
Same as above test, just inserting in opposite way to make sure the
loaders are being sorted by priority (and not insertion order)
"""
Image.register_loader('jpeg', self.FakeBackend, priority=200)
Image.register_loader('jpeg', self.AnotherFakeBackend, priority=100)
self.assertEqual(Image.loaders, {
'jpeg': [
(100, self.AnotherFakeBackend),
(200, self.FakeBackend),
],
})
def test_register_loader_priority_multiple_other_way(self):
"""
Tests that register_loader keeps the loaders list sorted by priority
Same as above test, just inserting in opposite way to make sure the
loaders are being sorted by priority (and not insertion order)
"""
Image.register_loader('jpeg', self.FakeBackend, priority=200)
Image.register_loader('jpeg', self.AnotherFakeBackend, priority=100)
self.assertEqual(Image.loaders, {
'jpeg': [
(100, self.AnotherFakeBackend),
(200, self.FakeBackend),
],
})
def test_image_format_detection(self):
Image.loaders = {
'png': [
(0, self.FakeBackend),
],
'jpeg': [
(100, self.AnotherFakeBackend),
],
}
self.assertIsInstance(
Image.open('tests/images/transparent.png').backend,
self.FakeBackend)
self.assertIsInstance(
Image.open('tests/images/flower.jpg').backend,
self.AnotherFakeBackend)
def test_register_loader_different_extension(self):
"""
Tests that register_loader stores loaders for different extensions
separately
"""
Image.register_loader('jpeg', self.FakeBackend)
Image.register_loader('gif', self.FakeBackend)
self.assertEqual(Image.loaders, {
'jpeg': [
(0, self.FakeBackend),
],
'gif': [
(0, self.FakeBackend),
],
})
def test_calls_function(self):
"""
Tests that calling the operation calls the underlying function
"""
def myop(backend):
backend.func_called = True
self.FakeBackend.operations = {
'test': myop,
}
image = Image(self.FakeBackend(), 'jpeg')
image.backend.func_called = False
image.test()
self.assertTrue(image.backend.func_called)
def test_register_loader_different_extension_at_same_time_with_priority(
self):
"""
Tests that register_loader saves priority when using multipe extensions
"""
Image.register_loader(['jpeg', 'gif'], self.FakeBackend, priority=100)
self.assertEqual(
Image.loaders, {
'jpeg': [
(100, self.FakeBackend),
],
'gif': [
(100, self.FakeBackend),
],
})
def __init__(self, path):
fp = open(path, 'rb')
img = Image.open(fp)
dimensions = img.get_size()
self.width = dimensions[0]
self.height = dimensions[1]
def get_willow_image(self):
# Open file if it is closed
close_file = False
try:
image_file = self.file
if self.file.closed:
# Reopen the file
if self.is_stored_locally():
self.file.open('rb')
else:
# Some external storage backends don't allow reopening
# the file. Get a fresh file instance. #1397
storage = self._meta.get_field('file').storage
image_file = storage.open(self.file.name, 'rb')
close_file = True
except IOError as e:
# re-throw this as a SourceImageIOError so that calling code can distinguish
# these from IOErrors elsewhere in the process
raise SourceImageIOError(text_type(e))
# Seek to beginning
image_file.seek(0)
try:
yield WillowImage.open(image_file)
finally:
if close_file:
image_file.close()
def test_calls_function(self):
"""
Tests that calling the operation calls the underlying function
"""
def myop(backend):
backend.func_called = True
self.FakeBackend.operations = {
'test': myop,
}
image = Image(self.FakeBackend(), 'jpeg')
image.backend.func_called = False
image.test()
self.assertTrue(image.backend.func_called)
def get_willow_image(self):
# Open file if it is closed
close_file = False
try:
image_file = self.file
if self.file.closed:
# Reopen the file
if self.is_stored_locally():
self.file.open('rb')
else:
# Some external storage backends don't allow reopening
# the file. Get a fresh file instance. #1397
storage = self._meta.get_field('file').storage
image_file = storage.open(self.file.name, 'rb')
close_file = True
except IOError as e:
# re-throw this as a SourceImageIOError so that calling code can distinguish
# these from IOErrors elsewhere in the process
raise SourceImageIOError(text_type(e))
# Seek to beginning
image_file.seek(0)
try:
yield WillowImage.open(image_file)
finally:
if close_file:
image_file.close()
def test_register_loader_priority_same_other_way(self):
"""
If multiple backends are inserted with the same priority, the last one
should be placed last in the list
Same as above test, just inserting in opposite way to make sure the
loaders are being sorted by insertion time (and not name)
"""
Image.register_loader('jpeg', self.AnotherFakeBackend)
Image.register_loader('jpeg', self.FakeBackend)
self.assertEqual(Image.loaders, {
'jpeg': [
(0, self.AnotherFakeBackend),
(0, self.FakeBackend),
],
})
def test_tiff(self):
with open('tests/images/cameraman.tif', 'rb') as f:
image = Image.open(f)
width, height = image.get_size()
self.assertIsInstance(image, TIFFImageFile)
self.assertEqual(width, 256)
self.assertEqual(height, 256)
def test_bmp(self):
with open('tests/images/sails.bmp', 'rb') as f:
image = Image.open(f)
width, height = image.get_size()
self.assertIsInstance(image, BMPImageFile)
self.assertEqual(width, 768)
self.assertEqual(height, 512)
def convert_bmp_image(self, file_path):
new_file_path = file_path.replace("bmp", "jpg")
with open(file_path, 'rb') as f:
img = WillowImage.open(f)
output = open(new_file_path, 'wb')
img.save_as_jpeg(output)
output.close()
return new_file_path
def test_register_loader_priority_same_other_way(self):
"""
If multiple backends are inserted with the same priority, the last one
should be placed last in the list
Same as above test, just inserting in opposite way to make sure the
loaders are being sorted by insertion time (and not name)
"""
Image.register_loader('jpeg', self.AnotherFakeBackend)
Image.register_loader('jpeg', self.FakeBackend)
self.assertEqual(Image.loaders, {
'jpeg': [
(0, self.AnotherFakeBackend),
(0, self.FakeBackend),
],
})
def test_args_get_passed_through(self):
"""
Tests that args get passed through to the underlying function
"""
def myop(backend, *args, **kwargs):
backend.passed_args = args
backend.passed_kwargs = kwargs
self.FakeBackend.operations = {
'test': myop,
}
image = Image(self.FakeBackend(), 'jpeg')
image.backend.passed_args = None
image.backend.passed_kwargs = None
image.test('Hello', 'World', name="Karl")
self.assertEqual(image.backend.passed_args, ('Hello', 'World'))
self.assertEqual(image.backend.passed_kwargs, {'name': "Karl"})
def test_args_get_passed_through(self):
"""
Tests that args get passed through to the underlying function
"""
def myop(backend, *args, **kwargs):
backend.passed_args = args
backend.passed_kwargs = kwargs
self.FakeBackend.operations = {
'test': myop,
}
image = Image(self.FakeBackend(), 'jpeg')
image.backend.passed_args = None
image.backend.passed_kwargs = None
image.test('Hello', 'World', name="Karl")
self.assertEqual(image.backend.passed_args, ('Hello', 'World'))
self.assertEqual(image.backend.passed_kwargs, {'name': "Karl"})
def test_opens_png(self):
import imghdr
f = io.BytesIO()
f.write(b'\x89PNG\x0d\x0a\x1a\x0a')
f.seek(0)
image = Image.open(f)
self.assertIsInstance(image, PNGImageFile)
self.assertEqual(image.format_name, 'png')
self.assertEqual(image.original_format, 'png')
def test_opens_jpeg(self):
import imghdr
f = io.BytesIO()
f.write(b'\xff\xd8\xff\xe0\x00\x10JFIF\x00')
f.seek(0)
image = Image.open(f)
self.assertIsInstance(image, JPEGImageFile)
self.assertEqual(image.format_name, 'jpeg')
self.assertEqual(image.original_format, 'jpeg')
def test_opens_png(self):
import imghdr
f = io.BytesIO()
f.write(b'\x89PNG\x0d\x0a\x1a\x0a')
f.seek(0)
image = Image.open(f)
self.assertIsInstance(image, PNGImageFile)
self.assertEqual(image.format_name, 'png')
self.assertEqual(image.original_format, 'png')
def test_opens_gif(self):
import imghdr
f = io.BytesIO()
f.write(b'GIF89a')
f.seek(0)
image = Image.open(f)
self.assertIsInstance(image, GIFImageFile)
self.assertEqual(image.format_name, 'gif')
self.assertEqual(image.original_format, 'gif')
def test_find_loader(self):
"""
Tests basic usage of find_loader
"""
Image.loaders = {
'jpeg': [
(0, self.FakeBackend),
],
}
self.assertEqual(Image.find_loader('jpeg'), self.FakeBackend)
def test_opens_gif(self):
import imghdr
f = io.BytesIO()
f.write(b'GIF89a')
f.seek(0)
image = Image.open(f)
self.assertIsInstance(image, GIFImageFile)
self.assertEqual(image.format_name, 'gif')
self.assertEqual(image.original_format, 'gif')
def test_find_loader(self):
"""
Tests basic usage of find_loader
"""
Image.loaders = {
'jpeg': [
(0, self.FakeBackend),
],
}
self.assertEqual(Image.find_loader('jpeg'), self.FakeBackend)
def test_find_loader_priority(self):
"""
Tests that find_loader gets the backend with the highest priority
"""
Image.loaders = {
'jpeg': [
(100, self.FakeBackend),
(200, self.AnotherFakeBackend),
],
}
self.assertEqual(Image.find_loader('jpeg'), self.AnotherFakeBackend)
def get_willow_image(self):
try:
image_file = self.file.file # triggers a call to self.storage.open, so IOErrors from missing files will be raised at this point
except IOError as e:
# re-throw this as a SourceImageIOError so that calling code can distinguish
# these from IOErrors elsewhere in the process
raise SourceImageIOError(text_type(e))
image_file.open('rb')
image_file.seek(0)
return WillowImage.open(image_file)
def test_find_operation_unknown_operation(self):
"""
Tests find_operation returns None when the operation name is not
registered
"""
def myop(backend):
pass
self.FakeBackend.operations = {
'test': myop,
}
self.assertIsNone(Image.find_operation('test2'))
