Annotation of ExtFile/tests/testExtImage.py, revision 1.1
1.1 ! dwinter 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