|
| 1 | +import copy |
| 2 | +import os |
| 3 | +import sys |
| 4 | +import test.support |
| 5 | +import unittest |
| 6 | +from test import support as os_helper |
| 7 | +from test import support as warnings_helper |
| 8 | +from collections import OrderedDict |
| 9 | + |
| 10 | +import mailcap |
| 11 | + |
| 12 | + |
| 13 | +# Location of mailcap file |
| 14 | +MAILCAPFILE = test.support.findfile("mailcap.txt") |
| 15 | + |
| 16 | +# Dict to act as mock mailcap entry for this test |
| 17 | +# The keys and values should match the contents of MAILCAPFILE |
| 18 | + |
| 19 | +MAILCAPDICT = { |
| 20 | + 'application/x-movie': |
| 21 | + [{'compose': 'moviemaker %s', |
| 22 | + 'x11-bitmap': '"/usr/lib/Zmail/bitmaps/movie.xbm"', |
| 23 | + 'description': '"Movie"', |
| 24 | + 'view': 'movieplayer %s', |
| 25 | + 'lineno': 4}], |
| 26 | + 'application/*': |
| 27 | + [{'copiousoutput': '', |
| 28 | + 'view': 'echo "This is \\"%t\\" but is 50 \\% Greek to me" \\; cat %s', |
| 29 | + 'lineno': 5}], |
| 30 | + 'audio/basic': |
| 31 | + [{'edit': 'audiocompose %s', |
| 32 | + 'compose': 'audiocompose %s', |
| 33 | + 'description': '"An audio fragment"', |
| 34 | + 'view': 'showaudio %s', |
| 35 | + 'lineno': 6}], |
| 36 | + 'video/mpeg': |
| 37 | + [{'view': 'mpeg_play %s', 'lineno': 13}], |
| 38 | + 'application/postscript': |
| 39 | + [{'needsterminal': '', 'view': 'ps-to-terminal %s', 'lineno': 1}, |
| 40 | + {'compose': 'idraw %s', 'view': 'ps-to-terminal %s', 'lineno': 2}], |
| 41 | + 'application/x-dvi': |
| 42 | + [{'view': 'xdvi %s', 'lineno': 3}], |
| 43 | + 'message/external-body': |
| 44 | + [{'composetyped': 'extcompose %s', |
| 45 | + 'description': '"A reference to data stored in an external location"', |
| 46 | + 'needsterminal': '', |
| 47 | + 'view': 'showexternal %s %{access-type} %{name} %{site} %{directory} %{mode} %{server}', |
| 48 | + 'lineno': 10}], |
| 49 | + 'text/richtext': |
| 50 | + [{'test': 'test "`echo %{charset} | tr \'[A-Z]\' \'[a-z]\'`" = iso-8859-8', |
| 51 | + 'copiousoutput': '', |
| 52 | + 'view': 'shownonascii iso-8859-8 -e richtext -p %s', |
| 53 | + 'lineno': 11}], |
| 54 | + 'image/x-xwindowdump': |
| 55 | + [{'view': 'display %s', 'lineno': 9}], |
| 56 | + 'audio/*': |
| 57 | + [{'view': '/usr/local/bin/showaudio %t', 'lineno': 7}], |
| 58 | + 'video/*': |
| 59 | + [{'view': 'animate %s', 'lineno': 12}], |
| 60 | + 'application/frame': |
| 61 | + [{'print': '"cat %s | lp"', 'view': 'showframe %s', 'lineno': 0}], |
| 62 | + 'image/rgb': |
| 63 | + [{'view': 'display %s', 'lineno': 8}] |
| 64 | +} |
| 65 | + |
| 66 | +# In Python 2, mailcap doesn't return line numbers. |
| 67 | +# This test suite is copied from Python 3.11; for easier backporting we keep |
| 68 | +# data from there and remove the lineno. |
| 69 | +# So, for Python 2, MAILCAPDICT_DEPRECATED is the same as MAILCAPDICT |
| 70 | +MAILCAPDICT_DEPRECATED = MAILCAPDICT |
| 71 | +for entry_list in MAILCAPDICT_DEPRECATED.values(): |
| 72 | + for entry in entry_list: |
| 73 | + entry.pop('lineno') |
| 74 | + |
| 75 | + |
| 76 | +class HelperFunctionTest(unittest.TestCase): |
| 77 | + |
| 78 | + def test_listmailcapfiles(self): |
| 79 | + # The return value for listmailcapfiles() will vary by system. |
| 80 | + # So verify that listmailcapfiles() returns a list of strings that is of |
| 81 | + # non-zero length. |
| 82 | + mcfiles = mailcap.listmailcapfiles() |
| 83 | + self.assertIsInstance(mcfiles, list) |
| 84 | + for m in mcfiles: |
| 85 | + self.assertIsInstance(m, str) |
| 86 | + with os_helper.EnvironmentVarGuard() as env: |
| 87 | + # According to RFC 1524, if MAILCAPS env variable exists, use that |
| 88 | + # and only that. |
| 89 | + if "MAILCAPS" in env: |
| 90 | + env_mailcaps = env["MAILCAPS"].split(os.pathsep) |
| 91 | + else: |
| 92 | + env_mailcaps = ["/testdir1/.mailcap", "/testdir2/mailcap"] |
| 93 | + env["MAILCAPS"] = os.pathsep.join(env_mailcaps) |
| 94 | + mcfiles = mailcap.listmailcapfiles() |
| 95 | + self.assertEqual(env_mailcaps, mcfiles) |
| 96 | + |
| 97 | + def test_readmailcapfile(self): |
| 98 | + # Test readmailcapfile() using test file. It should match MAILCAPDICT. |
| 99 | + with open(MAILCAPFILE, 'r') as mcf: |
| 100 | + d = mailcap.readmailcapfile(mcf) |
| 101 | + self.assertDictEqual(d, MAILCAPDICT_DEPRECATED) |
| 102 | + |
| 103 | + def test_lookup(self): |
| 104 | + # Test without key |
| 105 | + |
| 106 | + # In Python 2, 'video/mpeg' is tried before 'video/*' |
| 107 | + # (unfixed bug: https://github.com/python/cpython/issues/59182 ) |
| 108 | + # So, these are in reverse order: |
| 109 | + expected = [{'view': 'mpeg_play %s', }, |
| 110 | + {'view': 'animate %s', }] |
| 111 | + actual = mailcap.lookup(MAILCAPDICT, 'video/mpeg') |
| 112 | + self.assertListEqual(expected, actual) |
| 113 | + |
| 114 | + # Test with key |
| 115 | + key = 'compose' |
| 116 | + expected = [{'edit': 'audiocompose %s', |
| 117 | + 'compose': 'audiocompose %s', |
| 118 | + 'description': '"An audio fragment"', |
| 119 | + 'view': 'showaudio %s', |
| 120 | + }] |
| 121 | + actual = mailcap.lookup(MAILCAPDICT, 'audio/basic', key) |
| 122 | + self.assertListEqual(expected, actual) |
| 123 | + |
| 124 | + # Test on user-defined dicts without line numbers |
| 125 | + expected = [{'view': 'mpeg_play %s'}, {'view': 'animate %s'}] |
| 126 | + actual = mailcap.lookup(MAILCAPDICT_DEPRECATED, 'video/mpeg') |
| 127 | + self.assertListEqual(expected, actual) |
| 128 | + |
| 129 | + def test_subst(self): |
| 130 | + plist = ['id=1', 'number=2', 'total=3'] |
| 131 | + # test case: ([field, MIMEtype, filename, plist=[]], <expected string>) |
| 132 | + test_cases = [ |
| 133 | + (["", "audio/*", "foo.txt"], ""), |
| 134 | + (["echo foo", "audio/*", "foo.txt"], "echo foo"), |
| 135 | + (["echo %s", "audio/*", "foo.txt"], "echo foo.txt"), |
| 136 | + (["echo %t", "audio/*", "foo.txt"], None), |
| 137 | + (["echo %t", "audio/wav", "foo.txt"], "echo audio/wav"), |
| 138 | + (["echo \\%t", "audio/*", "foo.txt"], "echo %t"), |
| 139 | + (["echo foo", "audio/*", "foo.txt", plist], "echo foo"), |
| 140 | + (["echo %{total}", "audio/*", "foo.txt", plist], "echo 3") |
| 141 | + ] |
| 142 | + for tc in test_cases: |
| 143 | + self.assertEqual(mailcap.subst(*tc[0]), tc[1]) |
| 144 | + |
| 145 | +class GetcapsTest(unittest.TestCase): |
| 146 | + |
| 147 | + def test_mock_getcaps(self): |
| 148 | + # Test mailcap.getcaps() using mock mailcap file in this dir. |
| 149 | + # Temporarily override any existing system mailcap file by pointing the |
| 150 | + # MAILCAPS environment variable to our mock file. |
| 151 | + with os_helper.EnvironmentVarGuard() as env: |
| 152 | + env["MAILCAPS"] = MAILCAPFILE |
| 153 | + caps = mailcap.getcaps() |
| 154 | + self.assertDictEqual(caps, MAILCAPDICT) |
| 155 | + |
| 156 | + def test_system_mailcap(self): |
| 157 | + # Test mailcap.getcaps() with mailcap file(s) on system, if any. |
| 158 | + caps = mailcap.getcaps() |
| 159 | + self.assertIsInstance(caps, dict) |
| 160 | + mailcapfiles = mailcap.listmailcapfiles() |
| 161 | + existingmcfiles = [mcf for mcf in mailcapfiles if os.path.exists(mcf)] |
| 162 | + if existingmcfiles: |
| 163 | + # At least 1 mailcap file exists, so test that. |
| 164 | + for (k, v) in caps.items(): |
| 165 | + self.assertIsInstance(k, str) |
| 166 | + self.assertIsInstance(v, list) |
| 167 | + for e in v: |
| 168 | + self.assertIsInstance(e, dict) |
| 169 | + else: |
| 170 | + # No mailcap files on system. getcaps() should return empty dict. |
| 171 | + self.assertEqual({}, caps) |
| 172 | + |
| 173 | + |
| 174 | +class FindmatchTest(unittest.TestCase): |
| 175 | + |
| 176 | + def test_findmatch(self): |
| 177 | + |
| 178 | + # default findmatch arguments |
| 179 | + c = MAILCAPDICT |
| 180 | + fname = "foo.txt" |
| 181 | + plist = ["access-type=default", "name=john", "site=python.org", |
| 182 | + "directory=/tmp", "mode=foo", "server=bar"] |
| 183 | + audio_basic_entry = { |
| 184 | + 'edit': 'audiocompose %s', |
| 185 | + 'compose': 'audiocompose %s', |
| 186 | + 'description': '"An audio fragment"', |
| 187 | + 'view': 'showaudio %s', |
| 188 | + } |
| 189 | + audio_entry = {"view": "/usr/local/bin/showaudio %t", } |
| 190 | + video_entry = {'view': 'animate %s', } |
| 191 | + mpeg_entry = {'view': 'mpeg_play %s', } |
| 192 | + message_entry = { |
| 193 | + 'composetyped': 'extcompose %s', |
| 194 | + 'description': '"A reference to data stored in an external location"', 'needsterminal': '', |
| 195 | + 'view': 'showexternal %s %{access-type} %{name} %{site} %{directory} %{mode} %{server}', |
| 196 | + } |
| 197 | + |
| 198 | + # test case: (findmatch args, findmatch keyword args, expected output) |
| 199 | + # positional args: caps, MIMEtype |
| 200 | + # keyword args: key="view", filename="/dev/null", plist=[] |
| 201 | + # output: (command line, mailcap entry) |
| 202 | + cases = [ |
| 203 | + ([{}, "video/mpeg"], {}, (None, None)), |
| 204 | + ([c, "foo/bar"], {}, (None, None)), |
| 205 | + |
| 206 | + # In Python 2, 'video/mpeg' is tried before 'video/*' |
| 207 | + # (unfixed bug: https://github.com/python/cpython/issues/59182 ) |
| 208 | + #([c, "video/mpeg"], {}, ('animate /dev/null', video_entry)), |
| 209 | + ([c, "video/mpeg"], {}, ('mpeg_play /dev/null', mpeg_entry)), |
| 210 | + |
| 211 | + ([c, "audio/basic", "edit"], {}, ("audiocompose /dev/null", audio_basic_entry)), |
| 212 | + ([c, "audio/basic", "compose"], {}, ("audiocompose /dev/null", audio_basic_entry)), |
| 213 | + ([c, "audio/basic", "description"], {}, ('"An audio fragment"', audio_basic_entry)), |
| 214 | + ([c, "audio/basic", "foobar"], {}, (None, None)), |
| 215 | + ([c, "video/*"], {"filename": fname}, ("animate %s" % fname, video_entry)), |
| 216 | + ([c, "audio/basic", "compose"], |
| 217 | + {"filename": fname}, |
| 218 | + ("audiocompose %s" % fname, audio_basic_entry)), |
| 219 | + ([c, "audio/basic"], |
| 220 | + {"key": "description", "filename": fname}, |
| 221 | + ('"An audio fragment"', audio_basic_entry)), |
| 222 | + ([c, "audio/*"], |
| 223 | + {"filename": fname}, |
| 224 | + (None, None)), |
| 225 | + ([c, "audio/wav"], |
| 226 | + {"filename": fname}, |
| 227 | + ("/usr/local/bin/showaudio audio/wav", audio_entry)), |
| 228 | + ([c, "message/external-body"], |
| 229 | + {"plist": plist}, |
| 230 | + ("showexternal /dev/null default john python.org /tmp foo bar", message_entry)) |
| 231 | + ] |
| 232 | + self._run_cases(cases) |
| 233 | + |
| 234 | + @unittest.skipUnless(os.name == "posix", "Requires 'test' command on system") |
| 235 | + @unittest.skipIf(sys.platform == "vxworks", "'test' command is not supported on VxWorks") |
| 236 | + def test_test(self): |
| 237 | + # findmatch() will automatically check any "test" conditions and skip |
| 238 | + # the entry if the check fails. |
| 239 | + caps = {"test/pass": [{"test": "test 1 -eq 1"}], |
| 240 | + "test/fail": [{"test": "test 1 -eq 0"}]} |
| 241 | + # test case: (findmatch args, findmatch keyword args, expected output) |
| 242 | + # positional args: caps, MIMEtype, key ("test") |
| 243 | + # keyword args: N/A |
| 244 | + # output: (command line, mailcap entry) |
| 245 | + cases = [ |
| 246 | + # findmatch will return the mailcap entry for test/pass because it evaluates to true |
| 247 | + ([caps, "test/pass", "test"], {}, ("test 1 -eq 1", {"test": "test 1 -eq 1"})), |
| 248 | + # findmatch will return None because test/fail evaluates to false |
| 249 | + ([caps, "test/fail", "test"], {}, (None, None)) |
| 250 | + ] |
| 251 | + self._run_cases(cases) |
| 252 | + |
| 253 | + def _run_cases(self, cases): |
| 254 | + for c in cases: |
| 255 | + self.assertEqual(mailcap.findmatch(*c[0], **c[1]), c[2]) |
| 256 | + |
| 257 | + |
| 258 | +def test_main(): |
| 259 | + test.support.run_unittest(HelperFunctionTest, GetcapsTest, FindmatchTest) |
0 commit comments