May 19, 2025 · Apr 14, 2025 · Apr 15, 2025 · Apr 15, 2025 · Apr 15, 2025 · Apr 15, 2025
diff --git a/Lib/http/server.py b/Lib/http/server.py
 import sys
 import time
 import urllib.parse
 import argparse
 import contextlib

 from http import HTTPStatus

 class ThreadingHTTPServer(socketserver.ThreadingMixIn, HTTPServer):
    daemon_threads = True


 class HTTPSServer(HTTPServer):
    def __init__(self, server_address, RequestHandlerClass,
                 bind_and_activate=True, *, certfile, keyfile=None,

 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.

    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)

            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')
    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")
    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()
diff --git a/Lib/test/test_httpservers.py b/Lib/test/test_httpservers.py
     SimpleHTTPRequestHandler, CGIHTTPRequestHandler
 from http import server, HTTPStatus

 import http.server
 import os
 import socket
 import sys
 import threading
 from unittest import mock
 from io import BytesIO, StringIO
 import textwrap
 import contextlib

 import unittest
 from test import support
 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
            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())
diff --git a/Misc/NEWS.d/next/Library/2025-04-15-12-47-09.gh-issue-131178.Td8j5x.rst b/Misc/NEWS.d/next/Library/2025-04-15-12-47-09.gh-issue-131178.Td8j5x.rst
 Add tests for the command line interface of the ``http.server`` module.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -106,6 +106,8 @@
		import sys
		import time
		import urllib.parse
		import argparse
		import contextlib
ggqlq marked this conversation as resolved. Show resolvedHide resolved

		from http import HTTPStatus

Expand DownExpand Up		@@ -150,7 +152,6 @@ def server_bind(self):
		class ThreadingHTTPServer(socketserver.ThreadingMixIn, HTTPServer):
		daemon_threads = True

ggqlq marked this conversation as resolved. Show resolvedHide resolved

		class HTTPSServer(HTTPServer):
		def __init__(self, server_address, RequestHandlerClass,
		bind_and_activate=True, *, certfile, keyfile=None,
Expand DownExpand Up		@@ -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,
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		tls_cert=None, tls_key=None, tls_password=None):
		"""Test the HTTP request handler class.

Expand All		@@ -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)
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		else:
		server = ServerClass(addr, HandlerClass)

Expand All		@@ -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):
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		parser = argparse.ArgumentParser()
		parser.add_argument('--cgi', action='store_true',
		help='run as CGI server')
Expand All		@@ -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)
ggqlq marked this conversation as resolved. Show resolvedHide resolved

		if not args.tls_cert and args.tls_key:
		parser.error("--tls-key requires --tls-cert to be set")
Expand All		@@ -1383,27 +1399,18 @@ def test(HandlerClass=BaseHTTPRequestHandler,
		else:
		handler_class = SimpleHTTPRequestHandler

ggqlq marked this conversation as resolved. Show resolvedHide resolved
		# 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,
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		tls_cert=args.tls_cert,
		tls_key=args.tls_key,
		tls_password=tls_key_password,
		)


		if __name__ == '__main__':
		_main()
Original file line number	Diff line number	Diff line change
Expand Up		@@ -8,6 +8,7 @@
		SimpleHTTPRequestHandler, CGIHTTPRequestHandler
		from http import server, HTTPStatus

		import http.server
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		import os
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		import socket
		import sys
Expand All		@@ -27,6 +28,8 @@
		import threading
		from unittest import mock
		from io import BytesIO, StringIO
		import textwrap
		import contextlib
ggqlq marked this conversation as resolved. Show resolvedHide resolved

		import unittest
		from test import support
Expand DownExpand Up		@@ -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'}
ggqlq marked this conversation as resolved. Show resolvedHide resolved ggqlq marked this conversation as resolved. Show resolvedHide resolved
		for name in dir(server):
		if name.startswith('_') or name in denylist:
		continue
Expand DownExpand Up		@@ -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):
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		def setUp(self):
		self.default_port = 8000
		self.default_bind = None
		self.default_protocol = 'HTTP/1.0'
		self.default_directory = os.getcwd()
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		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()
ggqlq marked this conversation as resolved. Show resolvedHide resolved

		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()
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		with contextlib.redirect_stdout(output):
		server._main(args)
		return self.text_normalizer(output.getvalue())
ggqlq marked this conversation as resolved. Show resolvedHide resolved

ggqlq marked this conversation as resolved. Show resolvedHide resolved
		@mock.patch('http.server.test')
		def test_port_flag(self, mock_func):
		ports = [8000, 65535,]
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		for port in ports:
		with self.subTest(port=port):
		self.invoke_httpd([str(port)])
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		mock_func.assert_called_once_with(HandlerClass=self.default_handler, ServerClass=self.default_server,
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		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',]
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		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):
ggqlq marked this conversation as resolved. Show resolvedHide resolved
		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):
ggqlq marked this conversation as resolved. Show resolvedHide resolved ggqlq marked this conversation as resolved. Show resolvedHide resolved
		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)
ggqlq marked this conversation as resolved. Show resolvedHide resolved

		def test_unknown_flag(self):
		with self.assertRaises(SystemExit):
		self.invoke_httpd(['--unknown-flag'])

		def setUpModule():
		unittest.addModuleCleanup(os.chdir, os.getcwd())
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		Add tests for the command line interface of the ``http.server`` module.
ggqlq marked this conversation as resolved. Show resolvedHide resolved