mirror of
https://github.com/RustPython/RustPython.git
synced 2026-06-09 22:49:57 +09:00
Merge pull request #2569 from fanninpm/test-mimetypes
Add test_mimetypes from CPython 3.8
This commit is contained in:
Noah
GitHub
281
Lib/mimetypes.py
vendored
281
Lib/mimetypes.py
vendored
@@ -66,13 +66,13 @@ class MimeTypes:
|
||||
def __init__(self, filenames=(), strict=True):
|
||||
if not inited:
|
||||
init()
|
||||
self.encodings_map = encodings_map.copy()
|
||||
self.suffix_map = suffix_map.copy()
|
||||
self.encodings_map = _encodings_map_default.copy()
|
||||
self.suffix_map = _suffix_map_default.copy()
|
||||
self.types_map = ({}, {}) # dict for (non-strict, strict)
|
||||
self.types_map_inv = ({}, {})
|
||||
for (ext, type) in types_map.items():
|
||||
for (ext, type) in _types_map_default.items():
|
||||
self.add_type(type, ext, True)
|
||||
for (ext, type) in common_types.items():
|
||||
for (ext, type) in _common_types_default.items():
|
||||
self.add_type(type, ext, False)
|
||||
for name in filenames:
|
||||
self.read(name, strict)
|
||||
@@ -95,7 +95,7 @@ class MimeTypes:
|
||||
exts.append(ext)
|
||||
|
||||
def guess_type(self, url, strict=True):
|
||||
"""Guess the type of a file based on its URL.
|
||||
"""Guess the type of a file which is either a URL or a path-like object.
|
||||
|
||||
Return value is a tuple (type, encoding) where type is None if
|
||||
the type can't be guessed (no or unknown suffix) or a string
|
||||
@@ -113,7 +113,8 @@ class MimeTypes:
|
||||
Optional `strict' argument when False adds a bunch of commonly found,
|
||||
but non-standard types.
|
||||
"""
|
||||
scheme, url = urllib.parse.splittype(url)
|
||||
url = os.fspath(url)
|
||||
scheme, url = urllib.parse._splittype(url)
|
||||
if scheme == 'data':
|
||||
# syntax of data URLs:
|
||||
# dataurl := "data:" [ mediatype ] [ ";base64" ] "," data
|
||||
@@ -245,7 +246,7 @@ class MimeTypes:
|
||||
while True:
|
||||
try:
|
||||
ctype = _winreg.EnumKey(mimedb, i)
|
||||
except EnvironmentError:
|
||||
except OSError:
|
||||
break
|
||||
else:
|
||||
if '\0' not in ctype:
|
||||
@@ -259,13 +260,13 @@ class MimeTypes:
|
||||
# Only check file extensions
|
||||
if not subkeyname.startswith("."):
|
||||
continue
|
||||
# raises EnvironmentError if no 'Content Type' value
|
||||
# raises OSError if no 'Content Type' value
|
||||
mimetype, datatype = _winreg.QueryValueEx(
|
||||
subkey, 'Content Type')
|
||||
if datatype != _winreg.REG_SZ:
|
||||
continue
|
||||
self.add_type(mimetype, subkeyname, strict)
|
||||
except EnvironmentError:
|
||||
except OSError:
|
||||
continue
|
||||
|
||||
def guess_type(url, strict=True):
|
||||
@@ -345,11 +346,19 @@ def init(files=None):
|
||||
global suffix_map, types_map, encodings_map, common_types
|
||||
global inited, _db
|
||||
inited = True # so that MimeTypes.__init__() doesn't call us again
|
||||
db = MimeTypes()
|
||||
if files is None:
|
||||
|
||||
if files is None or _db is None:
|
||||
db = MimeTypes()
|
||||
if _winreg:
|
||||
db.read_windows_registry()
|
||||
files = knownfiles
|
||||
|
||||
if files is None:
|
||||
files = knownfiles
|
||||
else:
|
||||
files = knownfiles + list(files)
|
||||
else:
|
||||
db = _db
|
||||
|
||||
for file in files:
|
||||
if os.path.isfile(file):
|
||||
db.read(file)
|
||||
@@ -363,7 +372,7 @@ def init(files=None):
|
||||
|
||||
def read_mime_types(file):
|
||||
try:
|
||||
f = open(file)
|
||||
f = open(file, encoding='utf-8')
|
||||
except OSError:
|
||||
return None
|
||||
with f:
|
||||
@@ -373,12 +382,12 @@ def read_mime_types(file):
|
||||
|
||||
|
||||
def _default_mime_types():
|
||||
global suffix_map
|
||||
global encodings_map
|
||||
global types_map
|
||||
global common_types
|
||||
global suffix_map, _suffix_map_default
|
||||
global encodings_map, _encodings_map_default
|
||||
global types_map, _types_map_default
|
||||
global common_types, _common_types_default
|
||||
|
||||
suffix_map = {
|
||||
suffix_map = _suffix_map_default = {
|
||||
'.svgz': '.svg.gz',
|
||||
'.tgz': '.tar.gz',
|
||||
'.taz': '.tar.gz',
|
||||
@@ -387,7 +396,7 @@ def _default_mime_types():
|
||||
'.txz': '.tar.xz',
|
||||
}
|
||||
|
||||
encodings_map = {
|
||||
encodings_map = _encodings_map_default = {
|
||||
'.gz': 'gzip',
|
||||
'.Z': 'compress',
|
||||
'.bz2': 'bzip2',
|
||||
@@ -398,160 +407,164 @@ def _default_mime_types():
|
||||
# at http://www.iana.org/assignments/media-types
|
||||
# or extensions, i.e. using the x- prefix
|
||||
|
||||
# If you add to these, please keep them sorted!
|
||||
types_map = {
|
||||
'.a' : 'application/octet-stream',
|
||||
'.ai' : 'application/postscript',
|
||||
'.aif' : 'audio/x-aiff',
|
||||
'.aifc' : 'audio/x-aiff',
|
||||
'.aiff' : 'audio/x-aiff',
|
||||
'.au' : 'audio/basic',
|
||||
'.avi' : 'video/x-msvideo',
|
||||
'.bat' : 'text/plain',
|
||||
'.bcpio' : 'application/x-bcpio',
|
||||
'.bin' : 'application/octet-stream',
|
||||
'.bmp' : 'image/x-ms-bmp',
|
||||
'.c' : 'text/plain',
|
||||
# Duplicates :(
|
||||
'.cdf' : 'application/x-cdf',
|
||||
'.cdf' : 'application/x-netcdf',
|
||||
'.cpio' : 'application/x-cpio',
|
||||
'.csh' : 'application/x-csh',
|
||||
'.css' : 'text/css',
|
||||
'.csv' : 'text/csv',
|
||||
'.dll' : 'application/octet-stream',
|
||||
# If you add to these, please keep them sorted by mime type.
|
||||
# Make sure the entry with the preferred file extension for a particular mime type
|
||||
# appears before any others of the same mimetype.
|
||||
types_map = _types_map_default = {
|
||||
'.js' : 'application/javascript',
|
||||
'.mjs' : 'application/javascript',
|
||||
'.json' : 'application/json',
|
||||
'.webmanifest': 'application/manifest+json',
|
||||
'.doc' : 'application/msword',
|
||||
'.dot' : 'application/msword',
|
||||
'.dvi' : 'application/x-dvi',
|
||||
'.eml' : 'message/rfc822',
|
||||
'.eps' : 'application/postscript',
|
||||
'.etx' : 'text/x-setext',
|
||||
'.wiz' : 'application/msword',
|
||||
'.bin' : 'application/octet-stream',
|
||||
'.a' : 'application/octet-stream',
|
||||
'.dll' : 'application/octet-stream',
|
||||
'.exe' : 'application/octet-stream',
|
||||
'.gif' : 'image/gif',
|
||||
'.gtar' : 'application/x-gtar',
|
||||
'.h' : 'text/plain',
|
||||
'.hdf' : 'application/x-hdf',
|
||||
'.htm' : 'text/html',
|
||||
'.html' : 'text/html',
|
||||
'.ico' : 'image/vnd.microsoft.icon',
|
||||
'.ief' : 'image/ief',
|
||||
'.jpe' : 'image/jpeg',
|
||||
'.jpeg' : 'image/jpeg',
|
||||
'.jpg' : 'image/jpeg',
|
||||
'.js' : 'application/javascript',
|
||||
'.ksh' : 'text/plain',
|
||||
'.latex' : 'application/x-latex',
|
||||
'.m1v' : 'video/mpeg',
|
||||
'.m3u' : 'application/vnd.apple.mpegurl',
|
||||
'.m3u8' : 'application/vnd.apple.mpegurl',
|
||||
'.man' : 'application/x-troff-man',
|
||||
'.me' : 'application/x-troff-me',
|
||||
'.mht' : 'message/rfc822',
|
||||
'.mhtml' : 'message/rfc822',
|
||||
'.mif' : 'application/x-mif',
|
||||
'.mov' : 'video/quicktime',
|
||||
'.movie' : 'video/x-sgi-movie',
|
||||
'.mp2' : 'audio/mpeg',
|
||||
'.mp3' : 'audio/mpeg',
|
||||
'.mp4' : 'video/mp4',
|
||||
'.mpa' : 'video/mpeg',
|
||||
'.mpe' : 'video/mpeg',
|
||||
'.mpeg' : 'video/mpeg',
|
||||
'.mpg' : 'video/mpeg',
|
||||
'.ms' : 'application/x-troff-ms',
|
||||
'.nc' : 'application/x-netcdf',
|
||||
'.nws' : 'message/rfc822',
|
||||
'.o' : 'application/octet-stream',
|
||||
'.obj' : 'application/octet-stream',
|
||||
'.so' : 'application/octet-stream',
|
||||
'.oda' : 'application/oda',
|
||||
'.p12' : 'application/x-pkcs12',
|
||||
'.p7c' : 'application/pkcs7-mime',
|
||||
'.pbm' : 'image/x-portable-bitmap',
|
||||
'.pdf' : 'application/pdf',
|
||||
'.pfx' : 'application/x-pkcs12',
|
||||
'.pgm' : 'image/x-portable-graymap',
|
||||
'.pl' : 'text/plain',
|
||||
'.png' : 'image/png',
|
||||
'.pnm' : 'image/x-portable-anymap',
|
||||
'.p7c' : 'application/pkcs7-mime',
|
||||
'.ps' : 'application/postscript',
|
||||
'.ai' : 'application/postscript',
|
||||
'.eps' : 'application/postscript',
|
||||
'.m3u' : 'application/vnd.apple.mpegurl',
|
||||
'.m3u8' : 'application/vnd.apple.mpegurl',
|
||||
'.xls' : 'application/vnd.ms-excel',
|
||||
'.xlb' : 'application/vnd.ms-excel',
|
||||
'.ppt' : 'application/vnd.ms-powerpoint',
|
||||
'.pot' : 'application/vnd.ms-powerpoint',
|
||||
'.ppa' : 'application/vnd.ms-powerpoint',
|
||||
'.ppm' : 'image/x-portable-pixmap',
|
||||
'.pps' : 'application/vnd.ms-powerpoint',
|
||||
'.ppt' : 'application/vnd.ms-powerpoint',
|
||||
'.ps' : 'application/postscript',
|
||||
'.pwz' : 'application/vnd.ms-powerpoint',
|
||||
'.py' : 'text/x-python',
|
||||
'.wasm' : 'application/wasm',
|
||||
'.bcpio' : 'application/x-bcpio',
|
||||
'.cpio' : 'application/x-cpio',
|
||||
'.csh' : 'application/x-csh',
|
||||
'.dvi' : 'application/x-dvi',
|
||||
'.gtar' : 'application/x-gtar',
|
||||
'.hdf' : 'application/x-hdf',
|
||||
'.h5' : 'application/x-hdf5',
|
||||
'.latex' : 'application/x-latex',
|
||||
'.mif' : 'application/x-mif',
|
||||
'.cdf' : 'application/x-netcdf',
|
||||
'.nc' : 'application/x-netcdf',
|
||||
'.p12' : 'application/x-pkcs12',
|
||||
'.pfx' : 'application/x-pkcs12',
|
||||
'.ram' : 'application/x-pn-realaudio',
|
||||
'.pyc' : 'application/x-python-code',
|
||||
'.pyo' : 'application/x-python-code',
|
||||
'.qt' : 'video/quicktime',
|
||||
'.ra' : 'audio/x-pn-realaudio',
|
||||
'.ram' : 'application/x-pn-realaudio',
|
||||
'.ras' : 'image/x-cmu-raster',
|
||||
'.rdf' : 'application/xml',
|
||||
'.rgb' : 'image/x-rgb',
|
||||
'.roff' : 'application/x-troff',
|
||||
'.rtx' : 'text/richtext',
|
||||
'.sgm' : 'text/x-sgml',
|
||||
'.sgml' : 'text/x-sgml',
|
||||
'.sh' : 'application/x-sh',
|
||||
'.shar' : 'application/x-shar',
|
||||
'.snd' : 'audio/basic',
|
||||
'.so' : 'application/octet-stream',
|
||||
'.src' : 'application/x-wais-source',
|
||||
'.swf' : 'application/x-shockwave-flash',
|
||||
'.sv4cpio': 'application/x-sv4cpio',
|
||||
'.sv4crc' : 'application/x-sv4crc',
|
||||
'.svg' : 'image/svg+xml',
|
||||
'.swf' : 'application/x-shockwave-flash',
|
||||
'.t' : 'application/x-troff',
|
||||
'.tar' : 'application/x-tar',
|
||||
'.tcl' : 'application/x-tcl',
|
||||
'.tex' : 'application/x-tex',
|
||||
'.texi' : 'application/x-texinfo',
|
||||
'.texinfo': 'application/x-texinfo',
|
||||
'.tif' : 'image/tiff',
|
||||
'.tiff' : 'image/tiff',
|
||||
'.roff' : 'application/x-troff',
|
||||
'.t' : 'application/x-troff',
|
||||
'.tr' : 'application/x-troff',
|
||||
'.tsv' : 'text/tab-separated-values',
|
||||
'.txt' : 'text/plain',
|
||||
'.man' : 'application/x-troff-man',
|
||||
'.me' : 'application/x-troff-me',
|
||||
'.ms' : 'application/x-troff-ms',
|
||||
'.ustar' : 'application/x-ustar',
|
||||
'.vcf' : 'text/x-vcard',
|
||||
'.wav' : 'audio/x-wav',
|
||||
'.webm' : 'video/webm',
|
||||
'.wiz' : 'application/msword',
|
||||
'.wsdl' : 'application/xml',
|
||||
'.xbm' : 'image/x-xbitmap',
|
||||
'.xlb' : 'application/vnd.ms-excel',
|
||||
# Duplicates :(
|
||||
'.xls' : 'application/excel',
|
||||
'.xls' : 'application/vnd.ms-excel',
|
||||
'.xml' : 'text/xml',
|
||||
'.xpdl' : 'application/xml',
|
||||
'.xpm' : 'image/x-xpixmap',
|
||||
'.src' : 'application/x-wais-source',
|
||||
'.xsl' : 'application/xml',
|
||||
'.xwd' : 'image/x-xwindowdump',
|
||||
'.rdf' : 'application/xml',
|
||||
'.wsdl' : 'application/xml',
|
||||
'.xpdl' : 'application/xml',
|
||||
'.zip' : 'application/zip',
|
||||
'.au' : 'audio/basic',
|
||||
'.snd' : 'audio/basic',
|
||||
'.mp3' : 'audio/mpeg',
|
||||
'.mp2' : 'audio/mpeg',
|
||||
'.aif' : 'audio/x-aiff',
|
||||
'.aifc' : 'audio/x-aiff',
|
||||
'.aiff' : 'audio/x-aiff',
|
||||
'.ra' : 'audio/x-pn-realaudio',
|
||||
'.wav' : 'audio/x-wav',
|
||||
'.bmp' : 'image/bmp',
|
||||
'.gif' : 'image/gif',
|
||||
'.ief' : 'image/ief',
|
||||
'.jpg' : 'image/jpeg',
|
||||
'.jpe' : 'image/jpeg',
|
||||
'.jpeg' : 'image/jpeg',
|
||||
'.png' : 'image/png',
|
||||
'.svg' : 'image/svg+xml',
|
||||
'.tiff' : 'image/tiff',
|
||||
'.tif' : 'image/tiff',
|
||||
'.ico' : 'image/vnd.microsoft.icon',
|
||||
'.ras' : 'image/x-cmu-raster',
|
||||
'.bmp' : 'image/x-ms-bmp',
|
||||
'.pnm' : 'image/x-portable-anymap',
|
||||
'.pbm' : 'image/x-portable-bitmap',
|
||||
'.pgm' : 'image/x-portable-graymap',
|
||||
'.ppm' : 'image/x-portable-pixmap',
|
||||
'.rgb' : 'image/x-rgb',
|
||||
'.xbm' : 'image/x-xbitmap',
|
||||
'.xpm' : 'image/x-xpixmap',
|
||||
'.xwd' : 'image/x-xwindowdump',
|
||||
'.eml' : 'message/rfc822',
|
||||
'.mht' : 'message/rfc822',
|
||||
'.mhtml' : 'message/rfc822',
|
||||
'.nws' : 'message/rfc822',
|
||||
'.css' : 'text/css',
|
||||
'.csv' : 'text/csv',
|
||||
'.html' : 'text/html',
|
||||
'.htm' : 'text/html',
|
||||
'.txt' : 'text/plain',
|
||||
'.bat' : 'text/plain',
|
||||
'.c' : 'text/plain',
|
||||
'.h' : 'text/plain',
|
||||
'.ksh' : 'text/plain',
|
||||
'.pl' : 'text/plain',
|
||||
'.rtx' : 'text/richtext',
|
||||
'.tsv' : 'text/tab-separated-values',
|
||||
'.py' : 'text/x-python',
|
||||
'.etx' : 'text/x-setext',
|
||||
'.sgm' : 'text/x-sgml',
|
||||
'.sgml' : 'text/x-sgml',
|
||||
'.vcf' : 'text/x-vcard',
|
||||
'.xml' : 'text/xml',
|
||||
'.mp4' : 'video/mp4',
|
||||
'.mpeg' : 'video/mpeg',
|
||||
'.m1v' : 'video/mpeg',
|
||||
'.mpa' : 'video/mpeg',
|
||||
'.mpe' : 'video/mpeg',
|
||||
'.mpg' : 'video/mpeg',
|
||||
'.mov' : 'video/quicktime',
|
||||
'.qt' : 'video/quicktime',
|
||||
'.webm' : 'video/webm',
|
||||
'.avi' : 'video/x-msvideo',
|
||||
'.movie' : 'video/x-sgi-movie',
|
||||
}
|
||||
|
||||
# These are non-standard types, commonly found in the wild. They will
|
||||
# only match if strict=0 flag is given to the API methods.
|
||||
|
||||
# Please sort these too
|
||||
common_types = {
|
||||
'.jpg' : 'image/jpg',
|
||||
'.mid' : 'audio/midi',
|
||||
common_types = _common_types_default = {
|
||||
'.rtf' : 'application/rtf',
|
||||
'.midi': 'audio/midi',
|
||||
'.mid' : 'audio/midi',
|
||||
'.jpg' : 'image/jpg',
|
||||
'.pict': 'image/pict',
|
||||
'.pct' : 'image/pict',
|
||||
'.pic' : 'image/pict',
|
||||
'.pict': 'image/pict',
|
||||
'.rtf' : 'application/rtf',
|
||||
'.xul' : 'text/xul'
|
||||
'.xul' : 'text/xul',
|
||||
}
|
||||
|
||||
|
||||
_default_mime_types()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
def _main():
|
||||
import getopt
|
||||
|
||||
USAGE = """\
|
||||
@@ -595,3 +608,7 @@ More than one type argument may be given.
|
||||
guess, encoding = guess_type(gtype, strict)
|
||||
if not guess: print("I don't know anything about type", gtype)
|
||||
else: print('type:', guess, 'encoding:', encoding)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
_main()
|
||||
|
||||
1445
Lib/test/mime.types
Normal file
1445
Lib/test/mime.types
Normal file
File diff suppressed because it is too large
Load Diff
294
Lib/test/test_mimetypes.py
Normal file
294
Lib/test/test_mimetypes.py
Normal file
@@ -0,0 +1,294 @@
|
||||
import io
|
||||
import locale
|
||||
import mimetypes
|
||||
import pathlib
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from test import support
|
||||
from platform import win32_edition
|
||||
|
||||
|
||||
def setUpModule():
|
||||
global knownfiles
|
||||
knownfiles = mimetypes.knownfiles
|
||||
|
||||
# Tell it we don't know about external files:
|
||||
mimetypes.knownfiles = []
|
||||
mimetypes.inited = False
|
||||
mimetypes._default_mime_types()
|
||||
|
||||
|
||||
def tearDownModule():
|
||||
# Restore knownfiles to its initial state
|
||||
mimetypes.knownfiles = knownfiles
|
||||
|
||||
|
||||
class MimeTypesTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.db = mimetypes.MimeTypes()
|
||||
|
||||
def test_default_data(self):
|
||||
eq = self.assertEqual
|
||||
eq(self.db.guess_type("foo.html"), ("text/html", None))
|
||||
eq(self.db.guess_type("foo.HTML"), ("text/html", None))
|
||||
eq(self.db.guess_type("foo.tgz"), ("application/x-tar", "gzip"))
|
||||
eq(self.db.guess_type("foo.tar.gz"), ("application/x-tar", "gzip"))
|
||||
eq(self.db.guess_type("foo.tar.Z"), ("application/x-tar", "compress"))
|
||||
eq(self.db.guess_type("foo.tar.bz2"), ("application/x-tar", "bzip2"))
|
||||
eq(self.db.guess_type("foo.tar.xz"), ("application/x-tar", "xz"))
|
||||
|
||||
def test_data_urls(self):
|
||||
eq = self.assertEqual
|
||||
guess_type = self.db.guess_type
|
||||
eq(guess_type("data:invalidDataWithoutComma"), (None, None))
|
||||
eq(guess_type("data:,thisIsTextPlain"), ("text/plain", None))
|
||||
eq(guess_type("data:;base64,thisIsTextPlain"), ("text/plain", None))
|
||||
eq(guess_type("data:text/x-foo,thisIsTextXFoo"), ("text/x-foo", None))
|
||||
|
||||
def test_file_parsing(self):
|
||||
eq = self.assertEqual
|
||||
sio = io.StringIO("x-application/x-unittest pyunit\n")
|
||||
self.db.readfp(sio)
|
||||
eq(self.db.guess_type("foo.pyunit"),
|
||||
("x-application/x-unittest", None))
|
||||
eq(self.db.guess_extension("x-application/x-unittest"), ".pyunit")
|
||||
|
||||
# TODO: RUSTPYTHON
|
||||
@unittest.expectedFailure
|
||||
def test_read_mime_types(self):
|
||||
eq = self.assertEqual
|
||||
|
||||
# Unreadable file returns None
|
||||
self.assertIsNone(mimetypes.read_mime_types("non-existent"))
|
||||
|
||||
with support.temp_dir() as directory:
|
||||
data = "x-application/x-unittest pyunit\n"
|
||||
file = pathlib.Path(directory, "sample.mimetype")
|
||||
file.write_text(data)
|
||||
mime_dict = mimetypes.read_mime_types(file)
|
||||
eq(mime_dict[".pyunit"], "x-application/x-unittest")
|
||||
|
||||
# bpo-41048: read_mime_types should read the rule file with 'utf-8' encoding.
|
||||
# Not with locale encoding. _bootlocale has been imported because io.open(...)
|
||||
# uses it.
|
||||
with support.temp_dir() as directory:
|
||||
data = "application/no-mans-land Fran\u00E7ais"
|
||||
file = pathlib.Path(directory, "sample.mimetype")
|
||||
file.write_text(data, encoding='utf-8')
|
||||
import _bootlocale
|
||||
with support.swap_attr(_bootlocale, 'getpreferredencoding', lambda do_setlocale=True: 'ASCII'):
|
||||
mime_dict = mimetypes.read_mime_types(file)
|
||||
eq(mime_dict[".Français"], "application/no-mans-land")
|
||||
|
||||
def test_non_standard_types(self):
|
||||
eq = self.assertEqual
|
||||
# First try strict
|
||||
eq(self.db.guess_type('foo.xul', strict=True), (None, None))
|
||||
eq(self.db.guess_extension('image/jpg', strict=True), None)
|
||||
# And then non-strict
|
||||
eq(self.db.guess_type('foo.xul', strict=False), ('text/xul', None))
|
||||
eq(self.db.guess_type('foo.XUL', strict=False), ('text/xul', None))
|
||||
eq(self.db.guess_type('foo.invalid', strict=False), (None, None))
|
||||
eq(self.db.guess_extension('image/jpg', strict=False), '.jpg')
|
||||
eq(self.db.guess_extension('image/JPG', strict=False), '.jpg')
|
||||
|
||||
def test_filename_with_url_delimiters(self):
|
||||
# bpo-38449: URL delimiters cases should be handled also.
|
||||
# They would have different mime types if interpreted as URL as
|
||||
# compared to when interpreted as filename because of the semicolon.
|
||||
eq = self.assertEqual
|
||||
gzip_expected = ('application/x-tar', 'gzip')
|
||||
eq(self.db.guess_type(";1.tar.gz"), gzip_expected)
|
||||
eq(self.db.guess_type("?1.tar.gz"), gzip_expected)
|
||||
eq(self.db.guess_type("#1.tar.gz"), gzip_expected)
|
||||
eq(self.db.guess_type("#1#.tar.gz"), gzip_expected)
|
||||
eq(self.db.guess_type(";1#.tar.gz"), gzip_expected)
|
||||
eq(self.db.guess_type(";&1=123;?.tar.gz"), gzip_expected)
|
||||
eq(self.db.guess_type("?k1=v1&k2=v2.tar.gz"), gzip_expected)
|
||||
eq(self.db.guess_type(r" \"\`;b&b&c |.tar.gz"), gzip_expected)
|
||||
|
||||
def test_guess_all_types(self):
|
||||
eq = self.assertEqual
|
||||
unless = self.assertTrue
|
||||
# First try strict. Use a set here for testing the results because if
|
||||
# test_urllib2 is run before test_mimetypes, global state is modified
|
||||
# such that the 'all' set will have more items in it.
|
||||
all = set(self.db.guess_all_extensions('text/plain', strict=True))
|
||||
unless(all >= set(['.bat', '.c', '.h', '.ksh', '.pl', '.txt']))
|
||||
# And now non-strict
|
||||
all = self.db.guess_all_extensions('image/jpg', strict=False)
|
||||
all.sort()
|
||||
eq(all, ['.jpg'])
|
||||
# And now for no hits
|
||||
all = self.db.guess_all_extensions('image/jpg', strict=True)
|
||||
eq(all, [])
|
||||
|
||||
def test_encoding(self):
|
||||
getpreferredencoding = locale.getpreferredencoding
|
||||
self.addCleanup(setattr, locale, 'getpreferredencoding',
|
||||
getpreferredencoding)
|
||||
locale.getpreferredencoding = lambda: 'ascii'
|
||||
|
||||
filename = support.findfile("mime.types")
|
||||
mimes = mimetypes.MimeTypes([filename])
|
||||
exts = mimes.guess_all_extensions('application/vnd.geocube+xml',
|
||||
strict=True)
|
||||
self.assertEqual(exts, ['.g3', '.g\xb3'])
|
||||
|
||||
def test_init_reinitializes(self):
|
||||
# Issue 4936: make sure an init starts clean
|
||||
# First, put some poison into the types table
|
||||
mimetypes.add_type('foo/bar', '.foobar')
|
||||
self.assertEqual(mimetypes.guess_extension('foo/bar'), '.foobar')
|
||||
# Reinitialize
|
||||
mimetypes.init()
|
||||
# Poison should be gone.
|
||||
self.assertEqual(mimetypes.guess_extension('foo/bar'), None)
|
||||
|
||||
def test_preferred_extension(self):
|
||||
def check_extensions():
|
||||
self.assertEqual(mimetypes.guess_extension('application/octet-stream'), '.bin')
|
||||
self.assertEqual(mimetypes.guess_extension('application/postscript'), '.ps')
|
||||
self.assertEqual(mimetypes.guess_extension('application/vnd.apple.mpegurl'), '.m3u')
|
||||
self.assertEqual(mimetypes.guess_extension('application/vnd.ms-excel'), '.xls')
|
||||
self.assertEqual(mimetypes.guess_extension('application/vnd.ms-powerpoint'), '.ppt')
|
||||
self.assertEqual(mimetypes.guess_extension('application/x-texinfo'), '.texi')
|
||||
self.assertEqual(mimetypes.guess_extension('application/x-troff'), '.roff')
|
||||
self.assertEqual(mimetypes.guess_extension('application/xml'), '.xsl')
|
||||
self.assertEqual(mimetypes.guess_extension('audio/mpeg'), '.mp3')
|
||||
self.assertEqual(mimetypes.guess_extension('image/jpeg'), '.jpg')
|
||||
self.assertEqual(mimetypes.guess_extension('image/tiff'), '.tiff')
|
||||
self.assertEqual(mimetypes.guess_extension('message/rfc822'), '.eml')
|
||||
self.assertEqual(mimetypes.guess_extension('text/html'), '.html')
|
||||
self.assertEqual(mimetypes.guess_extension('text/plain'), '.txt')
|
||||
self.assertEqual(mimetypes.guess_extension('video/mpeg'), '.mpeg')
|
||||
self.assertEqual(mimetypes.guess_extension('video/quicktime'), '.mov')
|
||||
|
||||
check_extensions()
|
||||
mimetypes.init()
|
||||
check_extensions()
|
||||
|
||||
def test_init_stability(self):
|
||||
mimetypes.init()
|
||||
|
||||
suffix_map = mimetypes.suffix_map
|
||||
encodings_map = mimetypes.encodings_map
|
||||
types_map = mimetypes.types_map
|
||||
common_types = mimetypes.common_types
|
||||
|
||||
mimetypes.init()
|
||||
self.assertIsNot(suffix_map, mimetypes.suffix_map)
|
||||
self.assertIsNot(encodings_map, mimetypes.encodings_map)
|
||||
self.assertIsNot(types_map, mimetypes.types_map)
|
||||
self.assertIsNot(common_types, mimetypes.common_types)
|
||||
self.assertEqual(suffix_map, mimetypes.suffix_map)
|
||||
self.assertEqual(encodings_map, mimetypes.encodings_map)
|
||||
self.assertEqual(types_map, mimetypes.types_map)
|
||||
self.assertEqual(common_types, mimetypes.common_types)
|
||||
|
||||
def test_path_like_ob(self):
|
||||
filename = "LICENSE.txt"
|
||||
filepath = pathlib.Path(filename)
|
||||
filepath_with_abs_dir = pathlib.Path('/dir/'+filename)
|
||||
filepath_relative = pathlib.Path('../dir/'+filename)
|
||||
path_dir = pathlib.Path('./')
|
||||
|
||||
expected = self.db.guess_type(filename)
|
||||
|
||||
self.assertEqual(self.db.guess_type(filepath), expected)
|
||||
self.assertEqual(self.db.guess_type(
|
||||
filepath_with_abs_dir), expected)
|
||||
self.assertEqual(self.db.guess_type(filepath_relative), expected)
|
||||
self.assertEqual(self.db.guess_type(path_dir), (None, None))
|
||||
|
||||
def test_keywords_args_api(self):
|
||||
self.assertEqual(self.db.guess_type(
|
||||
url="foo.html", strict=True), ("text/html", None))
|
||||
self.assertEqual(self.db.guess_all_extensions(
|
||||
type='image/jpg', strict=True), [])
|
||||
self.assertEqual(self.db.guess_extension(
|
||||
type='image/jpg', strict=False), '.jpg')
|
||||
|
||||
|
||||
@unittest.skipUnless(sys.platform.startswith("win"), "Windows only")
|
||||
class Win32MimeTypesTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
# ensure all entries actually come from the Windows registry
|
||||
self.original_types_map = mimetypes.types_map.copy()
|
||||
mimetypes.types_map.clear()
|
||||
mimetypes.init()
|
||||
self.db = mimetypes.MimeTypes()
|
||||
|
||||
def tearDown(self):
|
||||
# restore default settings
|
||||
mimetypes.types_map.clear()
|
||||
mimetypes.types_map.update(self.original_types_map)
|
||||
|
||||
@unittest.skipIf(win32_edition() in ('NanoServer', 'WindowsCoreHeadless', 'IoTEdgeOS'),
|
||||
"MIME types registry keys unavailable")
|
||||
def test_registry_parsing(self):
|
||||
# the original, minimum contents of the MIME database in the
|
||||
# Windows registry is undocumented AFAIK.
|
||||
# Use file types that should *always* exist:
|
||||
eq = self.assertEqual
|
||||
eq(self.db.guess_type("foo.txt"), ("text/plain", None))
|
||||
eq(self.db.guess_type("image.jpg"), ("image/jpeg", None))
|
||||
eq(self.db.guess_type("image.png"), ("image/png", None))
|
||||
|
||||
|
||||
class MiscTestCase(unittest.TestCase):
|
||||
def test__all__(self):
|
||||
support.check__all__(self, mimetypes)
|
||||
|
||||
|
||||
class MimetypesCliTestCase(unittest.TestCase):
|
||||
|
||||
def mimetypes_cmd(self, *args, **kwargs):
|
||||
support.patch(self, sys, "argv", [sys.executable, *args])
|
||||
with support.captured_stdout() as output:
|
||||
mimetypes._main()
|
||||
return output.getvalue().strip()
|
||||
|
||||
def test_help_option(self):
|
||||
support.patch(self, sys, "argv", [sys.executable, "-h"])
|
||||
with support.captured_stdout() as output:
|
||||
with self.assertRaises(SystemExit) as cm:
|
||||
mimetypes._main()
|
||||
|
||||
self.assertIn("Usage: mimetypes.py", output.getvalue())
|
||||
self.assertEqual(cm.exception.code, 0)
|
||||
|
||||
def test_invalid_option(self):
|
||||
support.patch(self, sys, "argv", [sys.executable, "--invalid"])
|
||||
with support.captured_stdout() as output:
|
||||
with self.assertRaises(SystemExit) as cm:
|
||||
mimetypes._main()
|
||||
|
||||
self.assertIn("Usage: mimetypes.py", output.getvalue())
|
||||
self.assertEqual(cm.exception.code, 1)
|
||||
|
||||
def test_guess_extension(self):
|
||||
eq = self.assertEqual
|
||||
|
||||
extension = self.mimetypes_cmd("-l", "-e", "image/jpg")
|
||||
eq(extension, ".jpg")
|
||||
|
||||
extension = self.mimetypes_cmd("-e", "image/jpg")
|
||||
eq(extension, "I don't know anything about type image/jpg")
|
||||
|
||||
extension = self.mimetypes_cmd("-e", "image/jpeg")
|
||||
eq(extension, ".jpg")
|
||||
|
||||
def test_guess_type(self):
|
||||
eq = self.assertEqual
|
||||
|
||||
type_info = self.mimetypes_cmd("-l", "foo.pic")
|
||||
eq(type_info, "type: image/pict encoding: None")
|
||||
|
||||
type_info = self.mimetypes_cmd("foo.pic")
|
||||
eq(type_info, "I don't know anything about type foo.pic")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user