gh-131178: Add tests for http.server command-line interface

Lib/http/server.py

@@ -106,6 +106,8 @@
 import sys
 import time
 import urllib.parse
+import argparse
+import contextlib
 
 from http import HTTPStatus
 
@@ -150,7 +152,6 @@ def server_bind(self):
 class ThreadingHTTPServer(socketserver.ThreadingMixIn, HTTPServer):
     daemon_threads = True
 
-
 class HTTPSServer(HTTPServer):
     def __init__(self, server_address, RequestHandlerClass,
                  bind_and_activate=True, *, certfile, keyfile=None,
@@ -1306,7 +1307,7 @@ def _get_best_family(*address):
 
 def test(HandlerClass=BaseHTTPRequestHandler,
          ServerClass=ThreadingHTTPServer,
-         protocol="HTTP/1.0", port=8000, bind=None,
+         protocol="HTTP/1.0", port=8000, bind=None, directory=None,
          tls_cert=None, tls_key=None, tls_password=None):
     """Test the HTTP request handler class.
 
@@ -1319,6 +1320,24 @@ def test(HandlerClass=BaseHTTPRequestHandler,
     if tls_cert:
         server = ThreadingHTTPSServer(addr, HandlerClass, certfile=tls_cert,
                                       keyfile=tls_key, password=tls_password)
+    elif ServerClass is ThreadingHTTPServer:
+        # ensure dual-stack is not disabled; ref #38907
+        class DualStackServer(ThreadingHTTPServer):
+            def __init__(self, server_address, RequestHandlerClass, directory=None):
+                super().__init__(server_address, RequestHandlerClass)
+                self.directory = directory
+
+            def server_bind(self):
+                # suppress exception when protocol is IPv4
+                with contextlib.suppress(Exception):
+                    self.socket.setsockopt(
+                        socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+                return super().server_bind()
+
+            def finish_request(self, request, client_address):
+                self.RequestHandlerClass(request, client_address, self,
+                                        directory=self.directory)
+        server = DualStackServer(addr, HandlerClass, directory=directory)
     else:
         server = ServerClass(addr, HandlerClass)
 
@@ -1336,10 +1355,7 @@ def test(HandlerClass=BaseHTTPRequestHandler,
             print("\nKeyboard interrupt received, exiting.")
             sys.exit(0)
 
-if __name__ == '__main__':
-    import argparse
-    import contextlib
-
+def _main(args=None):
     parser = argparse.ArgumentParser()
     parser.add_argument('--cgi', action='store_true',
                         help='run as CGI server')
@@ -1362,7 +1378,7 @@ def test(HandlerClass=BaseHTTPRequestHandler,
     parser.add_argument('port', default=8000, type=int, nargs='?',
                         help='bind to this port '
                              '(default: %(default)s)')
-    args = parser.parse_args()
+    args = parser.parse_args(args=args)
 
     if not args.tls_cert and args.tls_key:
         parser.error("--tls-key requires --tls-cert to be set")
@@ -1383,27 +1399,18 @@ def test(HandlerClass=BaseHTTPRequestHandler,
     else:
         handler_class = SimpleHTTPRequestHandler
 
-    # ensure dual-stack is not disabled; ref #38907
-    class DualStackServer(ThreadingHTTPServer):
-
-        def server_bind(self):
-            # suppress exception when protocol is IPv4
-            with contextlib.suppress(Exception):
-                self.socket.setsockopt(
-                    socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
-            return super().server_bind()
-
-        def finish_request(self, request, client_address):
-            self.RequestHandlerClass(request, client_address, self,
-                                     directory=args.directory)
-
     test(
         HandlerClass=handler_class,
-        ServerClass=DualStackServer,
+        ServerClass=ThreadingHTTPServer,
         port=args.port,
         bind=args.bind,
         protocol=args.protocol,
+        directory=args.directory,
         tls_cert=args.tls_cert,
         tls_key=args.tls_key,
         tls_password=tls_key_password,
     )
+
+
+if __name__ == '__main__':
+    _main()

Lib/test/test_httpservers.py

@@ -8,6 +8,7 @@
      SimpleHTTPRequestHandler, CGIHTTPRequestHandler
 from http import server, HTTPStatus
 
+import http.server
 import os
 import socket
 import sys
@@ -27,6 +28,8 @@
 import threading
 from unittest import mock
 from io import BytesIO, StringIO
+import textwrap
+import contextlib
 
 import unittest
 from test import support
@@ -1466,7 +1469,7 @@ def test_windows_colon(self):
 class MiscTestCase(unittest.TestCase):
     def test_all(self):
         expected = []
-        denylist = {'executable', 'nobody_uid', 'test'}
+        denylist = {'executable', 'nobody_uid', 'test', 'CommandLineServerClass'}
         for name in dir(server):
             if name.startswith('_') or name in denylist:
                 continue
@@ -1535,6 +1538,158 @@ def test_server_test_ipv4(self, _):
             server.test(ServerClass=mock_server, bind=bind)
             self.assertEqual(mock_server.address_family, socket.AF_INET)
 
+class CommandLineTestCase(unittest.TestCase):
+    def setUp(self):
+        self.default_port = 8000
+        self.default_bind = None
+        self.default_protocol = 'HTTP/1.0'
+        self.default_directory = os.getcwd()
+        self.default_handler = SimpleHTTPRequestHandler
+        self.default_server = http.server.ThreadingHTTPServer
+        self.tls_cert = certdata_file('ssl_cert.pem')
+        self.tls_key = certdata_file('ssl_key.pem')
+        self.tls_password = 'somepass'
+        tls_password_file_object = tempfile.NamedTemporaryFile(mode='w+', delete=False)
+        tls_password_file_object.write(self.tls_password)
+        self.tls_password_file = tls_password_file_object.name
+        tls_password_file_object.close()
+        return super().setUp()
+
+    def tearDown(self):
+        if os.path.exists(self.tls_password_file):
+            os.remove(self.tls_password_file)
+        return super().tearDown()
+
+    def text_normalizer(self, string):
+        return textwrap.dedent(string).strip()
+
+    def invoke_httpd(self, args=[]):
+        output = StringIO()
+        with contextlib.redirect_stdout(output):
+            server._main(args)
+        return self.text_normalizer(output.getvalue())
+
+    @mock.patch('http.server.test')
+    def test_port_flag(self, mock_func):
+        ports = [8000, 65535,]
+        for port in ports:
+            with self.subTest(port=port):
+                self.invoke_httpd([str(port)])
+                mock_func.assert_called_once_with(HandlerClass=self.default_handler, ServerClass=self.default_server,
+                                                  protocol=self.default_protocol, port=port, bind=self.default_bind, directory=self.default_directory,
+                                                  tls_cert=None, tls_key=None, tls_password=None)
+                mock_func.reset_mock()
+
+    @mock.patch('http.server.test')
+    def test_directory_flag(self, mock_func):
+        options = ['-d', '--directory']
+        directories = ['.', '/foo', '\\bar', '/', 'C:\\', 'C:\\foo', 'C:\\bar',]
+        for flag in options:
+            for directory in directories:
+                with self.subTest(flag=flag, directory=directory):
+                    self.invoke_httpd([flag, directory])
+                    mock_func.assert_called_once_with(HandlerClass=self.default_handler, ServerClass=self.default_server,
+                                                      protocol=self.default_protocol, port=self.default_port, bind=self.default_bind, directory=directory,
+                                                      tls_cert=None, tls_key=None, tls_password=None)
+                    mock_func.reset_mock()
+
+    @mock.patch('http.server.test')
+    def test_bind_flag(self, mock_func):
+        options = ['-b', '--bind']
+        bind_addresses = ['localhost', '127.0.0.1', '::1', '0.0.0.0', '8.8.8.8',]
+        for flag in options:
+            for bind_address in bind_addresses:
+                with self.subTest(flag=flag, bind_address=bind_address):
+                    self.invoke_httpd([flag, bind_address])
+                    mock_func.assert_called_once_with(HandlerClass=self.default_handler, ServerClass=self.default_server,
+                                                      protocol=self.default_protocol, port=self.default_port, bind=bind_address, directory=self.default_directory,
+                                                      tls_cert=None, tls_key=None, tls_password=None)
+                    mock_func.reset_mock()
+
+    @mock.patch('http.server.test')
+    def test_protocol_flag(self, mock_func):
+        options = ['-p', '--protocol']
+        protocols = ['HTTP/1.0', 'HTTP/1.1', 'HTTP/2.0', 'HTTP/3.0',]
+        for flag in options:
+            for protocol in protocols:
+                with self.subTest(flag=flag, protocol=protocol):
+                    self.invoke_httpd([flag, protocol])
+                    mock_func.assert_called_once_with(HandlerClass=self.default_handler, ServerClass=self.default_server,
+                                                      protocol=protocol, port=self.default_port, bind=self.default_bind, directory=self.default_directory,
+                                                      tls_cert=None, tls_key=None, tls_password=None)
+                    mock_func.reset_mock()
+
+    @mock.patch('http.server.test')
+    def test_cgi_flag(self, mock_func):
+        self.invoke_httpd(['--cgi'])
+        mock_func.assert_called_once_with(HandlerClass=CGIHTTPRequestHandler, ServerClass=self.default_server,
+                                          protocol=self.default_protocol, port=self.default_port, bind=self.default_bind, directory=self.default_directory,
+                                          tls_cert=None, tls_key=None, tls_password=None)
+
+    @mock.patch('http.server.test')
+    def test_tls_flag(self, mock_func):
+        tls_cert_options = ['--tls-cert', ]
+        tls_key_options = ['--tls-key', ]
+        tls_password_options = ['--tls-password-file', ]
+        # Normal: --tls-cert and --tls-key
+
+        for tls_cert_option in tls_cert_options:
+            for tls_key_option in tls_key_options:
+                self.invoke_httpd([tls_cert_option, self.tls_cert, tls_key_option, self.tls_key])
+                mock_func.assert_called_once_with(HandlerClass=self.default_handler, ServerClass=self.default_server,
+                                                  protocol=self.default_protocol, port=self.default_port, bind=self.default_bind, directory=self.default_directory,
+                                                  tls_cert=self.tls_cert, tls_key=self.tls_key, tls_password=None)
+                mock_func.reset_mock()
+
+        # Normal: --tls-cert, --tls-key and --tls-password-file
+
+        for tls_cert_option in tls_cert_options:
+            for tls_key_option in tls_key_options:
+                for tls_password_option in tls_password_options:
+                    self.invoke_httpd([tls_cert_option, self.tls_cert, tls_key_option, self.tls_key, tls_password_option, self.tls_password_file])
+
+                    mock_func.assert_called_once_with(HandlerClass=self.default_handler, ServerClass=self.default_server,
+                                                      protocol=self.default_protocol, port=self.default_port, bind=self.default_bind, directory=self.default_directory,
+                                                      tls_cert=self.tls_cert, tls_key=self.tls_key, tls_password=self.tls_password)
+                    mock_func.reset_mock()
+
+        # Abnormal: --tls-key without --tls-cert
+
+        for tls_key_option in tls_key_options:
+            for tls_cert_option in tls_cert_options:
+                with self.assertRaises(SystemExit):
+                    self.invoke_httpd([tls_key_option, self.tls_key])
+                    mock_func.reset_mock()
+
+        # Abnormal: --tls-password-file without --tls-cert
+
+        for tls_password_option in tls_password_options:
+            with self.assertRaises(SystemExit):
+                self.invoke_httpd([tls_password_option, self.tls_password_file])
+                mock_func.reset_mock()
+
+        # Abnormal: --tls-password-file cannot be opened
+
+        non_existent_file = os.path.join(tempfile.gettempdir(), os.urandom(16).hex())
+        retry_count = 0
+        while os.path.exists(non_existent_file) and retry_count < 10:
+            non_existent_file = os.path.join(tempfile.gettempdir(), os.urandom(16).hex())
+        if not os.path.exists(non_existent_file):
+            for tls_password_option in tls_password_options:
+                for tls_cert_option in tls_cert_options:
+                    with self.assertRaises(SystemExit):
+                        self.invoke_httpd([tls_cert_option, self.tls_cert, tls_password_option, non_existent_file])
+
+    def test_help_flag(self):
+        options = ['-h', '--help']
+        for option in options:
+            with self.assertRaises(SystemExit):
+                output = self.invoke_httpd([option])
+                self.assertIn('usage:', output)
+
+    def test_unknown_flag(self):
+        with self.assertRaises(SystemExit):
+            self.invoke_httpd(['--unknown-flag'])
 
 def setUpModule():
     unittest.addModuleCleanup(os.chdir, os.getcwd())

Misc/NEWS.d/next/Library/2025-04-15-12-47-09.gh-issue-131178.Td8j5x.rst

@@ -0,0 +1 @@
+Add tests for the command line interface of the ``http.server`` module.