diff options
Diffstat (limited to 'lib/python2.7/test/test_xmlrpc.py')
| -rw-r--r-- | lib/python2.7/test/test_xmlrpc.py | 1027 |
1 files changed, 0 insertions, 1027 deletions
diff --git a/lib/python2.7/test/test_xmlrpc.py b/lib/python2.7/test/test_xmlrpc.py deleted file mode 100644 index 8e65fde..0000000 --- a/lib/python2.7/test/test_xmlrpc.py +++ /dev/null @@ -1,1027 +0,0 @@ -import base64 -import datetime -import sys -import time -import unittest -import xmlrpclib -import SimpleXMLRPCServer -import mimetools -import httplib -import socket -import StringIO -import os -import re -from test import test_support - -try: - import threading -except ImportError: - threading = None - -try: - unicode -except NameError: - have_unicode = False -else: - have_unicode = True - -alist = [{'astring': 'foo@bar.baz.spam', - 'afloat': 7283.43, - 'anint': 2**20, - 'ashortlong': 2L, - 'anotherlist': ['.zyx.41'], - 'abase64': xmlrpclib.Binary("my dog has fleas"), - 'boolean': xmlrpclib.False, - 'unicode': u'\u4000\u6000\u8000', - u'ukey\u4000': 'regular value', - 'datetime1': xmlrpclib.DateTime('20050210T11:41:23'), - 'datetime2': xmlrpclib.DateTime( - (2005, 02, 10, 11, 41, 23, 0, 1, -1)), - 'datetime3': xmlrpclib.DateTime( - datetime.datetime(2005, 02, 10, 11, 41, 23)), - }] - -class XMLRPCTestCase(unittest.TestCase): - - def test_dump_load(self): - self.assertEqual(alist, - xmlrpclib.loads(xmlrpclib.dumps((alist,)))[0][0]) - - def test_dump_bare_datetime(self): - # This checks that an unwrapped datetime.date object can be handled - # by the marshalling code. This can't be done via test_dump_load() - # since with use_datetime set to 1 the unmarshaller would create - # datetime objects for the 'datetime[123]' keys as well - dt = datetime.datetime(2005, 02, 10, 11, 41, 23) - s = xmlrpclib.dumps((dt,)) - (newdt,), m = xmlrpclib.loads(s, use_datetime=1) - self.assertEqual(newdt, dt) - self.assertEqual(m, None) - - (newdt,), m = xmlrpclib.loads(s, use_datetime=0) - self.assertEqual(newdt, xmlrpclib.DateTime('20050210T11:41:23')) - - def test_datetime_before_1900(self): - # same as before but with a date before 1900 - dt = datetime.datetime(1, 02, 10, 11, 41, 23) - s = xmlrpclib.dumps((dt,)) - (newdt,), m = xmlrpclib.loads(s, use_datetime=1) - self.assertEqual(newdt, dt) - self.assertEqual(m, None) - - (newdt,), m = xmlrpclib.loads(s, use_datetime=0) - self.assertEqual(newdt, xmlrpclib.DateTime('00010210T11:41:23')) - - def test_cmp_datetime_DateTime(self): - now = datetime.datetime.now() - dt = xmlrpclib.DateTime(now.timetuple()) - self.assertTrue(dt == now) - self.assertTrue(now == dt) - then = now + datetime.timedelta(seconds=4) - self.assertTrue(then >= dt) - self.assertTrue(dt < then) - - def test_bug_1164912 (self): - d = xmlrpclib.DateTime() - ((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,), - methodresponse=True)) - self.assertIsInstance(new_d.value, str) - - # Check that the output of dumps() is still an 8-bit string - s = xmlrpclib.dumps((new_d,), methodresponse=True) - self.assertIsInstance(s, str) - - def test_newstyle_class(self): - class T(object): - pass - t = T() - t.x = 100 - t.y = "Hello" - ((t2,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((t,))) - self.assertEqual(t2, t.__dict__) - - def test_dump_big_long(self): - self.assertRaises(OverflowError, xmlrpclib.dumps, (2L**99,)) - - def test_dump_bad_dict(self): - self.assertRaises(TypeError, xmlrpclib.dumps, ({(1,2,3): 1},)) - - def test_dump_recursive_seq(self): - l = [1,2,3] - t = [3,4,5,l] - l.append(t) - self.assertRaises(TypeError, xmlrpclib.dumps, (l,)) - - def test_dump_recursive_dict(self): - d = {'1':1, '2':1} - t = {'3':3, 'd':d} - d['t'] = t - self.assertRaises(TypeError, xmlrpclib.dumps, (d,)) - - def test_dump_big_int(self): - if sys.maxint > 2L**31-1: - self.assertRaises(OverflowError, xmlrpclib.dumps, - (int(2L**34),)) - - xmlrpclib.dumps((xmlrpclib.MAXINT, xmlrpclib.MININT)) - self.assertRaises(OverflowError, xmlrpclib.dumps, (xmlrpclib.MAXINT+1,)) - self.assertRaises(OverflowError, xmlrpclib.dumps, (xmlrpclib.MININT-1,)) - - def dummy_write(s): - pass - - m = xmlrpclib.Marshaller() - m.dump_int(xmlrpclib.MAXINT, dummy_write) - m.dump_int(xmlrpclib.MININT, dummy_write) - self.assertRaises(OverflowError, m.dump_int, xmlrpclib.MAXINT+1, dummy_write) - self.assertRaises(OverflowError, m.dump_int, xmlrpclib.MININT-1, dummy_write) - - - def test_dump_none(self): - value = alist + [None] - arg1 = (alist + [None],) - strg = xmlrpclib.dumps(arg1, allow_none=True) - self.assertEqual(value, - xmlrpclib.loads(strg)[0][0]) - self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,)) - - def test_default_encoding_issues(self): - # SF bug #1115989: wrong decoding in '_stringify' - utf8 = """<?xml version='1.0' encoding='iso-8859-1'?> - <params> - <param><value> - <string>abc \x95</string> - </value></param> - <param><value> - <struct> - <member> - <name>def \x96</name> - <value><string>ghi \x97</string></value> - </member> - </struct> - </value></param> - </params> - """ - - # sys.setdefaultencoding() normally doesn't exist after site.py is - # loaded. Import a temporary fresh copy to get access to it - # but then restore the original copy to avoid messing with - # other potentially modified sys module attributes - old_encoding = sys.getdefaultencoding() - with test_support.CleanImport('sys'): - import sys as temp_sys - temp_sys.setdefaultencoding("iso-8859-1") - try: - (s, d), m = xmlrpclib.loads(utf8) - finally: - temp_sys.setdefaultencoding(old_encoding) - - items = d.items() - if have_unicode: - self.assertEqual(s, u"abc \x95") - self.assertIsInstance(s, unicode) - self.assertEqual(items, [(u"def \x96", u"ghi \x97")]) - self.assertIsInstance(items[0][0], unicode) - self.assertIsInstance(items[0][1], unicode) - else: - self.assertEqual(s, "abc \xc2\x95") - self.assertEqual(items, [("def \xc2\x96", "ghi \xc2\x97")]) - - -class HelperTestCase(unittest.TestCase): - def test_escape(self): - self.assertEqual(xmlrpclib.escape("a&b"), "a&b") - self.assertEqual(xmlrpclib.escape("a<b"), "a<b") - self.assertEqual(xmlrpclib.escape("a>b"), "a>b") - -class FaultTestCase(unittest.TestCase): - def test_repr(self): - f = xmlrpclib.Fault(42, 'Test Fault') - self.assertEqual(repr(f), "<Fault 42: 'Test Fault'>") - self.assertEqual(repr(f), str(f)) - - def test_dump_fault(self): - f = xmlrpclib.Fault(42, 'Test Fault') - s = xmlrpclib.dumps((f,)) - (newf,), m = xmlrpclib.loads(s) - self.assertEqual(newf, {'faultCode': 42, 'faultString': 'Test Fault'}) - self.assertEqual(m, None) - - s = xmlrpclib.Marshaller().dumps(f) - self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, s) - - -class DateTimeTestCase(unittest.TestCase): - def test_default(self): - t = xmlrpclib.DateTime() - - def test_time(self): - d = 1181399930.036952 - t = xmlrpclib.DateTime(d) - self.assertEqual(str(t), time.strftime("%Y%m%dT%H:%M:%S", time.localtime(d))) - - def test_time_tuple(self): - d = (2007,6,9,10,38,50,5,160,0) - t = xmlrpclib.DateTime(d) - self.assertEqual(str(t), '20070609T10:38:50') - - def test_time_struct(self): - d = time.localtime(1181399930.036952) - t = xmlrpclib.DateTime(d) - self.assertEqual(str(t), time.strftime("%Y%m%dT%H:%M:%S", d)) - - def test_datetime_datetime(self): - d = datetime.datetime(2007,1,2,3,4,5) - t = xmlrpclib.DateTime(d) - self.assertEqual(str(t), '20070102T03:04:05') - - def test_repr(self): - d = datetime.datetime(2007,1,2,3,4,5) - t = xmlrpclib.DateTime(d) - val ="<DateTime '20070102T03:04:05' at %x>" % id(t) - self.assertEqual(repr(t), val) - - def test_decode(self): - d = ' 20070908T07:11:13 ' - t1 = xmlrpclib.DateTime() - t1.decode(d) - tref = xmlrpclib.DateTime(datetime.datetime(2007,9,8,7,11,13)) - self.assertEqual(t1, tref) - - t2 = xmlrpclib._datetime(d) - self.assertEqual(t1, tref) - -class BinaryTestCase(unittest.TestCase): - def test_default(self): - t = xmlrpclib.Binary() - self.assertEqual(str(t), '') - - def test_string(self): - d = '\x01\x02\x03abc123\xff\xfe' - t = xmlrpclib.Binary(d) - self.assertEqual(str(t), d) - - def test_decode(self): - d = '\x01\x02\x03abc123\xff\xfe' - de = base64.encodestring(d) - t1 = xmlrpclib.Binary() - t1.decode(de) - self.assertEqual(str(t1), d) - - t2 = xmlrpclib._binary(de) - self.assertEqual(str(t2), d) - - -ADDR = PORT = URL = None - -# The evt is set twice. First when the server is ready to serve. -# Second when the server has been shutdown. The user must clear -# the event after it has been set the first time to catch the second set. -def http_server(evt, numrequests, requestHandler=None): - class TestInstanceClass: - def div(self, x, y): - return x // y - - def _methodHelp(self, name): - if name == 'div': - return 'This is the div function' - - def my_function(): - '''This is my function''' - return True - - class MyXMLRPCServer(SimpleXMLRPCServer.SimpleXMLRPCServer): - def get_request(self): - # Ensure the socket is always non-blocking. On Linux, socket - # attributes are not inherited like they are on *BSD and Windows. - s, port = self.socket.accept() - s.setblocking(True) - return s, port - - if not requestHandler: - requestHandler = SimpleXMLRPCServer.SimpleXMLRPCRequestHandler - serv = MyXMLRPCServer(("localhost", 0), requestHandler, - logRequests=False, bind_and_activate=False) - try: - serv.socket.settimeout(3) - serv.server_bind() - global ADDR, PORT, URL - ADDR, PORT = serv.socket.getsockname() - #connect to IP address directly. This avoids socket.create_connection() - #trying to connect to "localhost" using all address families, which - #causes slowdown e.g. on vista which supports AF_INET6. The server listens - #on AF_INET only. - URL = "http://%s:%d"%(ADDR, PORT) - serv.server_activate() - serv.register_introspection_functions() - serv.register_multicall_functions() - serv.register_function(pow) - serv.register_function(lambda x,y: x+y, 'add') - serv.register_function(my_function) - serv.register_instance(TestInstanceClass()) - evt.set() - - # handle up to 'numrequests' requests - while numrequests > 0: - serv.handle_request() - numrequests -= 1 - - except socket.timeout: - pass - finally: - serv.socket.close() - PORT = None - evt.set() - -def http_multi_server(evt, numrequests, requestHandler=None): - class TestInstanceClass: - def div(self, x, y): - return x // y - - def _methodHelp(self, name): - if name == 'div': - return 'This is the div function' - - def my_function(): - '''This is my function''' - return True - - class MyXMLRPCServer(SimpleXMLRPCServer.MultiPathXMLRPCServer): - def get_request(self): - # Ensure the socket is always non-blocking. On Linux, socket - # attributes are not inherited like they are on *BSD and Windows. - s, port = self.socket.accept() - s.setblocking(True) - return s, port - - if not requestHandler: - requestHandler = SimpleXMLRPCServer.SimpleXMLRPCRequestHandler - class MyRequestHandler(requestHandler): - rpc_paths = [] - - serv = MyXMLRPCServer(("localhost", 0), MyRequestHandler, - logRequests=False, bind_and_activate=False) - serv.socket.settimeout(3) - serv.server_bind() - try: - global ADDR, PORT, URL - ADDR, PORT = serv.socket.getsockname() - #connect to IP address directly. This avoids socket.create_connection() - #trying to connect to "localhost" using all address families, which - #causes slowdown e.g. on vista which supports AF_INET6. The server listens - #on AF_INET only. - URL = "http://%s:%d"%(ADDR, PORT) - serv.server_activate() - paths = ["/foo", "/foo/bar"] - for path in paths: - d = serv.add_dispatcher(path, SimpleXMLRPCServer.SimpleXMLRPCDispatcher()) - d.register_introspection_functions() - d.register_multicall_functions() - serv.get_dispatcher(paths[0]).register_function(pow) - serv.get_dispatcher(paths[1]).register_function(lambda x,y: x+y, 'add') - evt.set() - - # handle up to 'numrequests' requests - while numrequests > 0: - serv.handle_request() - numrequests -= 1 - - except socket.timeout: - pass - finally: - serv.socket.close() - PORT = None - evt.set() - -# This function prevents errors like: -# <ProtocolError for localhost:57527/RPC2: 500 Internal Server Error> -def is_unavailable_exception(e): - '''Returns True if the given ProtocolError is the product of a server-side - exception caused by the 'temporarily unavailable' response sometimes - given by operations on non-blocking sockets.''' - - # sometimes we get a -1 error code and/or empty headers - try: - if e.errcode == -1 or e.headers is None: - return True - exc_mess = e.headers.get('X-exception') - except AttributeError: - # Ignore socket.errors here. - exc_mess = str(e) - - if exc_mess and 'temporarily unavailable' in exc_mess.lower(): - return True - - return False - -@unittest.skipUnless(threading, 'Threading required for this test.') -class BaseServerTestCase(unittest.TestCase): - requestHandler = None - request_count = 1 - threadFunc = staticmethod(http_server) - - def setUp(self): - # enable traceback reporting - SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = True - - self.evt = threading.Event() - # start server thread to handle requests - serv_args = (self.evt, self.request_count, self.requestHandler) - threading.Thread(target=self.threadFunc, args=serv_args).start() - - # wait for the server to be ready - self.evt.wait(10) - self.evt.clear() - - def tearDown(self): - # wait on the server thread to terminate - self.evt.wait(10) - - # disable traceback reporting - SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = False - -# NOTE: The tests in SimpleServerTestCase will ignore failures caused by -# "temporarily unavailable" exceptions raised in SimpleXMLRPCServer. This -# condition occurs infrequently on some platforms, frequently on others, and -# is apparently caused by using SimpleXMLRPCServer with a non-blocking socket -# If the server class is updated at some point in the future to handle this -# situation more gracefully, these tests should be modified appropriately. - -class SimpleServerTestCase(BaseServerTestCase): - def test_simple1(self): - try: - p = xmlrpclib.ServerProxy(URL) - self.assertEqual(p.pow(6,8), 6**8) - except (xmlrpclib.ProtocolError, socket.error), e: - # ignore failures due to non-blocking socket 'unavailable' errors - if not is_unavailable_exception(e): - # protocol error; provide additional information in test output - self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) - - def test_nonascii(self): - start_string = 'P\N{LATIN SMALL LETTER Y WITH CIRCUMFLEX}t' - end_string = 'h\N{LATIN SMALL LETTER O WITH HORN}n' - - try: - p = xmlrpclib.ServerProxy(URL) - self.assertEqual(p.add(start_string, end_string), - start_string + end_string) - except (xmlrpclib.ProtocolError, socket.error) as e: - # ignore failures due to non-blocking socket unavailable errors. - if not is_unavailable_exception(e): - # protocol error; provide additional information in test output - self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) - - def test_unicode_host(self): - server = xmlrpclib.ServerProxy(u"http://%s:%d/RPC2"%(ADDR, PORT)) - self.assertEqual(server.add("a", u"\xe9"), u"a\xe9") - - # [ch] The test 404 is causing lots of false alarms. - def XXXtest_404(self): - # send POST with httplib, it should return 404 header and - # 'Not Found' message. - conn = httplib.HTTPConnection(ADDR, PORT) - conn.request('POST', '/this-is-not-valid') - response = conn.getresponse() - conn.close() - - self.assertEqual(response.status, 404) - self.assertEqual(response.reason, 'Not Found') - - def test_introspection1(self): - try: - p = xmlrpclib.ServerProxy(URL) - meth = p.system.listMethods() - expected_methods = set(['pow', 'div', 'my_function', 'add', - 'system.listMethods', 'system.methodHelp', - 'system.methodSignature', 'system.multicall']) - self.assertEqual(set(meth), expected_methods) - except (xmlrpclib.ProtocolError, socket.error), e: - # ignore failures due to non-blocking socket 'unavailable' errors - if not is_unavailable_exception(e): - # protocol error; provide additional information in test output - self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) - - def test_introspection2(self): - try: - # test _methodHelp() - p = xmlrpclib.ServerProxy(URL) - divhelp = p.system.methodHelp('div') - self.assertEqual(divhelp, 'This is the div function') - except (xmlrpclib.ProtocolError, socket.error), e: - # ignore failures due to non-blocking socket 'unavailable' errors - if not is_unavailable_exception(e): - # protocol error; provide additional information in test output - self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) - - @unittest.skipIf(sys.flags.optimize >= 2, - "Docstrings are omitted with -O2 and above") - def test_introspection3(self): - try: - # test native doc - p = xmlrpclib.ServerProxy(URL) - myfunction = p.system.methodHelp('my_function') - self.assertEqual(myfunction, 'This is my function') - except (xmlrpclib.ProtocolError, socket.error), e: - # ignore failures due to non-blocking socket 'unavailable' errors - if not is_unavailable_exception(e): - # protocol error; provide additional information in test output - self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) - - def test_introspection4(self): - # the SimpleXMLRPCServer doesn't support signatures, but - # at least check that we can try making the call - try: - p = xmlrpclib.ServerProxy(URL) - divsig = p.system.methodSignature('div') - self.assertEqual(divsig, 'signatures not supported') - except (xmlrpclib.ProtocolError, socket.error), e: - # ignore failures due to non-blocking socket 'unavailable' errors - if not is_unavailable_exception(e): - # protocol error; provide additional information in test output - self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) - - def test_multicall(self): - try: - p = xmlrpclib.ServerProxy(URL) - multicall = xmlrpclib.MultiCall(p) - multicall.add(2,3) - multicall.pow(6,8) - multicall.div(127,42) - add_result, pow_result, div_result = multicall() - self.assertEqual(add_result, 2+3) - self.assertEqual(pow_result, 6**8) - self.assertEqual(div_result, 127//42) - except (xmlrpclib.ProtocolError, socket.error), e: - # ignore failures due to non-blocking socket 'unavailable' errors - if not is_unavailable_exception(e): - # protocol error; provide additional information in test output - self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) - - def test_non_existing_multicall(self): - try: - p = xmlrpclib.ServerProxy(URL) - multicall = xmlrpclib.MultiCall(p) - multicall.this_is_not_exists() - result = multicall() - - # result.results contains; - # [{'faultCode': 1, 'faultString': '<type \'exceptions.Exception\'>:' - # 'method "this_is_not_exists" is not supported'>}] - - self.assertEqual(result.results[0]['faultCode'], 1) - self.assertEqual(result.results[0]['faultString'], - '<type \'exceptions.Exception\'>:method "this_is_not_exists" ' - 'is not supported') - except (xmlrpclib.ProtocolError, socket.error), e: - # ignore failures due to non-blocking socket 'unavailable' errors - if not is_unavailable_exception(e): - # protocol error; provide additional information in test output - self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) - - def test_dotted_attribute(self): - # Raises an AttributeError because private methods are not allowed. - self.assertRaises(AttributeError, - SimpleXMLRPCServer.resolve_dotted_attribute, str, '__add') - - self.assertTrue(SimpleXMLRPCServer.resolve_dotted_attribute(str, 'title')) - # Get the test to run faster by sending a request with test_simple1. - # This avoids waiting for the socket timeout. - self.test_simple1() - - def test_partial_post(self): - # Check that a partial POST doesn't make the server loop: issue #14001. - conn = httplib.HTTPConnection(ADDR, PORT) - conn.request('POST', '/RPC2 HTTP/1.0\r\nContent-Length: 100\r\n\r\nbye') - conn.close() - -class MultiPathServerTestCase(BaseServerTestCase): - threadFunc = staticmethod(http_multi_server) - request_count = 2 - def test_path1(self): - p = xmlrpclib.ServerProxy(URL+"/foo") - self.assertEqual(p.pow(6,8), 6**8) - self.assertRaises(xmlrpclib.Fault, p.add, 6, 8) - def test_path2(self): - p = xmlrpclib.ServerProxy(URL+"/foo/bar") - self.assertEqual(p.add(6,8), 6+8) - self.assertRaises(xmlrpclib.Fault, p.pow, 6, 8) - -#A test case that verifies that a server using the HTTP/1.1 keep-alive mechanism -#does indeed serve subsequent requests on the same connection -class BaseKeepaliveServerTestCase(BaseServerTestCase): - #a request handler that supports keep-alive and logs requests into a - #class variable - class RequestHandler(SimpleXMLRPCServer.SimpleXMLRPCRequestHandler): - parentClass = SimpleXMLRPCServer.SimpleXMLRPCRequestHandler - protocol_version = 'HTTP/1.1' - myRequests = [] - def handle(self): - self.myRequests.append([]) - self.reqidx = len(self.myRequests)-1 - return self.parentClass.handle(self) - def handle_one_request(self): - result = self.parentClass.handle_one_request(self) - self.myRequests[self.reqidx].append(self.raw_requestline) - return result - - requestHandler = RequestHandler - def setUp(self): - #clear request log - self.RequestHandler.myRequests = [] - return BaseServerTestCase.setUp(self) - -#A test case that verifies that a server using the HTTP/1.1 keep-alive mechanism -#does indeed serve subsequent requests on the same connection -class KeepaliveServerTestCase1(BaseKeepaliveServerTestCase): - def test_two(self): - p = xmlrpclib.ServerProxy(URL) - #do three requests. - self.assertEqual(p.pow(6,8), 6**8) - self.assertEqual(p.pow(6,8), 6**8) - self.assertEqual(p.pow(6,8), 6**8) - - #they should have all been handled by a single request handler - self.assertEqual(len(self.RequestHandler.myRequests), 1) - - #check that we did at least two (the third may be pending append - #due to thread scheduling) - self.assertGreaterEqual(len(self.RequestHandler.myRequests[-1]), 2) - -#test special attribute access on the serverproxy, through the __call__ -#function. -class KeepaliveServerTestCase2(BaseKeepaliveServerTestCase): - #ask for two keepalive requests to be handled. - request_count=2 - - def test_close(self): - p = xmlrpclib.ServerProxy(URL) - #do some requests with close. - self.assertEqual(p.pow(6,8), 6**8) - self.assertEqual(p.pow(6,8), 6**8) - self.assertEqual(p.pow(6,8), 6**8) - p("close")() #this should trigger a new keep-alive request - self.assertEqual(p.pow(6,8), 6**8) - self.assertEqual(p.pow(6,8), 6**8) - self.assertEqual(p.pow(6,8), 6**8) - - #they should have all been two request handlers, each having logged at least - #two complete requests - self.assertEqual(len(self.RequestHandler.myRequests), 2) - self.assertGreaterEqual(len(self.RequestHandler.myRequests[-1]), 2) - self.assertGreaterEqual(len(self.RequestHandler.myRequests[-2]), 2) - - def test_transport(self): - p = xmlrpclib.ServerProxy(URL) - #do some requests with close. - self.assertEqual(p.pow(6,8), 6**8) - p("transport").close() #same as above, really. - self.assertEqual(p.pow(6,8), 6**8) - self.assertEqual(len(self.RequestHandler.myRequests), 2) - -#A test case that verifies that gzip encoding works in both directions -#(for a request and the response) -class GzipServerTestCase(BaseServerTestCase): - #a request handler that supports keep-alive and logs requests into a - #class variable - class RequestHandler(SimpleXMLRPCServer.SimpleXMLRPCRequestHandler): - parentClass = SimpleXMLRPCServer.SimpleXMLRPCRequestHandler - protocol_version = 'HTTP/1.1' - - def do_POST(self): - #store content of last request in class - self.__class__.content_length = int(self.headers["content-length"]) - return self.parentClass.do_POST(self) - requestHandler = RequestHandler - - class Transport(xmlrpclib.Transport): - #custom transport, stores the response length for our perusal - fake_gzip = False - def parse_response(self, response): - self.response_length=int(response.getheader("content-length", 0)) - return xmlrpclib.Transport.parse_response(self, response) - - def send_content(self, connection, body): - if self.fake_gzip: - #add a lone gzip header to induce decode error remotely - connection.putheader("Content-Encoding", "gzip") - return xmlrpclib.Transport.send_content(self, connection, body) - - def setUp(self): - BaseServerTestCase.setUp(self) - - def test_gzip_request(self): - t = self.Transport() - t.encode_threshold = None - p = xmlrpclib.ServerProxy(URL, transport=t) - self.assertEqual(p.pow(6,8), 6**8) - a = self.RequestHandler.content_length - t.encode_threshold = 0 #turn on request encoding - self.assertEqual(p.pow(6,8), 6**8) - b = self.RequestHandler.content_length - self.assertTrue(a>b) - - def test_bad_gzip_request(self): - t = self.Transport() - t.encode_threshold = None - t.fake_gzip = True - p = xmlrpclib.ServerProxy(URL, transport=t) - cm = self.assertRaisesRegexp(xmlrpclib.ProtocolError, - re.compile(r"\b400\b")) - with cm: - p.pow(6, 8) - - def test_gsip_response(self): - t = self.Transport() - p = xmlrpclib.ServerProxy(URL, transport=t) - old = self.requestHandler.encode_threshold - self.requestHandler.encode_threshold = None #no encoding - self.assertEqual(p.pow(6,8), 6**8) - a = t.response_length - self.requestHandler.encode_threshold = 0 #always encode - self.assertEqual(p.pow(6,8), 6**8) - b = t.response_length - self.requestHandler.encode_threshold = old - self.assertTrue(a>b) - -#Test special attributes of the ServerProxy object -class ServerProxyTestCase(unittest.TestCase): - def setUp(self): - unittest.TestCase.setUp(self) - if threading: - self.url = URL - else: - # Without threading, http_server() and http_multi_server() will not - # be executed and URL is still equal to None. 'http://' is a just - # enough to choose the scheme (HTTP) - self.url = 'http://' - - def test_close(self): - p = xmlrpclib.ServerProxy(self.url) - self.assertEqual(p('close')(), None) - - def test_transport(self): - t = xmlrpclib.Transport() - p = xmlrpclib.ServerProxy(self.url, transport=t) - self.assertEqual(p('transport'), t) - -# This is a contrived way to make a failure occur on the server side -# in order to test the _send_traceback_header flag on the server -class FailingMessageClass(mimetools.Message): - def __getitem__(self, key): - key = key.lower() - if key == 'content-length': - return 'I am broken' - return mimetools.Message.__getitem__(self, key) - - -@unittest.skipUnless(threading, 'Threading required for this test.') -class FailingServerTestCase(unittest.TestCase): - def setUp(self): - self.evt = threading.Event() - # start server thread to handle requests - serv_args = (self.evt, 1) - threading.Thread(target=http_server, args=serv_args).start() - - # wait for the server to be ready - self.evt.wait() - self.evt.clear() - - def tearDown(self): - # wait on the server thread to terminate - self.evt.wait() - # reset flag - SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = False - # reset message class - SimpleXMLRPCServer.SimpleXMLRPCRequestHandler.MessageClass = mimetools.Message - - def test_basic(self): - # check that flag is false by default - flagval = SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header - self.assertEqual(flagval, False) - - # enable traceback reporting - SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = True - - # test a call that shouldn't fail just as a smoke test - try: - p = xmlrpclib.ServerProxy(URL) - self.assertEqual(p.pow(6,8), 6**8) - except (xmlrpclib.ProtocolError, socket.error), e: - # ignore failures due to non-blocking socket 'unavailable' errors - if not is_unavailable_exception(e): - # protocol error; provide additional information in test output - self.fail("%s\n%s" % (e, getattr(e, "headers", ""))) - - def test_fail_no_info(self): - # use the broken message class - SimpleXMLRPCServer.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass - - try: - p = xmlrpclib.ServerProxy(URL) - p.pow(6,8) - except (xmlrpclib.ProtocolError, socket.error), e: - # ignore failures due to non-blocking socket 'unavailable' errors - if not is_unavailable_exception(e) and hasattr(e, "headers"): - # The two server-side error headers shouldn't be sent back in this case - self.assertTrue(e.headers.get("X-exception") is None) - self.assertTrue(e.headers.get("X-traceback") is None) - else: - self.fail('ProtocolError not raised') - - def test_fail_with_info(self): - # use the broken message class - SimpleXMLRPCServer.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass - - # Check that errors in the server send back exception/traceback - # info when flag is set - SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = True - - try: - p = xmlrpclib.ServerProxy(URL) - p.pow(6,8) - except (xmlrpclib.ProtocolError, socket.error), e: - # ignore failures due to non-blocking socket 'unavailable' errors - if not is_unavailable_exception(e) and hasattr(e, "headers"): - # We should get error info in the response - expected_err = "invalid literal for int() with base 10: 'I am broken'" - self.assertEqual(e.headers.get("x-exception"), expected_err) - self.assertTrue(e.headers.get("x-traceback") is not None) - else: - self.fail('ProtocolError not raised') - -class CGIHandlerTestCase(unittest.TestCase): - def setUp(self): - self.cgi = SimpleXMLRPCServer.CGIXMLRPCRequestHandler() - - def tearDown(self): - self.cgi = None - - def test_cgi_get(self): - with test_support.EnvironmentVarGuard() as env: - env['REQUEST_METHOD'] = 'GET' - # if the method is GET and no request_text is given, it runs handle_get - # get sysout output - with test_support.captured_stdout() as data_out: - self.cgi.handle_request() - - # parse Status header - data_out.seek(0) - handle = data_out.read() - status = handle.split()[1] - message = ' '.join(handle.split()[2:4]) - - self.assertEqual(status, '400') - self.assertEqual(message, 'Bad Request') - - - def test_cgi_xmlrpc_response(self): - data = """<?xml version='1.0'?> - <methodCall> - <methodName>test_method</methodName> - <params> - <param> - <value><string>foo</string></value> - </param> - <param> - <value><string>bar</string></value> - </param> - </params> - </methodCall> - """ - - with test_support.EnvironmentVarGuard() as env, \ - test_support.captured_stdout() as data_out, \ - test_support.captured_stdin() as data_in: - data_in.write(data) - data_in.seek(0) - env['CONTENT_LENGTH'] = str(len(data)) - self.cgi.handle_request() - data_out.seek(0) - - # will respond exception, if so, our goal is achieved ;) - handle = data_out.read() - - # start with 44th char so as not to get http header, we just need only xml - self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, handle[44:]) - - # Also test the content-length returned by handle_request - # Using the same test method inorder to avoid all the datapassing - # boilerplate code. - # Test for bug: http://bugs.python.org/issue5040 - - content = handle[handle.find("<?xml"):] - - self.assertEqual( - int(re.search('Content-Length: (\d+)', handle).group(1)), - len(content)) - - -class FakeSocket: - - def __init__(self): - self.data = StringIO.StringIO() - - def send(self, buf): - self.data.write(buf) - return len(buf) - - def sendall(self, buf): - self.data.write(buf) - - def getvalue(self): - return self.data.getvalue() - - def makefile(self, x='r', y=-1): - raise RuntimeError - - def close(self): - pass - -class FakeTransport(xmlrpclib.Transport): - """A Transport instance that records instead of sending a request. - - This class replaces the actual socket used by httplib with a - FakeSocket object that records the request. It doesn't provide a - response. - """ - - def make_connection(self, host): - conn = xmlrpclib.Transport.make_connection(self, host) - conn.sock = self.fake_socket = FakeSocket() - return conn - -class TransportSubclassTestCase(unittest.TestCase): - - def issue_request(self, transport_class): - """Return an HTTP request made via transport_class.""" - transport = transport_class() - proxy = xmlrpclib.ServerProxy("http://example.com/", - transport=transport) - try: - proxy.pow(6, 8) - except RuntimeError: - return transport.fake_socket.getvalue() - return None - - def test_custom_user_agent(self): - class TestTransport(FakeTransport): - - def send_user_agent(self, conn): - xmlrpclib.Transport.send_user_agent(self, conn) - conn.putheader("X-Test", "test_custom_user_agent") - - req = self.issue_request(TestTransport) - self.assertIn("X-Test: test_custom_user_agent\r\n", req) - - def test_send_host(self): - class TestTransport(FakeTransport): - - def send_host(self, conn, host): - xmlrpclib.Transport.send_host(self, conn, host) - conn.putheader("X-Test", "test_send_host") - - req = self.issue_request(TestTransport) - self.assertIn("X-Test: test_send_host\r\n", req) - - def test_send_request(self): - class TestTransport(FakeTransport): - - def send_request(self, conn, url, body): - xmlrpclib.Transport.send_request(self, conn, url, body) - conn.putheader("X-Test", "test_send_request") - - req = self.issue_request(TestTransport) - self.assertIn("X-Test: test_send_request\r\n", req) - - def test_send_content(self): - class TestTransport(FakeTransport): - - def send_content(self, conn, body): - conn.putheader("X-Test", "test_send_content") - xmlrpclib.Transport.send_content(self, conn, body) - - req = self.issue_request(TestTransport) - self.assertIn("X-Test: test_send_content\r\n", req) - -@test_support.reap_threads -def test_main(): - xmlrpc_tests = [XMLRPCTestCase, HelperTestCase, DateTimeTestCase, - BinaryTestCase, FaultTestCase, TransportSubclassTestCase] - xmlrpc_tests.append(SimpleServerTestCase) - xmlrpc_tests.append(KeepaliveServerTestCase1) - xmlrpc_tests.append(KeepaliveServerTestCase2) - try: - import gzip - xmlrpc_tests.append(GzipServerTestCase) - except ImportError: - pass #gzip not supported in this build - xmlrpc_tests.append(MultiPathServerTestCase) - xmlrpc_tests.append(ServerProxyTestCase) - xmlrpc_tests.append(FailingServerTestCase) - xmlrpc_tests.append(CGIHandlerTestCase) - - test_support.run_unittest(*xmlrpc_tests) - -if __name__ == "__main__": - test_main() |