mirror of
https://github.com/django/django.git
synced 2024-11-25 16:09:27 +01:00
381 lines
14 KiB
Python
381 lines
14 KiB
Python
import errno
|
|
import gzip
|
|
import os
|
|
import struct
|
|
import tempfile
|
|
import unittest
|
|
from io import BytesIO, StringIO, TextIOWrapper
|
|
from unittest import mock
|
|
|
|
from django.core.files import File
|
|
from django.core.files.base import ContentFile
|
|
from django.core.files.move import file_move_safe
|
|
from django.core.files.temp import NamedTemporaryFile
|
|
from django.core.files.uploadedfile import (
|
|
InMemoryUploadedFile, SimpleUploadedFile, UploadedFile,
|
|
)
|
|
|
|
try:
|
|
from PIL import Image
|
|
except ImportError:
|
|
Image = None
|
|
else:
|
|
from django.core.files import images
|
|
|
|
|
|
class FileTests(unittest.TestCase):
|
|
def test_unicode_uploadedfile_name(self):
|
|
uf = UploadedFile(name='¿Cómo?', content_type='text')
|
|
self.assertIs(type(repr(uf)), str)
|
|
|
|
def test_unicode_file_name(self):
|
|
f = File(None, 'djángö')
|
|
self.assertIs(type(repr(f)), str)
|
|
|
|
def test_context_manager(self):
|
|
orig_file = tempfile.TemporaryFile()
|
|
base_file = File(orig_file)
|
|
with base_file as f:
|
|
self.assertIs(base_file, f)
|
|
self.assertFalse(f.closed)
|
|
self.assertTrue(f.closed)
|
|
self.assertTrue(orig_file.closed)
|
|
|
|
def test_open_resets_opened_file_to_start_and_returns_context_manager(self):
|
|
file = File(BytesIO(b'content'))
|
|
file.read()
|
|
with file.open() as f:
|
|
self.assertEqual(f.read(), b'content')
|
|
|
|
def test_open_reopens_closed_file_and_returns_context_manager(self):
|
|
temporary_file = tempfile.NamedTemporaryFile(delete=False)
|
|
file = File(temporary_file)
|
|
try:
|
|
file.close()
|
|
with file.open() as f:
|
|
self.assertFalse(f.closed)
|
|
finally:
|
|
# remove temporary file
|
|
os.unlink(file.name)
|
|
|
|
def test_namedtemporaryfile_closes(self):
|
|
"""
|
|
The symbol django.core.files.NamedTemporaryFile is assigned as
|
|
a different class on different operating systems. In
|
|
any case, the result should minimally mock some of the API of
|
|
tempfile.NamedTemporaryFile from the Python standard library.
|
|
"""
|
|
tempfile = NamedTemporaryFile()
|
|
self.assertTrue(hasattr(tempfile, "closed"))
|
|
self.assertFalse(tempfile.closed)
|
|
|
|
tempfile.close()
|
|
self.assertTrue(tempfile.closed)
|
|
|
|
def test_file_mode(self):
|
|
# Should not set mode to None if it is not present.
|
|
# See #14681, stdlib gzip module crashes if mode is set to None
|
|
file = SimpleUploadedFile("mode_test.txt", b"content")
|
|
self.assertFalse(hasattr(file, 'mode'))
|
|
gzip.GzipFile(fileobj=file)
|
|
|
|
def test_file_iteration(self):
|
|
"""
|
|
File objects should yield lines when iterated over.
|
|
Refs #22107.
|
|
"""
|
|
file = File(BytesIO(b'one\ntwo\nthree'))
|
|
self.assertEqual(list(file), [b'one\n', b'two\n', b'three'])
|
|
|
|
def test_file_iteration_windows_newlines(self):
|
|
"""
|
|
#8149 - File objects with \r\n line endings should yield lines
|
|
when iterated over.
|
|
"""
|
|
f = File(BytesIO(b'one\r\ntwo\r\nthree'))
|
|
self.assertEqual(list(f), [b'one\r\n', b'two\r\n', b'three'])
|
|
|
|
def test_file_iteration_mac_newlines(self):
|
|
"""
|
|
#8149 - File objects with \r line endings should yield lines
|
|
when iterated over.
|
|
"""
|
|
f = File(BytesIO(b'one\rtwo\rthree'))
|
|
self.assertEqual(list(f), [b'one\r', b'two\r', b'three'])
|
|
|
|
def test_file_iteration_mixed_newlines(self):
|
|
f = File(BytesIO(b'one\rtwo\nthree\r\nfour'))
|
|
self.assertEqual(list(f), [b'one\r', b'two\n', b'three\r\n', b'four'])
|
|
|
|
def test_file_iteration_with_unix_newline_at_chunk_boundary(self):
|
|
f = File(BytesIO(b'one\ntwo\nthree'))
|
|
# Set chunk size to create a boundary after \n:
|
|
# b'one\n...
|
|
# ^
|
|
f.DEFAULT_CHUNK_SIZE = 4
|
|
self.assertEqual(list(f), [b'one\n', b'two\n', b'three'])
|
|
|
|
def test_file_iteration_with_windows_newline_at_chunk_boundary(self):
|
|
f = File(BytesIO(b'one\r\ntwo\r\nthree'))
|
|
# Set chunk size to create a boundary between \r and \n:
|
|
# b'one\r\n...
|
|
# ^
|
|
f.DEFAULT_CHUNK_SIZE = 4
|
|
self.assertEqual(list(f), [b'one\r\n', b'two\r\n', b'three'])
|
|
|
|
def test_file_iteration_with_mac_newline_at_chunk_boundary(self):
|
|
f = File(BytesIO(b'one\rtwo\rthree'))
|
|
# Set chunk size to create a boundary after \r:
|
|
# b'one\r...
|
|
# ^
|
|
f.DEFAULT_CHUNK_SIZE = 4
|
|
self.assertEqual(list(f), [b'one\r', b'two\r', b'three'])
|
|
|
|
def test_file_iteration_with_text(self):
|
|
f = File(StringIO('one\ntwo\nthree'))
|
|
self.assertEqual(list(f), ['one\n', 'two\n', 'three'])
|
|
|
|
def test_readable(self):
|
|
with tempfile.TemporaryFile() as temp, File(temp, name='something.txt') as test_file:
|
|
self.assertTrue(test_file.readable())
|
|
self.assertFalse(test_file.readable())
|
|
|
|
def test_writable(self):
|
|
with tempfile.TemporaryFile() as temp, File(temp, name='something.txt') as test_file:
|
|
self.assertTrue(test_file.writable())
|
|
self.assertFalse(test_file.writable())
|
|
with tempfile.TemporaryFile('rb') as temp, File(temp, name='something.txt') as test_file:
|
|
self.assertFalse(test_file.writable())
|
|
|
|
def test_seekable(self):
|
|
with tempfile.TemporaryFile() as temp, File(temp, name='something.txt') as test_file:
|
|
self.assertTrue(test_file.seekable())
|
|
self.assertFalse(test_file.seekable())
|
|
|
|
def test_io_wrapper(self):
|
|
content = "vive l'été\n"
|
|
with tempfile.TemporaryFile() as temp, File(temp, name='something.txt') as test_file:
|
|
test_file.write(content.encode())
|
|
test_file.seek(0)
|
|
wrapper = TextIOWrapper(test_file, 'utf-8', newline='\n')
|
|
self.assertEqual(wrapper.read(), content)
|
|
wrapper.write(content)
|
|
wrapper.seek(0)
|
|
self.assertEqual(wrapper.read(), content * 2)
|
|
test_file = wrapper.detach()
|
|
test_file.seek(0)
|
|
self.assertEqual(test_file.read(), (content * 2).encode())
|
|
|
|
|
|
class NoNameFileTestCase(unittest.TestCase):
|
|
"""
|
|
Other examples of unnamed files may be tempfile.SpooledTemporaryFile or
|
|
urllib.urlopen()
|
|
"""
|
|
def test_noname_file_default_name(self):
|
|
self.assertIsNone(File(BytesIO(b'A file with no name')).name)
|
|
|
|
def test_noname_file_get_size(self):
|
|
self.assertEqual(File(BytesIO(b'A file with no name')).size, 19)
|
|
|
|
|
|
class ContentFileTestCase(unittest.TestCase):
|
|
def test_content_file_default_name(self):
|
|
self.assertIsNone(ContentFile(b"content").name)
|
|
|
|
def test_content_file_custom_name(self):
|
|
"""
|
|
The constructor of ContentFile accepts 'name' (#16590).
|
|
"""
|
|
name = "I can have a name too!"
|
|
self.assertEqual(ContentFile(b"content", name=name).name, name)
|
|
|
|
def test_content_file_input_type(self):
|
|
"""
|
|
ContentFile can accept both bytes and strings and the retrieved content
|
|
is of the same type.
|
|
"""
|
|
self.assertIsInstance(ContentFile(b"content").read(), bytes)
|
|
self.assertIsInstance(ContentFile("español").read(), str)
|
|
|
|
def test_open_resets_file_to_start_and_returns_context_manager(self):
|
|
file = ContentFile(b'content')
|
|
with file.open() as f:
|
|
self.assertEqual(f.read(), b'content')
|
|
with file.open() as f:
|
|
self.assertEqual(f.read(), b'content')
|
|
|
|
|
|
class InMemoryUploadedFileTests(unittest.TestCase):
|
|
def test_open_resets_file_to_start_and_returns_context_manager(self):
|
|
uf = InMemoryUploadedFile(StringIO('1'), '', 'test', 'text/plain', 1, 'utf8')
|
|
uf.read()
|
|
with uf.open() as f:
|
|
self.assertEqual(f.read(), '1')
|
|
|
|
|
|
class DimensionClosingBug(unittest.TestCase):
|
|
"""
|
|
get_image_dimensions() properly closes files (#8817)
|
|
"""
|
|
@unittest.skipUnless(Image, "Pillow not installed")
|
|
def test_not_closing_of_files(self):
|
|
"""
|
|
Open files passed into get_image_dimensions() should stay opened.
|
|
"""
|
|
empty_io = BytesIO()
|
|
try:
|
|
images.get_image_dimensions(empty_io)
|
|
finally:
|
|
self.assertTrue(not empty_io.closed)
|
|
|
|
@unittest.skipUnless(Image, "Pillow not installed")
|
|
def test_closing_of_filenames(self):
|
|
"""
|
|
get_image_dimensions() called with a filename should closed the file.
|
|
"""
|
|
# We need to inject a modified open() builtin into the images module
|
|
# that checks if the file was closed properly if the function is
|
|
# called with a filename instead of an file object.
|
|
# get_image_dimensions will call our catching_open instead of the
|
|
# regular builtin one.
|
|
|
|
class FileWrapper:
|
|
_closed = []
|
|
|
|
def __init__(self, f):
|
|
self.f = f
|
|
|
|
def __getattr__(self, name):
|
|
return getattr(self.f, name)
|
|
|
|
def close(self):
|
|
self._closed.append(True)
|
|
self.f.close()
|
|
|
|
def catching_open(*args):
|
|
return FileWrapper(open(*args))
|
|
|
|
images.open = catching_open
|
|
try:
|
|
images.get_image_dimensions(os.path.join(os.path.dirname(__file__), "test1.png"))
|
|
finally:
|
|
del images.open
|
|
self.assertTrue(FileWrapper._closed)
|
|
|
|
|
|
class InconsistentGetImageDimensionsBug(unittest.TestCase):
|
|
"""
|
|
get_image_dimensions() works properly after various calls
|
|
using a file handler (#11158)
|
|
"""
|
|
@unittest.skipUnless(Image, "Pillow not installed")
|
|
def test_multiple_calls(self):
|
|
"""
|
|
Multiple calls of get_image_dimensions() should return the same size.
|
|
"""
|
|
img_path = os.path.join(os.path.dirname(__file__), "test.png")
|
|
with open(img_path, 'rb') as fh:
|
|
image = images.ImageFile(fh)
|
|
image_pil = Image.open(fh)
|
|
size_1 = images.get_image_dimensions(image)
|
|
size_2 = images.get_image_dimensions(image)
|
|
self.assertEqual(image_pil.size, size_1)
|
|
self.assertEqual(size_1, size_2)
|
|
|
|
@unittest.skipUnless(Image, "Pillow not installed")
|
|
def test_bug_19457(self):
|
|
"""
|
|
Regression test for #19457
|
|
get_image_dimensions fails on some pngs, while Image.size is working good on them
|
|
"""
|
|
img_path = os.path.join(os.path.dirname(__file__), "magic.png")
|
|
size = images.get_image_dimensions(img_path)
|
|
with open(img_path, 'rb') as fh:
|
|
self.assertEqual(size, Image.open(fh).size)
|
|
|
|
|
|
@unittest.skipUnless(Image, "Pillow not installed")
|
|
class GetImageDimensionsTests(unittest.TestCase):
|
|
|
|
def test_invalid_image(self):
|
|
"""
|
|
get_image_dimensions() should return (None, None) for the dimensions of
|
|
invalid images (#24441).
|
|
|
|
brokenimg.png is not a valid image and it has been generated by:
|
|
$ echo "123" > brokenimg.png
|
|
"""
|
|
img_path = os.path.join(os.path.dirname(__file__), "brokenimg.png")
|
|
with open(img_path, 'rb') as fh:
|
|
size = images.get_image_dimensions(fh)
|
|
self.assertEqual(size, (None, None))
|
|
|
|
def test_valid_image(self):
|
|
"""
|
|
get_image_dimensions() should catch struct.error while feeding the PIL
|
|
Image parser (#24544).
|
|
|
|
Emulates the Parser feed error. Since the error is raised on every feed
|
|
attempt, the resulting image size should be invalid: (None, None).
|
|
"""
|
|
img_path = os.path.join(os.path.dirname(__file__), "test.png")
|
|
with mock.patch('PIL.ImageFile.Parser.feed', side_effect=struct.error):
|
|
with open(img_path, 'rb') as fh:
|
|
size = images.get_image_dimensions(fh)
|
|
self.assertEqual(size, (None, None))
|
|
|
|
|
|
class FileMoveSafeTests(unittest.TestCase):
|
|
def test_file_move_overwrite(self):
|
|
handle_a, self.file_a = tempfile.mkstemp()
|
|
handle_b, self.file_b = tempfile.mkstemp()
|
|
|
|
# file_move_safe should raise an IOError exception if destination file exists and allow_overwrite is False
|
|
with self.assertRaises(IOError):
|
|
file_move_safe(self.file_a, self.file_b, allow_overwrite=False)
|
|
|
|
# should allow it and continue on if allow_overwrite is True
|
|
self.assertIsNone(file_move_safe(self.file_a, self.file_b, allow_overwrite=True))
|
|
|
|
os.close(handle_a)
|
|
os.close(handle_b)
|
|
|
|
def test_file_move_copystat_cifs(self):
|
|
"""
|
|
file_move_safe() ignores a copystat() EPERM PermissionError. This
|
|
happens when the destination filesystem is CIFS, for example.
|
|
"""
|
|
copystat_EACCES_error = PermissionError(errno.EACCES, 'msg')
|
|
copystat_EPERM_error = PermissionError(errno.EPERM, 'msg')
|
|
handle_a, self.file_a = tempfile.mkstemp()
|
|
handle_b, self.file_b = tempfile.mkstemp()
|
|
try:
|
|
# This exception is required to reach the copystat() call in
|
|
# file_safe_move().
|
|
with mock.patch('django.core.files.move.os.rename', side_effect=OSError()):
|
|
# An error besides EPERM isn't ignored.
|
|
with mock.patch('django.core.files.move.copystat', side_effect=copystat_EACCES_error):
|
|
with self.assertRaises(PermissionError):
|
|
file_move_safe(self.file_a, self.file_b, allow_overwrite=True)
|
|
# EPERM is ignored.
|
|
with mock.patch('django.core.files.move.copystat', side_effect=copystat_EPERM_error):
|
|
self.assertIsNone(file_move_safe(self.file_a, self.file_b, allow_overwrite=True))
|
|
finally:
|
|
os.close(handle_a)
|
|
os.close(handle_b)
|
|
|
|
|
|
class SpooledTempTests(unittest.TestCase):
|
|
def test_in_memory_spooled_temp(self):
|
|
with tempfile.SpooledTemporaryFile() as temp:
|
|
temp.write(b"foo bar baz quux\n")
|
|
django_file = File(temp, name="something.txt")
|
|
self.assertEqual(django_file.size, 17)
|
|
|
|
def test_written_spooled_temp(self):
|
|
with tempfile.SpooledTemporaryFile(max_size=4) as temp:
|
|
temp.write(b"foo bar baz quux\n")
|
|
django_file = File(temp, name="something.txt")
|
|
self.assertEqual(django_file.size, 17)
|