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