[Jython-checkins] jython: from:
frank.wierzbicki
jython-checkins at python.org
Tue Mar 20 06:18:19 CET 2012
http://hg.python.org/jython/rev/e833ccc5b68d
changeset: 6428:e833ccc5b68d
user: Frank Wierzbicki <fwierzbicki at gmail.com>
date: Mon Mar 19 22:13:18 2012 -0700
summary:
from:
http://hg.python.org/cpython/Lib/test/test_xmlrpc.py@75832
files:
Lib/test/test_xmlrpc.py | 1027 +++++++++++++++++++++++++++
1 files changed, 1027 insertions(+), 0 deletions(-)
diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py
new file mode 100644
--- /dev/null
+++ b/Lib/test/test_xmlrpc.py
@@ -0,0 +1,1027 @@
+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 at 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
+
+ at 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)
+
+
+ at 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)
+
+ at 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()
--
Repository URL: http://hg.python.org/jython
More information about the Jython-checkins
mailing list