You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1127 lines
43 KiB
1127 lines
43 KiB
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:
|
|
import gzip
|
|
except ImportError:
|
|
gzip = None
|
|
|
|
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,
|
|
'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)),
|
|
}]
|
|
|
|
if test_support.have_unicode:
|
|
alist[0].update({
|
|
'unicode': test_support.u(r'\u4000\u6000\u8000'),
|
|
test_support.u(r'ukey\u4000'): 'regular value',
|
|
})
|
|
|
|
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,))
|
|
|
|
@test_support.requires_unicode
|
|
def test_dump_encoding(self):
|
|
value = {test_support.u(r'key\u20ac\xa4'):
|
|
test_support.u(r'value\u20ac\xa4')}
|
|
strg = xmlrpclib.dumps((value,), encoding='iso-8859-15')
|
|
strg = "<?xml version='1.0' encoding='iso-8859-15'?>" + strg
|
|
self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
|
|
|
|
strg = xmlrpclib.dumps((value,), encoding='iso-8859-15',
|
|
methodresponse=True)
|
|
self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
|
|
|
|
methodname = test_support.u(r'method\u20ac\xa4')
|
|
strg = xmlrpclib.dumps((value,), encoding='iso-8859-15',
|
|
methodname=methodname)
|
|
self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
|
|
self.assertEqual(xmlrpclib.loads(strg)[1], methodname)
|
|
|
|
@test_support.requires_unicode
|
|
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 test_support.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")])
|
|
|
|
def test_loads_unsupported(self):
|
|
ResponseError = xmlrpclib.ResponseError
|
|
data = '<params><param><value><spam/></value></param></params>'
|
|
self.assertRaises(ResponseError, xmlrpclib.loads, data)
|
|
data = ('<params><param><value><array>'
|
|
'<value><spam/></value>'
|
|
'</array></value></param></params>')
|
|
self.assertRaises(ResponseError, xmlrpclib.loads, data)
|
|
data = ('<params><param><value><struct>'
|
|
'<member><name>a</name><value><spam/></value></member>'
|
|
'<member><name>b</name><value><spam/></value></member>'
|
|
'</struct></value></param></params>')
|
|
self.assertRaises(ResponseError, xmlrpclib.loads, data)
|
|
|
|
|
|
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, encoding=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,
|
|
encoding=encoding,
|
|
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(lambda x: x, test_support.u(r't\xea\u0161t'))
|
|
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", "")))
|
|
|
|
@test_support.requires_unicode
|
|
def test_nonascii(self):
|
|
start_string = test_support.u(r'P\N{LATIN SMALL LETTER Y WITH CIRCUMFLEX}t')
|
|
end_string = test_support.u(r'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", "")))
|
|
|
|
@test_support.requires_unicode
|
|
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")
|
|
|
|
@test_support.requires_unicode
|
|
def test_client_encoding(self):
|
|
start_string = unichr(0x20ac)
|
|
end_string = unichr(0xa4)
|
|
|
|
try:
|
|
p = xmlrpclib.ServerProxy(URL, encoding='iso-8859-15')
|
|
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", "")))
|
|
|
|
@test_support.requires_unicode
|
|
def test_nonascii_methodname(self):
|
|
try:
|
|
p = xmlrpclib.ServerProxy(URL, encoding='iso-8859-15')
|
|
m = getattr(p, 't\xea\xa8t')
|
|
self.assertEqual(m(42), 42)
|
|
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", "")))
|
|
|
|
# [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',
|
|
test_support.u(r't\xea\u0161t'),
|
|
'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 SimpleServerEncodingTestCase(BaseServerTestCase):
|
|
@staticmethod
|
|
def threadFunc(evt, numrequests, requestHandler=None, encoding=None):
|
|
http_server(evt, numrequests, requestHandler, 'iso-8859-15')
|
|
|
|
@test_support.requires_unicode
|
|
def test_server_encoding(self):
|
|
start_string = unichr(0x20ac)
|
|
end_string = unichr(0xa4)
|
|
|
|
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", "")))
|
|
|
|
|
|
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)
|
|
@unittest.skipUnless(gzip, 'gzip not available')
|
|
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_gzip_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)
|
|
|
|
def test_gzip_decode_limit(self):
|
|
max_gzip_decode = 20 * 1024 * 1024
|
|
data = '\0' * max_gzip_decode
|
|
encoded = xmlrpclib.gzip_encode(data)
|
|
decoded = xmlrpclib.gzip_decode(encoded)
|
|
self.assertEqual(len(decoded), max_gzip_decode)
|
|
|
|
data = '\0' * (max_gzip_decode + 1)
|
|
encoded = xmlrpclib.gzip_encode(data)
|
|
|
|
with self.assertRaisesRegexp(ValueError,
|
|
"max gzipped payload length exceeded"):
|
|
xmlrpclib.gzip_decode(encoded)
|
|
|
|
xmlrpclib.gzip_decode(encoded, max_decode=-1)
|
|
|
|
|
|
#Test special attributes of the ServerProxy object
|
|
class ServerProxyTestCase(unittest.TestCase):
|
|
def setUp(self):
|
|
unittest.TestCase.setUp(self)
|
|
# Actual value of the URL doesn't matter if it is a string in
|
|
# the correct format.
|
|
self.url = 'http://fake.localhost'
|
|
|
|
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(SimpleServerEncodingTestCase)
|
|
xmlrpc_tests.append(KeepaliveServerTestCase1)
|
|
xmlrpc_tests.append(KeepaliveServerTestCase2)
|
|
xmlrpc_tests.append(GzipServerTestCase)
|
|
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()
|