use Hugo's approach for testing mimetypes

Author: picnixz

Lib/mimetypes.py

@@ -669,9 +669,7 @@ def _default_mime_types():
 _default_mime_types()
 
 
-def _main(args=None):
-    """Run the mimetypes command-line interface."""
-    import sys
+def _parse_args(args):
     from argparse import ArgumentParser
 
     parser = ArgumentParser(description='map filename extensions to MIME types')
@@ -687,24 +685,29 @@ def _main(args=None):
     )
     parser.add_argument('type', nargs='+', help='a type to search')
     args = parser.parse_args(args)
+    return args, parser.format_help()
+
+
+def _main(args=None):
+    """Run the mimetypes command-line interface and return a text to print."""
+    import sys
+
+    args, help_text = _parse_args(args)
 
     if args.extension:
         for gtype in args.type:
             guess = guess_extension(gtype, not args.lenient)
             if guess:
-                print(guess)
-            else:
-                # do not use parser.error() as it prints a help message
-                parser.exit(1, f"error: unknown type {gtype}\n")
+                return str(guess)
+            sys.exit(f"error: unknown type {gtype}")
     else:
         for gtype in args.type:
             guess, encoding = guess_type(gtype, not args.lenient)
             if guess:
-                print('type:', guess, 'encoding:', encoding)
-            else:
-                # do not use parser.error() as it prints a help message
-                parser.exit(1, f"error: media type unknown for {gtype}\n")
+                return f"type: {guess} encoding: {encoding}"
+            sys.exit(f"error: media type unknown for {gtype}")
+    return parser.format_help()
 
 
 if __name__ == '__main__':
-    _main()
+    print(_main())

Lib/test/test_mimetypes.py

@@ -2,6 +2,7 @@
 import io
 import mimetypes
 import os
+import shlex
 import sys
 import unittest.mock
 from platform import win32_edition
@@ -389,61 +390,51 @@ def test__all__(self):
         support.check__all__(self, mimetypes)
 
 
-class MimetypesCliTestCase(unittest.TestCase):
-
-    def mimetypes_cmd(self, *args):
-        # We cannot use run_python_until_end() as the latter would not
-        # call setUpModule() which unsets mimetypes.knowfiles. Instead,
-        # we need to directly call the main() function in order to avoid
-        # re-initializing the database.
-        rc, out, err = 0, io.StringIO(), io.StringIO()
-        with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
-            try:
-                mimetypes._main(args)
-            except SystemExit as exc:
-                self.assertIsInstance(exc.code, int)
-                rc = exc.code
-        return rc, out.getvalue(), err.getvalue()
-
-    def test_help_option(self):
-        retcode, out, err = self.mimetypes_cmd('-h')
-        self.assertEqual(retcode, 0)
-        self.assertStartsWith(out, 'usage: ')
-        self.assertEqual(err, '')
-
-    def test_invalid_option(self):
-        retcode, out, err = self.mimetypes_cmd('--invalid')
-        self.assertEqual(retcode, 2)
-        self.assertEqual(out, '')
-        self.assertStartsWith(err, 'usage: ')
-
-    def test_guess_extension(self):
-        retcode, out, err = self.mimetypes_cmd('-l', '-e', 'image/jpg')
-        self.assertEqual(retcode, 0)
-        self.assertEqual(out, '.jpg\n')
-        self.assertEqual(err, '')
-
-        retcode, out, err = self.mimetypes_cmd('-e', 'image/jpg')
-        self.assertEqual(retcode, 1)
-        self.assertEqual(out, '')
-        self.assertEqual(err, 'error: unknown type image/jpg\n')
-
-        retcode, out, err = self.mimetypes_cmd('-e', 'image/jpeg')
-        self.assertEqual(retcode, 0)
-        self.assertEqual(out, '.jpg\n')
-        self.assertEqual(err, '')
-
-    def test_guess_type(self):
-        retcode, out, err = self.mimetypes_cmd('-l', 'foo.webp')
-        self.assertEqual(retcode, 0)
-        self.assertEqual(out, 'type: image/webp encoding: None\n')
-        self.assertEqual(err, '')
-
-    def test_guess_type_conflicting_with_mimetypes(self):
-        retcode, out, err = self.mimetypes_cmd('foo.pic')
-        self.assertEqual(retcode, 1)
-        self.assertEqual(out, '')
-        self.assertEqual(err, 'error: media type unknown for foo.pic\n')
+class CommandLineTest(unittest.TestCase):
+    def test_parse_args(self):
+        args, help_text = mimetypes._parse_args("-h")
+        self.assertTrue(help_text.startswith("usage: "))
+
+        args, help_text = mimetypes._parse_args("--invalid")
+        self.assertTrue(help_text.startswith("usage: "))
+
+        args, _ = mimetypes._parse_args(shlex.split("-l -e image/jpg"))
+        self.assertTrue(args.extension)
+        self.assertTrue(args.lenient)
+        self.assertEqual(args.type, ["image/jpg"])
+
+        args, _ = mimetypes._parse_args(shlex.split("-e image/jpg"))
+        self.assertTrue(args.extension)
+        self.assertFalse(args.lenient)
+        self.assertEqual(args.type, ["image/jpg"])
+
+        args, _ = mimetypes._parse_args(shlex.split("-l foo.webp"))
+        self.assertFalse(args.extension)
+        self.assertTrue(args.lenient)
+        self.assertEqual(args.type, ["foo.webp"])
+
+        args, _ = mimetypes._parse_args(shlex.split("foo.pic"))
+        self.assertFalse(args.extension)
+        self.assertFalse(args.lenient)
+        self.assertEqual(args.type, ["foo.pic"])
+
+
+    def test_invocation(self):
+        for command, expected in [
+            ("-l -e image/jpg", ".jpg"),
+            ("-e image/jpeg", ".jpg"),
+            ("-l foo.webp", "type: image/webp encoding: None"),
+        ]:
+            self.assertEqual(mimetypes._main(shlex.split(command)), expected)
+
+
+    def test_invocation_error(self):
+        for command, expected in [
+            ("-e image/jpg", "error: unknown type image/jpg"),
+            ("foo.pic", "error: media type unknown for foo.pic"),
+        ]:
+            with self.assertRaisesRegex(SystemExit, expected):
+                mimetypes._main(shlex.split(command))
 
 
 if __name__ == "__main__":