1: #
2: # Tests the ExtFile product
3: #
4:
5: import os, sys
6: if __name__ == '__main__':
7: execfile(os.path.join(sys.path[0], 'framework.py'))
8:
9: from Testing import ZopeTestCase
10:
11: ZopeTestCase.installProduct('ExtFile')
12: ZopeTestCase.installProduct('PythonScripts')
13: ZopeTestCase.utils.startZServer(4)
14:
15: from Products.ExtFile.tests.ExtFileTestCase import ExtFileTestCase
16: from Products.ExtFile.tests.ExtFileTestCase import gifImage, jpegImage, tiffImage, notImage
17: from Products.ExtFile.tests.ExtFileTestCase import makeFileUpload
18: from Products.ExtFile.tests.ExtFileTestCase import copymove_perms
19: from Products.ExtFile import transaction
20: from Products.ExtFile import ExtFile, ExtImage, Config
21: from Products.ExtFile.ExtImage import UPLOAD_RESIZE
22:
23:
24: class TestExtFileAdd(ExtFileTestCase):
25: '''Test ExtFile creation'''
26:
27: def testAddFileFromFileName(self):
28: # Add File from file name
29: self.addExtFile(id='file', file=notImage)
30: self.file._finish()
31: self.failUnless(self._exists('file.exe'))
32: self.assertEqual(self.file.get_size(), self._fsize(notImage))
33:
34: def testAddFileFromFileHandle(self):
35: # Add File from file handle
36: self.addExtFile(id='file', file=open(notImage, 'rb'))
37: self.file._finish()
38: self.failUnless(self._exists('file.exe'))
39: self.assertEqual(self.file.get_size(), self._fsize(notImage))
40:
41: def testAddFileFromFileUpload(self):
42: # Add File from file upload
43: self.addExtFile(id='file', file=makeFileUpload(notImage, 'application/octet-stream'))
44: self.file._finish()
45: self.failUnless(self._exists('file.exe'))
46: self.assertEqual(self.file.get_size(), self._fsize(notImage))
47:
48: def testAddFileWithIdFromFilename(self):
49: # Add File without id - should use filename instead
50: self.addExtFile(id='', file=makeFileUpload(notImage, 'application/octet-stream', filename='foo'))
51: self.file._finish()
52: self.assertEqual(self.file.getId(), 'foo')
53: self.failUnless(self._exists('foo.exe'))
54: self.assertEqual(self.file.get_size(), self._fsize(notImage))
55:
56: def testAddFileWithLatin1Filename(self):
57: # Add File without id - should use filename instead
58: self.addExtFile(id='', file=makeFileUpload(notImage, 'application/octet-stream', filename='M\xe4dchen'))
59: self.file._finish()
60: self.assertEqual(self.file.getId(), 'Madchen')
61: self.failUnless(self._exists('Madchen.exe'))
62: self.assertEqual(self.file.get_size(), self._fsize(notImage))
63:
64: def testAddFileWithUTF8Filename(self):
65: # Add File without id - should use filename instead
66: self.addExtFile(id='', file=makeFileUpload(notImage, 'application/octet-stream', filename='M\303\244dchen'))
67: self.file._finish()
68: self.assertEqual(self.file.getId(), 'Madchen')
69: self.failUnless(self._exists('Madchen.exe'))
70: self.assertEqual(self.file.get_size(), self._fsize(notImage))
71:
72:
73: class TestExtImageAdd(ExtFileTestCase):
74: '''Test ExtImage creation'''
75:
76: def testAddImageFromName(self):
77: # Add Image from file name
78: self.addExtImage(id='image', file=gifImage)
79: self.image._finish()
80: self.failUnless(self._exists('image.gif'))
81: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
82:
83: def testAddImageFromFileHandle(self):
84: # Add Image from file handle
85: self.addExtImage(id='image', file=open(gifImage, 'rb'))
86: self.image._finish()
87: self.failUnless(self._exists('image.gif'))
88: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
89:
90: def testAddImageFromFileUpload(self):
91: # Add Image from file upload
92: self.addExtImage(id='image', file=makeFileUpload(gifImage, 'image/gif'))
93: self.image._finish()
94: self.failUnless(self._exists('image.gif'))
95: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
96:
97: def testAddImageWithIdFromFilename(self):
98: # Add File without id - should use filename instead
99: self.addExtImage(id='', file=makeFileUpload(gifImage, 'image/gif', filename='foo'))
100: self.image._finish()
101: self.assertEqual(self.image.getId(), 'foo')
102: self.failUnless(self._exists('foo.gif'))
103: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
104:
105: def testAddUnwrappedImage(self):
106: # This is what Photo does with displays...
107: file = ExtImage.ExtImage('foo')
108: self.assertRaises(AttributeError,
109: file.manage_file_upload, file=gifImage)
110:
111: def testAddImageWithLatin1Filename(self):
112: # Add File without id - should use filename instead
113: self.addExtImage(id='', file=makeFileUpload(gifImage, 'image/gif', filename='M\xe4dchen'))
114: self.image._finish()
115: self.assertEqual(self.image.getId(), 'Madchen')
116: self.failUnless(self._exists('Madchen.gif'))
117: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
118:
119: def testAddImageWithUTF8Filename(self):
120: # Add File without id - should use filename instead
121: self.addExtImage(id='', file=makeFileUpload(gifImage, 'image/gif', filename='M\303\244dchen'))
122: self.image._finish()
123: self.assertEqual(self.image.getId(), 'Madchen')
124: self.failUnless(self._exists('Madchen.gif'))
125: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
126:
127:
128: class TestExtFileUpload(ExtFileTestCase):
129: '''Test ExtFile upload'''
130:
131: def testManageFileUploadFromFileName(self):
132: # Upload File from file name
133: self.addExtFile(id='file', file='')
134: self.file.manage_file_upload(file=notImage)
135: self.file._finish()
136: self.failUnless(self._exists('file.exe'))
137: self.assertEqual(self.file.get_size(), self._fsize(notImage))
138:
139: def testManageFileUploadFromFileHandle(self):
140: # Upload File from file handle
141: self.addExtFile(id='file', file='')
142: self.file.manage_file_upload(file=open(notImage, 'rb'))
143: self.file._finish()
144: self.failUnless(self._exists('file.exe'))
145: self.assertEqual(self.file.get_size(), self._fsize(notImage))
146:
147: def testManageFileUploadFromFileUpload(self):
148: # Upload File from file upload
149: self.addExtFile(id='file', file='')
150: self.file.manage_file_upload(file=makeFileUpload(notImage, 'application/octet-stream'))
151: self.file._finish()
152: self.failUnless(self._exists('file.exe'))
153: self.assertEqual(self.file.get_size(), self._fsize(notImage))
154:
155: def testManageUploadFromStringBuffer(self):
156: # Upload File from file name
157: self.addExtFile(id='file', file='')
158: self.file.manage_upload(file=open(notImage, 'rb').read())
159: self.file._finish()
160: self.failUnless(self._exists('file.exe'))
161: self.assertEqual(self.file.get_size(), self._fsize(notImage))
162:
163: def testManageUploadFromFileHandle(self):
164: # Upload File from file handle
165: self.addExtFile(id='file', file='')
166: self.file.manage_upload(file=open(notImage, 'rb'))
167: self.file._finish()
168: self.failUnless(self._exists('file.exe'))
169: self.assertEqual(self.file.get_size(), self._fsize(notImage))
170:
171: def testManageUploadFromFileUpload(self):
172: # Upload File from file upload
173: self.addExtFile(id='file', file='')
174: self.file.manage_upload(file=makeFileUpload(notImage, 'application/octet-stream'))
175: self.file._finish()
176: self.failUnless(self._exists('file.exe'))
177: self.assertEqual(self.file.get_size(), self._fsize(notImage))
178:
179:
180: class TestExtImageUpload(ExtFileTestCase):
181: '''Test ExtImage upload'''
182:
183: def testManageFileUploadFromFileName(self):
184: # Upload Image from file name
185: self.addExtImage(id='image', file='')
186: self.image.manage_file_upload(file=gifImage)
187: self.image._finish()
188: self.failUnless(self._exists('image.gif'))
189: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
190:
191: def testManageFileUploadFromFileHandle(self):
192: # Upload Image from file handle
193: self.addExtImage(id='image', file='')
194: self.image.manage_file_upload(file=open(gifImage, 'rb'))
195: self.image._finish()
196: self.failUnless(self._exists('image.gif'))
197: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
198:
199: def testManageFileUploadFromFileUpload(self):
200: # Upload Image from file upload
201: self.addExtImage(id='image', file='')
202: self.image.manage_file_upload(file=makeFileUpload(gifImage, 'image/gif'))
203: self.image._finish()
204: self.failUnless(self._exists('image.gif'))
205: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
206:
207: def testManageUploadFromStringBuffer(self):
208: # Upload Image from file name
209: self.addExtImage(id='image', file='')
210: self.image.manage_upload(file=open(gifImage, 'rb').read())
211: self.image._finish()
212: self.failUnless(self._exists('image.gif'))
213: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
214:
215: def testManageUploadFromFileHandle(self):
216: # Upload Image from file handle
217: self.addExtImage(id='image', file='')
218: self.image.manage_upload(file=open(gifImage, 'rb'))
219: self.image._finish()
220: self.failUnless(self._exists('image.gif'))
221: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
222:
223: def testManageUploadFromFileUpload(self):
224: # Upload Image from file upload
225: self.addExtImage(id='image', file='')
226: self.image.manage_upload(file=makeFileUpload(gifImage, 'image/gif'))
227: self.image._finish()
228: self.failUnless(self._exists('image.gif'))
229: self.assertEqual(self.image.get_size(), self._fsize(gifImage))
230:
231:
232: class TestExtFileContentType(ExtFileTestCase):
233: '''Test ExtFile content-type detection'''
234:
235: def testDefaultContentType(self):
236: # Use default content type
237: self.addExtFile(id='file', file=notImage)
238: self.file._finish()
239: self.assertEqual(self.file.content_type, 'application/octet-stream')
240: self.failUnless(self._exists('file.exe'))
241:
242: def testContentTypeExplicit(self):
243: # Use passed-in content type
244: self.addExtFile(id='file', file=notImage, content_type='image/jpeg')
245: self.file._finish()
246: self.assertEqual(self.file.content_type, 'image/jpeg')
247: self.failUnless(self._exists('file.jpg'))
248:
249: def testContentTypeFromId(self):
250: # Detect GIF content type from file id
251: self.addExtFile(id='file.gif', file=notImage)
252: self.file._finish()
253: self.assertEqual(self.file.content_type, 'image/gif')
254: self.failUnless(self._exists('file.gif'))
255:
256: def testContentTypeFromIdExplicit(self):
257: # Passed-in content type trumps detection by id
258: self.addExtFile(id='file.gif', file=notImage, content_type='image/jpeg')
259: self.file._finish()
260: self.assertEqual(self.file.content_type, 'image/jpeg')
261: self.failUnless(self._exists('file.jpg'))
262:
263: def testContentTypeFromHeaders(self):
264: # Detect GIF content type from file upload headers
265: self.addExtFile(id='file', file=makeFileUpload(notImage, 'image/gif'))
266: self.file._finish()
267: self.assertEqual(self.file.content_type, 'image/gif')
268: self.failUnless(self._exists('file.gif'))
269:
270: def testContentTypeFromHeadersExplicit(self):
271: # Passed-in content type trumps detection by headers
272: self.addExtFile(id='file', file=makeFileUpload(notImage, 'image/gif'), content_type='image/jpeg')
273: self.file._finish()
274: self.assertEqual(self.file.content_type, 'image/jpeg')
275: self.failUnless(self._exists('file.jpg'))
276:
277: def testContentTypeFromHttpUpload(self):
278: # Detect content type from download headers
279: self.addExtFile(id='file', file=notImage)
280: self.file.manage_http_upload(url=self.app.TiffImage.absolute_url())
281: self.file._finish()
282: self.assertEqual(self.file.content_type, 'image/tiff')
283: # File is *not* renamed!
284: self.failUnless(self._exists('file.exe'))
285:
286: def testContentTypeFromHttpUploadDefault(self):
287: # Detect content type from download headers
288: self.addExtFile(id='file', file=notImage)
289: self.file.manage_http_upload(url=self.app.NotImage.absolute_url())
290: self.file._finish()
291: self.assertEqual(self.file.content_type, 'application/octet-stream')
292: # File is *not* renamed!
293: self.failUnless(self._exists('file.exe'))
294:
295:
296: class TestExtImageContentType(ExtFileTestCase):
297: '''Test ExtImage content-type detection'''
298:
299: def testDefaultContentType(self):
300: # Use default content type
301: self.addExtImage(id='image', file=notImage)
302: self.image._finish()
303: self.assertEqual(self.image.content_type, 'application/octet-stream')
304: self.failUnless(self._exists('image.exe'))
305:
306: def testContentTypeExplicit(self):
307: # Use passed-in content type when we cannot detect from content
308: self.addExtImage(id='image', file=notImage, content_type='image/jpeg')
309: self.image._finish()
310: self.assertEqual(self.image.content_type, 'image/jpeg')
311: self.failUnless(self._exists('image.jpg'))
312:
313: def testContentTypeFromId(self):
314: # Detect GIF content type from file id
315: self.addExtImage(id='image.gif', file=notImage)
316: self.image._finish()
317: self.assertEqual(self.image.content_type, 'image/gif')
318: self.failUnless(self._exists('image.gif'))
319:
320: def testContentTypeFromIdExplicit(self):
321: # Passed-in content type trumps detection by id
322: self.addExtImage(id='image.gif', file=notImage, content_type='image/jpeg')
323: self.image._finish()
324: self.assertEqual(self.image.content_type, 'image/jpeg')
325: self.failUnless(self._exists('image.jpg'))
326:
327: def testContentTypeFromHeaders(self):
328: # Detect GIF content type from file upload headers
329: self.addExtImage(id='image', file=makeFileUpload(notImage, 'image/gif'))
330: self.image._finish()
331: self.assertEqual(self.image.content_type, 'image/gif')
332: self.failUnless(self._exists('image.gif'))
333:
334: def testContentTypeFromHeadersExplicit(self):
335: # Passed-in content type trumps detection by headers
336: self.addExtImage(id='image', file=makeFileUpload(notImage, 'image/gif'), content_type='image/jpeg')
337: self.image._finish()
338: self.assertEqual(self.image.content_type, 'image/jpeg')
339: self.failUnless(self._exists('image.jpg'))
340:
341: def testContentTypeFromHttpUpload(self):
342: # Detect content type from download headers
343: self.addExtImage(id='image', file=notImage)
344: self.image.manage_http_upload(url=self.app.TiffImage.absolute_url())
345: self.image._finish()
346: self.assertEqual(self.image.content_type, 'image/tiff')
347: # File is *not* renamed!
348: self.failUnless(self._exists('image.exe'))
349: # Check TIFF dimension sniffing
350: self.assertEqual(self.image.width(), 200)
351: self.assertEqual(self.image.height(), 136)
352:
353: def testContentTypeFromGifContent(self):
354: # Detect GIF content type from file contents
355: self.addExtImage(id='image', file=gifImage)
356: self.image._finish()
357: self.assertEqual(self.image.content_type, 'image/gif')
358: self.failUnless(self._exists('image.gif'))
359:
360: def testContentTypeFromGifContentExplicit(self):
361: # Detect GIF content type even when passing a content type
362: self.addExtImage(id='image', file=gifImage, content_type='image/jpeg')
363: self.image._finish()
364: self.assertEqual(self.image.content_type, 'image/gif')
365: self.failUnless(self._exists('image.gif'))
366:
367: def testContentTypeFromJpegContent(self):
368: # Detect JPEG content type from file contents
369: self.addExtImage(id='image', file=jpegImage)
370: self.image._finish()
371: self.assertEqual(self.image.content_type, 'image/jpeg')
372: self.failUnless(self._exists('image.jpg'))
373:
374: def testContentTypeFromJpegContentExplicit(self):
375: # Detect JPEG content type even when passing a content type
376: self.addExtImage(id='image', file=jpegImage, content_type='image/tiff')
377: self.image._finish()
378: self.assertEqual(self.image.content_type, 'image/jpeg')
379: self.failUnless(self._exists('image.jpg'))
380:
381: def testContentTypeFromGifString(self):
382: # Detect GIF content type from string buffer
383: self.addExtImage(id='image', file=notImage)
384: self.image.manage_upload(file=open(gifImage, 'rb').read())
385: self.image._finish()
386: self.assertEqual(self.image.content_type, 'image/gif')
387: # File is *not* renamed!
388: self.failUnless(self._exists('image.exe'))
389:
390: def testContentTypeFromJpegPUT(self):
391: # Detect JPEG content type from PUT' image
392: self.addExtImage(id='image', file=open(notImage, 'rb'))
393: request = self.app.REQUEST
394: request['BODYFILE'] = open(jpegImage, 'rb')
395: self.image.PUT(request, request.RESPONSE)
396: self.image._finish()
397: self.assertEqual(self.image.content_type, 'image/jpeg')
398: # File is *not* renamed!
399: self.failUnless(self._exists('image.exe'))
400: # Check PUT works
401: self.assertEqual(self.image.get_size(), self._fsize(jpegImage))
402:
403:
404: class TestExtFileCopyPaste(ExtFileTestCase):
405: '''Tests cut/copy/paste/rename/clone'''
406:
407: def afterSetUp(self):
408: ExtFileTestCase.afterSetUp(self)
409: self.folder.manage_addFolder('subfolder')
410: self.subfolder = self.folder['subfolder']
411: self.setPermissions(copymove_perms)
412: self.addExtFile(id='image.gif', file=gifImage)
413: transaction.savepoint(1) # need a _p_jar
414:
415: def testClone(self):
416: # Clone a file
417: self.subfolder.manage_clone(self.file, 'image.gif')
418: self.file._finish()
419: self.subfolder['image.gif']._finish()
420: self.failUnless(self._exists('image.gif'))
421: self.failIf(self._exists('image.gif.undo'))
422: self.failUnless(self._exists('image.1.gif'))
423:
424: def testCopyPaste(self):
425: # Copy and paste a file
426: cb = self.folder.manage_copyObjects(['image.gif'])
427: self.subfolder.manage_pasteObjects(cb)
428: self.file._finish()
429: self.subfolder['image.gif']._finish()
430: self.failUnless(self._exists('image.gif'))
431: self.failIf(self._exists('image.gif.undo'))
432: self.failUnless(self._exists('image.1.gif'))
433: self.assertEqual(self.subfolder['image.gif'].get_size(), self._fsize(gifImage))
434:
435: def testCutPaste(self):
436: # Cut and paste a file
437: cb = self.folder.manage_cutObjects(['image.gif'])
438: self.subfolder.manage_pasteObjects(cb)
439: self.file._finish()
440: self.subfolder['image.gif']._finish()
441: self.failUnless(self._exists('image.gif'))
442: self.failIf(self._exists('image.gif.undo'))
443: self.failIf(self._exists('image.1.gif'))
444:
445: def testRename(self):
446: # Rename a file
447: self.folder.manage_renameObject('image.gif', 'image44.gif')
448: self.file._finish()
449: self.folder['image44.gif']._finish()
450: self.failUnless(self._exists('image.gif'))
451: self.failIf(self._exists('image.gif.undo'))
452: self.failIf(self._exists('image.1.gif'))
453:
454: def testCOPY(self):
455: # WebDAV copy a file
456: req = self.app.REQUEST
457: req.environ['HTTP_DEPTH'] = 'infinity'
458: req.environ['HTTP_DESTINATION'] = 'http://dummy.org/%s/subfolder/image.gif' % ZopeTestCase.folder_name
459: self.folder['image.gif'].COPY(req, req.RESPONSE)
460: self.file._finish()
461: self.subfolder['image.gif']._finish()
462: self.failUnless(self._exists('image.gif'))
463: self.failIf(self._exists('image.gif.undo'))
464: self.failUnless(self._exists('image.1.gif'))
465: self.assertEqual(self.subfolder['image.gif'].get_size(), self._fsize(gifImage))
466:
467: def testMOVE(self):
468: # WebDAV move a file
469: req = self.app.REQUEST
470: req.environ['HTTP_DEPTH'] = 'infinity'
471: req.environ['HTTP_DESTINATION'] = 'http://dummy.org/%s/subfolder/image.gif' % ZopeTestCase.folder_name
472: self.folder['image.gif'].MOVE(req, req.RESPONSE)
473: self.file._finish()
474: self.subfolder['image.gif']._finish()
475: self.failUnless(self._exists('image.gif'))
476: self.failIf(self._exists('image.gif.undo'))
477: self.failIf(self._exists('image.1.gif'))
478: self.failIf(self._exists('image.1.gif.undo'))
479: self.assertEqual(self.subfolder['image.gif'].get_size(), self._fsize(gifImage))
480:
481: def testCopyOfProtection(self):
482: # Copy and paste a file into the same folder.
483: # The filenames should not begin with 'copy_of_'
484: cb = self.folder.manage_copyObjects(['image.gif'])
485: self.folder.manage_pasteObjects(cb)
486: self.file._finish()
487: self.folder['copy_of_image.gif']._finish()
488: self.failUnless(self._exists('image.gif'))
489: self.failIf(self._exists('image.gif.undo'))
490: self.failIf(self._exists('copy_of_image.gif'))
491: self.failUnless(self._exists('image.1.gif'))
492: self.assertEqual(self.folder['copy_of_image.gif'].get_size(), self._fsize(gifImage))
493:
494:
495: class TestExtImageCopyPaste(ExtFileTestCase):
496: '''Tests cut/copy/paste/rename/clone'''
497:
498: def afterSetUp(self):
499: ExtFileTestCase.afterSetUp(self)
500: self.folder.manage_addFolder('subfolder')
501: self.subfolder = self.folder['subfolder']
502: self.setPermissions(copymove_perms)
503: self.addExtImage(id='image.gif', file=gifImage)
504: # Add a preview image as well
505: self.folder['image.gif'].manage_file_upload(file=jpegImage, is_preview=1,
506: create_prev=UPLOAD_RESIZE,
507: maxx=100, maxy=100, ratio=1)
508: transaction.savepoint(1) # need a _p_jar
509:
510: def testClone(self):
511: # Clone an image
512: self.subfolder.manage_clone(self.image, 'image.gif')
513: self.image._finish()
514: self.subfolder['image.gif']._finish()
515: self.failUnless(self._exists('image.gif'))
516: self.failIf(self._exists('image.gif.undo'))
517: self.failUnless(self._exists('image.jpg'))
518: self.failIf(self._exists('image.jpg.undo'))
519: self.failUnless(self._exists('image.1.gif'))
520: self.failUnless(self._exists('image.1.jpg'))
521:
522: def testCopyPaste(self):
523: # Copy and paste an image
524: cb = self.folder.manage_copyObjects(['image.gif'])
525: self.subfolder.manage_pasteObjects(cb)
526: self.image._finish()
527: self.subfolder['image.gif']._finish()
528: self.failUnless(self._exists('image.gif'))
529: self.failIf(self._exists('image.gif.undo'))
530: self.failUnless(self._exists('image.1.gif'))
531: self.failIf(self._exists('image.1.gif.undo'))
532: self.failUnless(self._exists('image.jpg'))
533: self.failUnless(self._exists('image.1.jpg'))
534: self.assertEqual(self.subfolder['image.gif'].get_size(), self._fsize(gifImage))
535:
536: def testCutPaste(self):
537: # Cut and paste an image
538: cb = self.folder.manage_cutObjects(['image.gif'])
539: self.subfolder.manage_pasteObjects(cb)
540: self.image._finish()
541: self.subfolder['image.gif']._finish()
542: self.failUnless(self._exists('image.gif'))
543: self.failIf(self._exists('image.gif.undo'))
544: self.failUnless(self._exists('image.jpg'))
545: self.failIf(self._exists('image.jpg.undo'))
546: self.failIf(self._exists('image.1.gif'))
547: self.failIf(self._exists('image.1.jpg'))
548:
549: def testRename(self):
550: # Rename an image
551: self.folder.manage_renameObject('image.gif', 'image44.gif')
552: self.image._finish()
553: self.folder['image44.gif']._finish()
554: self.failUnless(self._exists('image.gif'))
555: self.failIf(self._exists('image.gif.undo'))
556: self.failUnless(self._exists('image.jpg'))
557: self.failIf(self._exists('image.jpg.undo'))
558: self.failIf(self._exists('image.1.gif'))
559: self.failIf(self._exists('image.1.jpg'))
560:
561: def testCOPY(self):
562: # WebDAV copy an image
563: req = self.app.REQUEST
564: req.environ['HTTP_DEPTH'] = 'infinity'
565: req.environ['HTTP_DESTINATION'] = 'http://dummy.org/%s/subfolder/image.gif' % ZopeTestCase.folder_name
566: self.folder['image.gif'].COPY(req, req.RESPONSE)
567: self.image._finish()
568: self.subfolder['image.gif']._finish()
569: self.failUnless(self._exists('image.gif'))
570: self.failIf(self._exists('image.gif.undo'))
571: self.failUnless(self._exists('image.1.gif'))
572: self.failIf(self._exists('image.1.gif.undo'))
573: self.failUnless(self._exists('image.jpg'))
574: self.failUnless(self._exists('image.1.jpg'))
575: self.assertEqual(self.subfolder['image.gif'].get_size(), self._fsize(gifImage))
576:
577: def testMOVE(self):
578: # WebDAV move an image
579: req = self.app.REQUEST
580: req.environ['HTTP_DEPTH'] = 'infinity'
581: req.environ['HTTP_DESTINATION'] = 'http://dummy.org/%s/subfolder/image.gif' % ZopeTestCase.folder_name
582: self.folder['image.gif'].MOVE(req, req.RESPONSE)
583: self.image._finish()
584: self.subfolder['image.gif']._finish()
585: self.failUnless(self._exists('image.gif'))
586: self.failIf(self._exists('image.gif.undo'))
587: self.failUnless(self._exists('image.jpg'))
588: self.failIf(self._exists('image.jpg.undo'))
589: self.failIf(self._exists('image.1.gif'))
590: self.failIf(self._exists('image.1.jpg'))
591: self.assertEqual(self.subfolder['image.gif'].get_size(), self._fsize(gifImage))
592:
593: def testPUTRecreatesPreview(self):
594: # PUT an image; the preview should be regenerated.
595: self.image._finish()
596: self.failUnless(self._exists('image.gif'))
597: self.failUnless(self._exists('image.jpg')) # preview
598: self.failIf(self._exists('image.gif.tmp'))
599: self.failIf(self._exists('image.jpg.tmp'))
600: req = self.app.REQUEST
601: req['BODYFILE'] = open(gifImage, 'rb')
602: self.image.PUT(req, req.RESPONSE)
603: self.failUnless(self._exists('image.gif'))
604: self.failUnless(self._exists('image.jpg')) # preview
605: self.failUnless(self._exists('image.gif.tmp')) # newly put image
606: self.failUnless(self._exists('image.jpg.tmp')) # regenerated preview
607: self.image._finish()
608: self.failUnless(self._exists('image.gif'))
609: self.failUnless(self._exists('image.jpg')) # regenerated preview
610: self.failIf(self._exists('image.gif.tmp'))
611: self.failIf(self._exists('image.jpg.tmp'))
612:
613: def testPUTRetainsPreviewBoundaries(self):
614: # PUT an image; the preview should retain maxx and maxy.
615: self.failUnless(self.image.has_preview)
616: self.assertEqual(self.image.prev_width(), 100)
617: self.assertEqual(self.image.prev_height(), 64)
618: req = self.app.REQUEST
619: req['BODYFILE'] = open(tiffImage, 'rb')
620: self.image.PUT(req, req.RESPONSE)
621: self.assertEqual(self.image.prev_width(), 100)
622: self.assertEqual(self.image.prev_height(), 68)
623:
624: def testManageHTTPUploadDoesNotAffectPreview(self):
625: # HTTP upload an image; the preview should not change.
626: self.failUnless(self.image.has_preview)
627: self.assertEqual(self.image.prev_width(), 100)
628: self.assertEqual(self.image.prev_height(), 64)
629: self.image.manage_http_upload(url=self.app.TiffImage.absolute_url())
630: self.assertEqual(self.image.prev_width(), 100)
631: self.assertEqual(self.image.prev_height(), 64)
632:
633:
634: class TestRepository(ExtFileTestCase):
635: '''Test repository directories'''
636:
637: def afterClear(self):
638: ExtFileTestCase.afterClear(self)
639: ExtFile.REPOSITORY = Config.FLAT
640: ExtFile.NORMALIZE_CASE = Config.KEEP
641: ExtFile.CUSTOM_METHOD = 'getExtFilePath'
642:
643: def testRepositoryFlat(self):
644: ExtFile.REPOSITORY = Config.FLAT
645: self.addExtImage(id='image', file=gifImage)
646: path = self.image.filename[:-1]
647: self.assertEqual(path, [])
648:
649: def testRepositorySyncZodb(self):
650: ExtFile.REPOSITORY = Config.SYNC_ZODB
651: self.addExtImage(id='image', file=gifImage)
652: path = self.image.filename[:-1]
653: self.assertEqual(path, [ZopeTestCase.folder_name])
654:
655: def testRepositorySliced(self):
656: ExtFile.REPOSITORY = Config.SLICED
657: self.addExtImage(id='image', file=gifImage)
658: path = self.image.filename[:-1]
659: self.assertEqual(path, ['i', 'm'])
660:
661: def testRepositorySlicedReverse(self):
662: ExtFile.REPOSITORY = Config.SLICED_REVERSE
663: self.addExtImage(id='image', file=gifImage)
664: path = self.image.filename[:-1]
665: self.assertEqual(path, ['e', 'g'])
666:
667: def testRepositorySlicedHash(self):
668: ExtFile.REPOSITORY = Config.SLICED_HASH
669: self.addExtImage(id='image', file=gifImage)
670: path = self.image.filename[:-1]
671: self.assertEqual(path, ['F', 'E'])
672:
673: def testRepositorySlicedHashDifferentFolder(self):
674: # Because the path is part of the hash, the results
675: # are different from the above test.
676: ExtFile.REPOSITORY = Config.SLICED_HASH
677: self.folder.manage_addFolder('subfolder')
678: self.subfolder = self.folder['subfolder']
679: self.addExtImage(id='image', file=gifImage, folder=self.subfolder)
680: path = self.image.filename[:-1]
681: self.assertEqual(path, ['L', 'd'])
682:
683: def testRepositoryCustom(self):
684:
685: def getExtFilePath(path, id):
686: return ['custom', 'path']
687: setattr(self.folder, 'getExtFilePath', getExtFilePath)
688:
689: ExtFile.REPOSITORY = Config.CUSTOM
690: self.addExtImage(id='image', file=gifImage)
691: path = self.image.filename[:-1]
692: self.assertEqual(path, ['custom', 'path'])
693:
694: def testRepositoryNormalizeCase(self):
695:
696: def getExtFilePath(path, id):
697: return ['Custom', 'Path']
698: setattr(self.folder, 'getExtFilePath', getExtFilePath)
699:
700: ExtFile.REPOSITORY = Config.CUSTOM
701: ExtFile.NORMALIZE_CASE = Config.NORMALIZE
702: self.addExtImage(id='image', file=gifImage)
703: path = self.image.filename[:-1]
704: self.assertEqual(path, ['custom', 'path'])
705:
706: def testRepositoryCustomScript(self):
707:
708: factory = self.folder.manage_addProduct['PythonScripts']
709: factory.manage_addPythonScript('getExtFilePath')
710: ps = self.folder.getExtFilePath
711: ps.ZPythonScript_edit(params='path, id', body="return ['custom', 'path']")
712:
713: ExtFile.REPOSITORY = Config.CUSTOM
714: self.addExtImage(id='image', file=gifImage)
715: path = self.image.filename[:-1]
716: self.assertEqual(path, ['custom', 'path'])
717:
718: def testRepositoryCustomContainer(self):
719: from OFS.Folder import Folder
720:
721: class CustomContainer(Folder):
722: def __init__(self, id):
723: self.id = id
724: def getExtFilePath(self, path, id):
725: return ['custom', 'path']
726:
727: self.folder._setObject('subfolder', CustomContainer('subfolder'))
728: self.folder = self.folder.subfolder
729:
730: ExtFile.REPOSITORY = Config.CUSTOM
731: self.addExtImage(id='image', file=gifImage)
732: path = self.image.filename[:-1]
733: self.assertEqual(path, ['custom', 'path'])
734:
735: def testRepositoryCustomContainerContainer(self):
736: from OFS.Folder import Folder
737:
738: class CustomContainer(Folder):
739: def __init__(self, id):
740: self.id = id
741: def getExtFilePath(self, path, id):
742: return ['custom', 'path']
743:
744: self.folder._setObject('subfolder', CustomContainer('subfolder'))
745: self.folder = self.folder.subfolder
746: self.folder._setObject('subsubfolder', Folder('subsubfolder'))
747: self.folder = self.folder.subsubfolder
748:
749: ExtFile.REPOSITORY = Config.CUSTOM
750: self.addExtImage(id='image', file=gifImage)
751: path = self.image.filename[:-1]
752: self.assertEqual(path, ['custom', 'path'])
753:
754: def testRepositoryCustomSubclass(self):
755:
756: class CustomImage(ExtImage.ExtImage):
757: def getExtFilePath(self, path, id):
758: return ['custom', 'path']
759:
760: ExtFile.REPOSITORY = Config.CUSTOM
761: self.folder._setObject('image', CustomImage('image'))
762: self.folder.image.manage_file_upload(gifImage)
763: path = self.folder.image.filename[:-1]
764: self.assertEqual(path, ['custom', 'path'])
765:
766: def testRepositoryCustomPrivateMethod(self):
767:
768: def _getExtFilePath(path, id):
769: return ['custom', 'path']
770: setattr(self.folder, '_getExtFilePath', _getExtFilePath)
771:
772: ExtFile.REPOSITORY = Config.CUSTOM
773: ExtFile.CUSTOM_METHOD = '_getExtFilePath'
774: self.addExtImage(id='image', file=gifImage)
775: path = self.image.filename[:-1]
776: self.assertEqual(path, ['custom', 'path'])
777:
778:
779: class TestRepositoryFiles(ExtFileTestCase):
780: '''Test repository files'''
781:
782: def afterSetUp(self):
783: ExtFileTestCase.afterSetUp(self)
784: self.folder.manage_addFolder('subfolder')
785: self.subfolder = self.folder['subfolder']
786:
787: def testUniqueFileName(self):
788: # Create a unique file name
789: self.addExtImage(id='image', file=gifImage)
790: self.image._finish()
791: self.addExtImage(id='image', file=gifImage, folder=self.subfolder)
792: self.image._finish()
793: self.failUnless(self._exists('image.gif'))
794: self.failIf(self._exists('image.gif.undo'))
795: self.failUnless(self._exists('image.1.gif'))
796: self.failIf(self._exists('image.1.gif.undo'))
797:
798: def testUniquePreviewName(self):
799: # Create a unique preview name
800: self.addExtImage(id='image', file=jpegImage)
801: self.image.manage_create_prev(100, 100, ratio=1)
802: self.image._finish()
803: self.failUnless(self._exists('image.jpg'))
804: self.failIf(self._exists('image.jpg.undo'))
805: self.failUnless(self._exists('image.1.jpg')) # Generated previews are always jpeg
806: self.failIf(self._exists('image.1.jpg.undo'))
807:
808: def testUndoNameOnDelete(self):
809: # Create a .undo file on delete
810: self.addExtImage(id='image', file=gifImage)
811: self.folder.manage_delObjects(['image'])
812: self.failIf(self._exists('image.gif'))
813: self.failUnless(self._exists('image.gif.undo'))
814:
815: def testUndoNameOnDeletePreview(self):
816: # Create a .undo file for the preview image on delete
817: self.addExtImage(id='image', file=gifImage)
818: self.image.manage_create_prev(100, 100, ratio=1)
819: self.image._finish()
820: self.failUnless(self._exists('image.gif'))
821: self.failUnless(self._exists('image.jpg')) # Generated previews are always jpeg
822: self.folder.manage_delObjects(['image'])
823: self.failIf(self._exists('image.gif'))
824: self.failUnless(self._exists('image.gif.undo'))
825: self.failIf(self._exists('image.jpg'))
826: self.failUnless(self._exists('image.jpg.undo'))
827:
828: def testUndoNameOnUpload(self):
829: # Do not create a .undo file on upload
830: self.addExtImage(id='image', file=gifImage)
831: self.image.manage_file_upload(file=gifImage)
832: self.image._finish()
833: self.failUnless(self._exists('image.gif'))
834: self.failIf(self._exists('image.gif.undo'))
835: self.failIf(self._exists('image.1.gif'))
836:
837: def testUndoNameIsNotReused(self):
838: # If an .undo file exists the name is not reused
839: self.addExtImage(id='image', file=gifImage)
840: self.folder.manage_delObjects(['image'])
841: self.addExtImage(id='image', file=gifImage)
842: self.image._finish()
843: self.failIf(self._exists('image.gif'))
844: self.failUnless(self._exists('image.gif.undo'))
845: self.failUnless(self._exists('image.1.gif'))
846:
847:
848: class TestRepositoryExtensions(ExtFileTestCase):
849: '''Test repository file extensions'''
850:
851: def afterClear(self):
852: ExtFileTestCase.afterClear(self)
853: ExtFile.REPOSITORY_EXTENSIONS = Config.MIMETYPE_REPLACE
854:
855: def testDefaultContentType(self):
856: # Use default content type
857: self.addExtImage(id='image', file=notImage)
858: self.image._finish()
859: self.failUnless(self._exists('image.exe'))
860:
861: def testDefaultContentTypeKeepsExistingExtension(self):
862: # Retain existing file extension if content type is octet-stream
863: self.addExtImage(id='image.foo', file=notImage)
864: self.image._finish()
865: self.failUnless(self._exists('image.foo'))
866:
867: def testDefaultContentTypeMimetypeAppend(self):
868: # Use default content type
869: ExtFile.REPOSITORY_EXTENSIONS = Config.MIMETYPE_APPEND
870: self.testDefaultContentType()
871:
872: def testDefaultContentTypeKeepsExistingExtensionMimetypeAppend(self):
873: # Retain existing file extension if content type is octet-stream
874: ExtFile.REPOSITORY_EXTENSIONS = Config.MIMETYPE_APPEND
875: self.testDefaultContentTypeKeepsExistingExtension()
876:
877:
878: class TestDownloadPermission(ExtFileTestCase):
879: '''Tests the DownloadPermission'''
880:
881: def testPermissionExists(self):
882: # DownloadPermission should exist
883: perms = self.app.permissionsOfRole('Manager')
884: perms = [x['name'] for x in perms if x['selected']]
885: self.failUnless(ExtFile.DownloadPermission in perms)
886:
887: def testDownloadPermissionCheck(self):
888: # The use_download_permission_check property
889: # should control whether we can see the full image.
890: self.addExtImage(id='image', file=gifImage)
891: self.failUnless(self.image._access_permitted())
892: self.image.use_download_permission_check = 1
893: self.failIf(self.image._access_permitted())
894:
895: def testShowPreviewIfNoDownloadPermission(self):
896: # If we don't have the permission we should only
897: # see the preview.
898: self.addExtImage(id='image', file=gifImage)
899: self.image.use_download_permission_check = 1
900: self.image.manage_create_prev(maxx=10, maxy=10, ratio=1)
901: dummy, dummy, dummy, preview = self.image._get_file_to_serve()
902: self.failUnless(preview)
903:
904: def testShowIconIfNoDownloadPermission(self):
905: # If we don't have the permission, and there is no preview,
906: # we should only see the icon.
907: self.addExtImage(id='image', file=gifImage)
908: self.image.use_download_permission_check = 1
909: dummy, dummy, icon, dummy = self.image._get_file_to_serve()
910: self.failUnless(icon)
911:
912: def testPreviewTagIfNoDownloadPermission(self):
913: # If we don't have the permission we should only
914: # see the preview.
915: self.addExtImage(id='image', file=gifImage)
916: self.image.use_download_permission_check = 1
917: self.image.manage_create_prev(maxx=10, maxy=10, ratio=1)
918: tag = self.image.tag()
919: # Permission is not checked in static mode
920: if self.image.static_mode():
921: self.failUnless(tag.find('/static/image.jpg')>=0)
922: else:
923: self.failUnless(tag.find('/image?preview=1')>=0)
924:
925: def testIconTagIfNoDownloadPermission(self):
926: # If we don't have the permission, and there is no preview,
927: # we should only see the icon.
928: self.addExtImage(id='image', file=gifImage)
929: self.image.use_download_permission_check = 1
930: tag = self.image.tag()
931: self.failUnless(tag.find('/image?icon=1')>=0)
932:
933: def testPreviewTagIfNotWebviewable(self):
934: # If the image is not webviewable we should only
935: # see the preview.
936: self.addExtImage(id='image', file=tiffImage)
937: self.image.manage_create_prev(maxx=10, maxy=10, ratio=1)
938: tag = self.image.tag()
939: # Permission is not checked in static mode
940: if self.image.static_mode():
941: self.failUnless(tag.find('/static/image.jpg')>=0)
942: else:
943: self.failUnless(tag.find('/image?preview=1')>=0)
944:
945:
946: class TestGetOwner(ExtFileTestCase):
947:
948: def afterSetUp(self):
949: ExtFileTestCase.afterSetUp(self)
950: self.addExtFile(id='file.zip', file=gifImage)
951: self.addExtImage(id='image.gif', file=gifImage)
952:
953: def testFileOwner(self):
954: self.assertEqual(self.file.getOwner().getId(), ZopeTestCase.user_name)
955: self.assertEqual(self.file.getOwnerTuple(),
956: ([ZopeTestCase.folder_name, 'acl_users'], ZopeTestCase.user_name))
957:
958: def testImageOwner(self):
959: self.assertEqual(self.image.getOwner().getId(), ZopeTestCase.user_name)
960: self.assertEqual(self.image.getOwnerTuple(),
961: ([ZopeTestCase.folder_name, 'acl_users'], ZopeTestCase.user_name))
962:
963:
964: class TestFTPget(ExtFileTestCase):
965:
966: def afterSetUp(self):
967: ExtFileTestCase.afterSetUp(self)
968: self.addExtFile(id='file.zip', file=gifImage)
969: self.addExtImage(id='image.gif', file=gifImage)
970:
971: def testFTPgetFile(self):
972: from StringIO import StringIO
973: response = self.app.REQUEST.RESPONSE
974: response.stdout = StringIO() # Shut up
975: result = self.file.manage_FTPget()
976: #self.assertEqual(result, '')
977: self.assertEqual(response.headers.get('content-type'), 'application/zip')
978: self.assertEqual(response.headers.get('content-length'), '%s' % self._fsize(gifImage))
979:
980: def testFTPgetImage(self):
981: from StringIO import StringIO
982: response = self.app.REQUEST.RESPONSE
983: response.stdout = StringIO() # Shut up
984: result = self.image.manage_FTPget()
985: #self.assertEqual(result, '')
986: self.assertEqual(response.headers.get('content-type'), 'image/gif')
987: self.assertEqual(response.headers.get('content-length'), '%s' % self._fsize(gifImage))
988:
989:
990: class TestPublish(ZopeTestCase.Functional, ExtFileTestCase):
991:
992: def afterSetUp(self):
993: ExtFileTestCase.afterSetUp(self)
994: self.addExtFile(id='file.zip', file=gifImage)
995: self.addExtImage(id='image.gif', file=gifImage)
996:
997: def testPublishFile(self):
998: folder_path = self.folder.absolute_url(1)
999: response = self.publish(folder_path+'/file.zip')
1000: self.assertEqual(response.getStatus(), 200)
1001: self.failUnless(response.getHeader('Content-Type').startswith('application/zip'))
1002:
1003: def testPublishImage(self):
1004: folder_path = self.folder.absolute_url(1)
1005: response = self.publish(folder_path+'/image.gif')
1006: self.assertEqual(response.getStatus(), 200)
1007: self.failUnless(response.getHeader('Content-Type').startswith('image/gif'))
1008:
1009:
1010: def test_suite():
1011: from unittest import TestSuite, makeSuite
1012: suite = TestSuite()
1013: suite.addTest(makeSuite(TestExtFileAdd))
1014: suite.addTest(makeSuite(TestExtImageAdd))
1015: suite.addTest(makeSuite(TestExtFileUpload))
1016: suite.addTest(makeSuite(TestExtImageUpload))
1017: suite.addTest(makeSuite(TestExtFileContentType))
1018: suite.addTest(makeSuite(TestExtImageContentType))
1019: suite.addTest(makeSuite(TestExtFileCopyPaste))
1020: suite.addTest(makeSuite(TestExtImageCopyPaste))
1021: suite.addTest(makeSuite(TestRepository))
1022: suite.addTest(makeSuite(TestRepositoryFiles))
1023: suite.addTest(makeSuite(TestRepositoryExtensions))
1024: suite.addTest(makeSuite(TestDownloadPermission))
1025: suite.addTest(makeSuite(TestGetOwner))
1026: suite.addTest(makeSuite(TestFTPget))
1027: suite.addTest(makeSuite(TestPublish))
1028: return suite
1029:
1030: if __name__ == '__main__':
1031: framework()
1032:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to testExtImage.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ExtFile / tests