From b47eccbff0b4580b09bfbde3e27b0cffcb00a1c0 Mon Sep 17 00:00:00 2001 From: Andrey Maltsev Date: Sun, 2 Apr 2023 13:51:18 +0000 Subject: [PATCH] Update test_docxmlrpc.py from Cpython v3.11.2 --- Lib/test/test_docxmlrpc.py | 232 +++++++++++++++++++++++++++++++++++++ 1 file changed, 232 insertions(+) create mode 100644 Lib/test/test_docxmlrpc.py diff --git a/Lib/test/test_docxmlrpc.py b/Lib/test/test_docxmlrpc.py new file mode 100644 index 0000000000..99469a5849 --- /dev/null +++ b/Lib/test/test_docxmlrpc.py @@ -0,0 +1,232 @@ +from xmlrpc.server import DocXMLRPCServer +import http.client +import re +import sys +import threading +import unittest +from test import support + +support.requires_working_socket(module=True) + +def make_request_and_skipIf(condition, reason): + # If we skip the test, we have to make a request because + # the server created in setUp blocks expecting one to come in. + if not condition: + return lambda func: func + def decorator(func): + def make_request_and_skip(self): + self.client.request("GET", "/") + self.client.getresponse() + raise unittest.SkipTest(reason) + return make_request_and_skip + return decorator + + +def make_server(): + serv = DocXMLRPCServer(("localhost", 0), logRequests=False) + + try: + # Add some documentation + serv.set_server_title("DocXMLRPCServer Test Documentation") + serv.set_server_name("DocXMLRPCServer Test Docs") + serv.set_server_documentation( + "This is an XML-RPC server's documentation, but the server " + "can be used by POSTing to /RPC2. Try self.add, too.") + + # Create and register classes and functions + class TestClass(object): + def test_method(self, arg): + """Test method's docs. This method truly does very little.""" + self.arg = arg + + serv.register_introspection_functions() + serv.register_instance(TestClass()) + + def add(x, y): + """Add two instances together. This follows PEP008, but has nothing + to do with RFC1952. Case should matter: pEp008 and rFC1952. Things + that start with http and ftp should be auto-linked, too: + http://google.com. + """ + return x + y + + def annotation(x: int): + """ Use function annotations. """ + return x + + class ClassWithAnnotation: + def method_annotation(self, x: bytes): + return x.decode() + + serv.register_function(add) + serv.register_function(lambda x, y: x-y) + serv.register_function(annotation) + serv.register_instance(ClassWithAnnotation()) + return serv + except: + serv.server_close() + raise + +class DocXMLRPCHTTPGETServer(unittest.TestCase): + def setUp(self): + # Enable server feedback + DocXMLRPCServer._send_traceback_header = True + + self.serv = make_server() + self.thread = threading.Thread(target=self.serv.serve_forever) + self.thread.start() + + PORT = self.serv.server_address[1] + self.client = http.client.HTTPConnection("localhost:%d" % PORT) + + def tearDown(self): + self.client.close() + + # Disable server feedback + DocXMLRPCServer._send_traceback_header = False + self.serv.shutdown() + self.thread.join() + self.serv.server_close() + + # TODO: RUSTPYTHON + @unittest.expectedFailure + def test_valid_get_response(self): + self.client.request("GET", "/") + response = self.client.getresponse() + + self.assertEqual(response.status, 200) + self.assertEqual(response.getheader("Content-type"), "text/html; charset=UTF-8") + + # Server raises an exception if we don't start to read the data + response.read() + + # TODO: RUSTPYTHON + @unittest.expectedFailure + def test_get_css(self): + self.client.request("GET", "/pydoc.css") + response = self.client.getresponse() + + self.assertEqual(response.status, 200) + self.assertEqual(response.getheader("Content-type"), "text/css; charset=UTF-8") + + # Server raises an exception if we don't start to read the data + response.read() + + def test_invalid_get_response(self): + self.client.request("GET", "/spam") + response = self.client.getresponse() + + self.assertEqual(response.status, 404) + self.assertEqual(response.getheader("Content-type"), "text/plain") + + response.read() + + def test_lambda(self): + """Test that lambda functionality stays the same. The output produced + currently is, I suspect invalid because of the unencoded brackets in the + HTML, "". + + The subtraction lambda method is tested. + """ + self.client.request("GET", "/") + response = self.client.getresponse() + + self.assertIn((b'
' + b'<lambda>(x, y)
'), + response.read()) + + # TODO: RUSTPYTHON + @unittest.expectedFailure + @make_request_and_skipIf(sys.flags.optimize >= 2, + "Docstrings are omitted with -O2 and above") + def test_autolinking(self): + """Test that the server correctly automatically wraps references to + PEPS and RFCs with links, and that it linkifies text starting with + http or ftp protocol prefixes. + + The documentation for the "add" method contains the test material. + """ + self.client.request("GET", "/") + response = self.client.getresponse().read() + + self.assertIn( + (b'
add(x, y)
' + b'Add two instances together. This ' + b'follows ' + b'PEP008, but has nothing
\nto do ' + b'with ' + b'RFC1952. Case should matter: pEp008 ' + b'and rFC1952.  Things
\nthat start ' + b'with http and ftp should be ' + b'auto-linked, too:
\n' + b'http://google.com.
'), response) + + @make_request_and_skipIf(sys.flags.optimize >= 2, + "Docstrings are omitted with -O2 and above") + def test_system_methods(self): + """Test the presence of three consecutive system.* methods. + + This also tests their use of parameter type recognition and the + systems related to that process. + """ + self.client.request("GET", "/") + response = self.client.getresponse().read() + + self.assertIn( + (b'
system.methodHelp' + b'(method_name)
system.methodHelp(\'add\') => "Adds ' + b'two integers together"
\n 
\nReturns a' + b' string containing documentation for ' + b'the specified method.
\n
system.methodSignature' + b'(method_name)
' + b'system.methodSignature(\'add\') => [double, ' + b'int, int]
\n 
\nReturns a list ' + b'describing the signature of the method.' + b' In the
\nabove example, the add ' + b'method takes two integers as arguments' + b'
\nand returns a double result.
\n ' + b'
\nThis server does NOT support system' + b'.methodSignature.
'), response) + + def test_autolink_dotted_methods(self): + """Test that selfdot values are made strong automatically in the + documentation.""" + self.client.request("GET", "/") + response = self.client.getresponse() + + self.assertIn(b"""Try self.add, too.""", + response.read()) + + def test_annotations(self): + """ Test that annotations works as expected """ + self.client.request("GET", "/") + response = self.client.getresponse() + docstring = (b'' if sys.flags.optimize >= 2 else + b'
Use function annotations.
') + self.assertIn( + (b'
annotation' + b'(x: int)
' + docstring + b'
\n' + b'
' + b'method_annotation(x: bytes)
'), + response.read()) + + def test_server_title_escape(self): + # bpo-38243: Ensure that the server title and documentation + # are escaped for HTML. + self.serv.set_server_title('test_title