Debian Codegraph @

tests/file_storage/test_inmemory_storage.py

raw
1 import os
2 import sys
3 import time
4 import unittest
5
6 from django.core.files.base import ContentFile
7 from django.core.files.storage import InMemoryStorage
8 from django.core.files.uploadedfile import TemporaryUploadedFile
9 from django.test import SimpleTestCase, override_settings
10
11
12 class MemoryStorageIOTests(unittest.TestCase):
13 def setUp(self):
14 self.storage = InMemoryStorage()
15
16 def test_write_string(self):
17 with self.storage.open("file.txt", "w") as fd:
18 fd.write("hello")
19 with self.storage.open("file.txt", "r") as fd:
20 self.assertEqual(fd.read(), "hello")
21 with self.storage.open("file.dat", "wb") as fd:
22 fd.write(b"hello")
23 with self.storage.open("file.dat", "rb") as fd:
24 self.assertEqual(fd.read(), b"hello")
25
26 def test_convert_str_to_bytes_and_back(self):
27 """InMemoryStorage handles conversion from str to bytes and back."""
28 with self.storage.open("file.txt", "w") as fd:
29 fd.write("hello")
30 with self.storage.open("file.txt", "rb") as fd:
31 self.assertEqual(fd.read(), b"hello")
32 with self.storage.open("file.dat", "wb") as fd:
33 fd.write(b"hello")
34 with self.storage.open("file.dat", "r") as fd:
35 self.assertEqual(fd.read(), "hello")
36
37 def test_open_missing_file(self):
38 self.assertRaises(FileNotFoundError, self.storage.open, "missing.txt")
39
40 def test_open_dir_as_file(self):
41 with self.storage.open("a/b/file.txt", "w") as fd:
42 fd.write("hello")
43 self.assertRaises(IsADirectoryError, self.storage.open, "a/b")
44
45 def test_file_saving(self):
46 self.storage.save("file.txt", ContentFile("test"))
47 self.assertEqual(self.storage.open("file.txt", "r").read(), "test")
48
49 self.storage.save("file.dat", ContentFile(b"test"))
50 self.assertEqual(self.storage.open("file.dat", "rb").read(), b"test")
51
52 @unittest.skipIf(
53 sys.platform == "win32", "Windows doesn't support moving open files."
54 )
55 def test_removing_temporary_file_after_save(self):
56 """A temporary file is removed when saved into storage."""
57 with TemporaryUploadedFile("test", "text/plain", 1, "utf8") as file:
58 self.storage.save("test.txt", file)
59 self.assertFalse(os.path.exists(file.temporary_file_path()))
60
61 def test_large_file_saving(self):
62 large_file = ContentFile("A" * ContentFile.DEFAULT_CHUNK_SIZE * 3)
63 self.storage.save("file.txt", large_file)
64
65 def test_file_size(self):
66 """
67 File size is equal to the size of bytes-encoded version of the saved
68 data.
69 """
70 self.storage.save("file.txt", ContentFile("test"))
71 self.assertEqual(self.storage.size("file.txt"), 4)
72
73 # A unicode char encoded to UTF-8 takes 2 bytes.
74 self.storage.save("unicode_file.txt", ContentFile("รจ"))
75 self.assertEqual(self.storage.size("unicode_file.txt"), 2)
76
77 self.storage.save("file.dat", ContentFile(b"\xf1\xf1"))
78 self.assertEqual(self.storage.size("file.dat"), 2)
79
80 def test_listdir(self):
81 self.assertEqual(self.storage.listdir(""), ([], []))
82
83 self.storage.save("file_a.txt", ContentFile("test"))
84 self.storage.save("file_b.txt", ContentFile("test"))
85 self.storage.save("dir/file_c.txt", ContentFile("test"))
86
87 dirs, files = self.storage.listdir("")
88 self.assertEqual(sorted(files), ["file_a.txt", "file_b.txt"])
89 self.assertEqual(dirs, ["dir"])
90
91 def test_list_relative_path(self):
92 self.storage.save("a/file.txt", ContentFile("test"))
93
94 _dirs, files = self.storage.listdir("./a/./.")
95 self.assertEqual(files, ["file.txt"])
96
97 def test_exists(self):
98 self.storage.save("dir/subdir/file.txt", ContentFile("test"))
99 self.assertTrue(self.storage.exists("dir"))
100 self.assertTrue(self.storage.exists("dir/subdir"))
101 self.assertTrue(self.storage.exists("dir/subdir/file.txt"))
102
103 def test_delete(self):
104 """Deletion handles both files and directory trees."""
105 self.storage.save("dir/subdir/file.txt", ContentFile("test"))
106 self.storage.save("dir/subdir/other_file.txt", ContentFile("test"))
107 self.assertTrue(self.storage.exists("dir/subdir/file.txt"))
108 self.assertTrue(self.storage.exists("dir/subdir/other_file.txt"))
109
110 self.storage.delete("dir/subdir/other_file.txt")
111 self.assertFalse(self.storage.exists("dir/subdir/other_file.txt"))
112
113 self.storage.delete("dir/subdir")
114 self.assertFalse(self.storage.exists("dir/subdir/file.txt"))
115 self.assertFalse(self.storage.exists("dir/subdir"))
116
117 def test_delete_missing_file(self):
118 self.storage.delete("missing_file.txt")
119 self.storage.delete("missing_dir/missing_file.txt")
120
121 def test_file_node_cannot_have_children(self):
122 """Navigate to children of a file node raises FileExistsError."""
123 self.storage.save("file.txt", ContentFile("test"))
124 self.assertRaises(FileExistsError, self.storage.listdir, "file.txt/child_dir")
125 self.assertRaises(
126 FileExistsError,
127 self.storage.save,
128 "file.txt/child_file.txt",
129 ContentFile("test"),
130 )
131
132 @override_settings(MEDIA_URL=None)
133 def test_url(self):
134 self.assertRaises(ValueError, self.storage.url, ("file.txt",))
135
136 storage = InMemoryStorage(base_url="http://www.example.com")
137 self.assertEqual(storage.url("file.txt"), "http://www.example.com/file.txt")
138
139 def test_url_with_none_filename(self):
140 storage = InMemoryStorage(base_url="/test_media_url/")
141 self.assertEqual(storage.url(None), "/test_media_url/")
142
143
144 class MemoryStorageTimesTests(unittest.TestCase):
145 def setUp(self):
146 self.storage = InMemoryStorage()
147
148 def test_file_modified_time(self):
149 """
150 File modified time should change after file changing
151 """
152 self.storage.save("file.txt", ContentFile("test"))
153 modified_time = self.storage.get_modified_time("file.txt")
154
155 time.sleep(0.1)
156
157 with self.storage.open("file.txt", "w") as fd:
158 fd.write("new content")
159
160 new_modified_time = self.storage.get_modified_time("file.txt")
161 self.assertTrue(new_modified_time > modified_time)
162
163 def test_file_accessed_time(self):
164 """File accessed time should change after consecutive opening."""
165 self.storage.save("file.txt", ContentFile("test"))
166 accessed_time = self.storage.get_accessed_time("file.txt")
167
168 time.sleep(0.1)
169
170 self.storage.open("file.txt", "r")
171 new_accessed_time = self.storage.get_accessed_time("file.txt")
172 self.assertGreater(new_accessed_time, accessed_time)
173
174 def test_file_created_time(self):
175 """File creation time should not change after I/O operations."""
176 self.storage.save("file.txt", ContentFile("test"))
177 created_time = self.storage.get_created_time("file.txt")
178
179 time.sleep(0.1)
180
181 # File opening doesn't change creation time.
182 file = self.storage.open("file.txt", "r")
183 after_open_created_time = self.storage.get_created_time("file.txt")
184 self.assertEqual(after_open_created_time, created_time)
185 # Writing to a file doesn't change its creation time.
186 file.write("New test")
187 self.storage.save("file.txt", file)
188 after_write_created_time = self.storage.get_created_time("file.txt")
189 self.assertEqual(after_write_created_time, created_time)
190
191 def test_directory_times_changing_after_file_creation(self):
192 """
193 Directory modified and accessed time should change when a new file is
194 created inside.
195 """
196 self.storage.save("dir/file1.txt", ContentFile("test"))
197 created_time = self.storage.get_created_time("dir")
198 modified_time = self.storage.get_modified_time("dir")
199 accessed_time = self.storage.get_accessed_time("dir")
200
201 time.sleep(0.1)
202
203 self.storage.save("dir/file2.txt", ContentFile("test"))
204 new_modified_time = self.storage.get_modified_time("dir")
205 new_accessed_time = self.storage.get_accessed_time("dir")
206 after_file_creation_created_time = self.storage.get_created_time("dir")
207 self.assertGreater(new_modified_time, modified_time)
208 self.assertGreater(new_accessed_time, accessed_time)
209 self.assertEqual(created_time, after_file_creation_created_time)
210
211 def test_directory_times_changing_after_file_deletion(self):
212 """
213 Directory modified and accessed time should change when a new file is
214 deleted inside.
215 """
216 self.storage.save("dir/file.txt", ContentFile("test"))
217 created_time = self.storage.get_created_time("dir")
218 modified_time = self.storage.get_modified_time("dir")
219 accessed_time = self.storage.get_accessed_time("dir")
220
221 time.sleep(0.1)
222
223 self.storage.delete("dir/file.txt")
224 new_modified_time = self.storage.get_modified_time("dir")
225 new_accessed_time = self.storage.get_accessed_time("dir")
226 after_file_deletion_created_time = self.storage.get_created_time("dir")
227 self.assertGreater(new_modified_time, modified_time)
228 self.assertGreater(new_accessed_time, accessed_time)
229 self.assertEqual(created_time, after_file_deletion_created_time)
230
231
232 class InMemoryStorageTests(SimpleTestCase):
233 def test_deconstruction(self):
234 storage = InMemoryStorage()
235 path, args, kwargs = storage.deconstruct()
236 self.assertEqual(path, "django.core.files.storage.InMemoryStorage")
237 self.assertEqual(args, ())
238 self.assertEqual(kwargs, {})
239
240 kwargs_orig = {
241 "location": "/custom_path",
242 "base_url": "http://myfiles.example.com/",
243 "file_permissions_mode": "0o755",
244 "directory_permissions_mode": "0o600",
245 }
246 storage = InMemoryStorage(**kwargs_orig)
247 path, args, kwargs = storage.deconstruct()
248 self.assertEqual(kwargs, kwargs_orig)
249
250 @override_settings(
251 MEDIA_ROOT="media_root",
252 MEDIA_URL="media_url/",
253 FILE_UPLOAD_PERMISSIONS=0o777,
254 FILE_UPLOAD_DIRECTORY_PERMISSIONS=0o777,
255 )
256 def test_setting_changed(self):
257 """
258 Properties using settings values as defaults should be updated on
259 referenced settings change while specified values should be unchanged.
260 """
261 storage = InMemoryStorage(
262 location="explicit_location",
263 base_url="explicit_base_url/",
264 file_permissions_mode=0o666,
265 directory_permissions_mode=0o666,
266 )
267 defaults_storage = InMemoryStorage()
268 settings = {
269 "MEDIA_ROOT": "overridden_media_root",
270 "MEDIA_URL": "/overridden_media_url/",
271 "FILE_UPLOAD_PERMISSIONS": 0o333,
272 "FILE_UPLOAD_DIRECTORY_PERMISSIONS": 0o333,
273 }
274 with self.settings(**settings):
275 self.assertEqual(storage.base_location, "explicit_location")
276 self.assertIn("explicit_location", storage.location)
277 self.assertEqual(storage.base_url, "explicit_base_url/")
278 self.assertEqual(storage.file_permissions_mode, 0o666)
279 self.assertEqual(storage.directory_permissions_mode, 0o666)
280 self.assertEqual(defaults_storage.base_location, settings["MEDIA_ROOT"])
281 self.assertIn(settings["MEDIA_ROOT"], defaults_storage.location)
282 self.assertEqual(defaults_storage.base_url, settings["MEDIA_URL"])
283 self.assertEqual(
284 defaults_storage.file_permissions_mode,
285 settings["FILE_UPLOAD_PERMISSIONS"],
286 )
287 self.assertEqual(
288 defaults_storage.directory_permissions_mode,
289 settings["FILE_UPLOAD_DIRECTORY_PERMISSIONS"],
290 )