Add tests for http.server command-line interface

picnixz · May 19, 2025 · Apr 14, 2025 · Apr 15, 2025 · Apr 15, 2025 · Apr 15, 2025
commit 79db2f2216f347c2ad19ef2c2c188a9155906b5c
diff --git a/Lib/http/server.py b/Lib/http/server.py
@@ -106,6 +106,8 @@
 import sys
 import time
 import urllib.parse
+import argparse
+import contextlib
 
 from http import HTTPStatus
 
@@ -150,6 +152,20 @@ def server_bind(self):
 class ThreadingHTTPServer(socketserver.ThreadingMixIn, HTTPServer):
     daemon_threads = True
 
+class CommandLineServerClass(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)
 
 class HTTPSServer(HTTPServer):
     def __init__(self, server_address, RequestHandlerClass,
@@ -1336,10 +1352,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 +1375,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")
@@ -1399,11 +1412,15 @@ def finish_request(self, request, client_address):
 
     test(
         HandlerClass=handler_class,
-        ServerClass=DualStackServer,
+        ServerClass=CommandLineServerClass,
         port=args.port,
         bind=args.bind,
         protocol=args.protocol,
         tls_cert=args.tls_cert,
         tls_key=args.tls_key,
         tls_password=tls_key_password,
     )
+
+
+if __name__ == '__main__':
+    _main()
diff --git a/Lib/test/test_httpservers.py b/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', '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_handler = SimpleHTTPRequestHandler
+        self.default_server = http.server.CommandLineServerClass
+        self.tls_cert = '-----BEGIN CERTIFICATE-----\n' + '-----END CERTIFICATE-----\n'
+        self.tls_key = '-----BEGIN RSA PRIVATE KEY-----\n' + '-----END RSA PRIVATE KEY-----\n'
+
+        self.tls_password = '<PASSWORD>'
+        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, 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,
+                                                      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,
+                                                      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,
+                                                      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,
+                                          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,
+                                                  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,
+                                                      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())