/Lib/test/test_xmlrpc.py

http://unladen-swallow.googlecode.com/ · Python · 752 lines · 544 code · 108 blank · 100 comment · 58 complexity · 4cb0946e021a2226e0456fd569bdbea8 MD5 · raw file

  1. import base64
  2. import datetime
  3. import sys
  4. import time
  5. import unittest
  6. import xmlrpclib
  7. import SimpleXMLRPCServer
  8. import threading
  9. import mimetools
  10. import httplib
  11. import socket
  12. import StringIO
  13. import os
  14. from test import test_support
  15. try:
  16. unicode
  17. except NameError:
  18. have_unicode = False
  19. else:
  20. have_unicode = True
  21. alist = [{'astring': 'foo@bar.baz.spam',
  22. 'afloat': 7283.43,
  23. 'anint': 2**20,
  24. 'ashortlong': 2L,
  25. 'anotherlist': ['.zyx.41'],
  26. 'abase64': xmlrpclib.Binary("my dog has fleas"),
  27. 'boolean': xmlrpclib.False,
  28. 'unicode': u'\u4000\u6000\u8000',
  29. u'ukey\u4000': 'regular value',
  30. 'datetime1': xmlrpclib.DateTime('20050210T11:41:23'),
  31. 'datetime2': xmlrpclib.DateTime(
  32. (2005, 02, 10, 11, 41, 23, 0, 1, -1)),
  33. 'datetime3': xmlrpclib.DateTime(
  34. datetime.datetime(2005, 02, 10, 11, 41, 23)),
  35. }]
  36. class XMLRPCTestCase(unittest.TestCase):
  37. def test_dump_load(self):
  38. self.assertEquals(alist,
  39. xmlrpclib.loads(xmlrpclib.dumps((alist,)))[0][0])
  40. def test_dump_bare_datetime(self):
  41. # This checks that an unwrapped datetime.date object can be handled
  42. # by the marshalling code. This can't be done via test_dump_load()
  43. # since with use_datetime set to 1 the unmarshaller would create
  44. # datetime objects for the 'datetime[123]' keys as well
  45. dt = datetime.datetime(2005, 02, 10, 11, 41, 23)
  46. s = xmlrpclib.dumps((dt,))
  47. (newdt,), m = xmlrpclib.loads(s, use_datetime=1)
  48. self.assertEquals(newdt, dt)
  49. self.assertEquals(m, None)
  50. (newdt,), m = xmlrpclib.loads(s, use_datetime=0)
  51. self.assertEquals(newdt, xmlrpclib.DateTime('20050210T11:41:23'))
  52. def test_datetime_before_1900(self):
  53. # same as before but with a date before 1900
  54. dt = datetime.datetime(1, 02, 10, 11, 41, 23)
  55. s = xmlrpclib.dumps((dt,))
  56. (newdt,), m = xmlrpclib.loads(s, use_datetime=1)
  57. self.assertEquals(newdt, dt)
  58. self.assertEquals(m, None)
  59. (newdt,), m = xmlrpclib.loads(s, use_datetime=0)
  60. self.assertEquals(newdt, xmlrpclib.DateTime('00010210T11:41:23'))
  61. def test_cmp_datetime_DateTime(self):
  62. now = datetime.datetime.now()
  63. dt = xmlrpclib.DateTime(now.timetuple())
  64. self.assert_(dt == now)
  65. self.assert_(now == dt)
  66. then = now + datetime.timedelta(seconds=4)
  67. self.assert_(then >= dt)
  68. self.assert_(dt < then)
  69. def test_bug_1164912 (self):
  70. d = xmlrpclib.DateTime()
  71. ((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,),
  72. methodresponse=True))
  73. self.assert_(isinstance(new_d.value, str))
  74. # Check that the output of dumps() is still an 8-bit string
  75. s = xmlrpclib.dumps((new_d,), methodresponse=True)
  76. self.assert_(isinstance(s, str))
  77. def test_newstyle_class(self):
  78. class T(object):
  79. pass
  80. t = T()
  81. t.x = 100
  82. t.y = "Hello"
  83. ((t2,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((t,)))
  84. self.assertEquals(t2, t.__dict__)
  85. def test_dump_big_long(self):
  86. self.assertRaises(OverflowError, xmlrpclib.dumps, (2L**99,))
  87. def test_dump_bad_dict(self):
  88. self.assertRaises(TypeError, xmlrpclib.dumps, ({(1,2,3): 1},))
  89. def test_dump_recursive_seq(self):
  90. l = [1,2,3]
  91. t = [3,4,5,l]
  92. l.append(t)
  93. self.assertRaises(TypeError, xmlrpclib.dumps, (l,))
  94. def test_dump_recursive_dict(self):
  95. d = {'1':1, '2':1}
  96. t = {'3':3, 'd':d}
  97. d['t'] = t
  98. self.assertRaises(TypeError, xmlrpclib.dumps, (d,))
  99. def test_dump_big_int(self):
  100. if sys.maxint > 2L**31-1:
  101. self.assertRaises(OverflowError, xmlrpclib.dumps,
  102. (int(2L**34),))
  103. xmlrpclib.dumps((xmlrpclib.MAXINT, xmlrpclib.MININT))
  104. self.assertRaises(OverflowError, xmlrpclib.dumps, (xmlrpclib.MAXINT+1,))
  105. self.assertRaises(OverflowError, xmlrpclib.dumps, (xmlrpclib.MININT-1,))
  106. def dummy_write(s):
  107. pass
  108. m = xmlrpclib.Marshaller()
  109. m.dump_int(xmlrpclib.MAXINT, dummy_write)
  110. m.dump_int(xmlrpclib.MININT, dummy_write)
  111. self.assertRaises(OverflowError, m.dump_int, xmlrpclib.MAXINT+1, dummy_write)
  112. self.assertRaises(OverflowError, m.dump_int, xmlrpclib.MININT-1, dummy_write)
  113. def test_dump_none(self):
  114. value = alist + [None]
  115. arg1 = (alist + [None],)
  116. strg = xmlrpclib.dumps(arg1, allow_none=True)
  117. self.assertEquals(value,
  118. xmlrpclib.loads(strg)[0][0])
  119. self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,))
  120. def test_default_encoding_issues(self):
  121. # SF bug #1115989: wrong decoding in '_stringify'
  122. utf8 = """<?xml version='1.0' encoding='iso-8859-1'?>
  123. <params>
  124. <param><value>
  125. <string>abc \x95</string>
  126. </value></param>
  127. <param><value>
  128. <struct>
  129. <member>
  130. <name>def \x96</name>
  131. <value><string>ghi \x97</string></value>
  132. </member>
  133. </struct>
  134. </value></param>
  135. </params>
  136. """
  137. # sys.setdefaultencoding() normally doesn't exist after site.py is
  138. # loaded. reload(sys) is the way to get it back.
  139. old_encoding = sys.getdefaultencoding()
  140. setdefaultencoding_existed = hasattr(sys, "setdefaultencoding")
  141. reload(sys) # ugh!
  142. sys.setdefaultencoding("iso-8859-1")
  143. try:
  144. (s, d), m = xmlrpclib.loads(utf8)
  145. finally:
  146. sys.setdefaultencoding(old_encoding)
  147. if not setdefaultencoding_existed:
  148. del sys.setdefaultencoding
  149. items = d.items()
  150. if have_unicode:
  151. self.assertEquals(s, u"abc \x95")
  152. self.assert_(isinstance(s, unicode))
  153. self.assertEquals(items, [(u"def \x96", u"ghi \x97")])
  154. self.assert_(isinstance(items[0][0], unicode))
  155. self.assert_(isinstance(items[0][1], unicode))
  156. else:
  157. self.assertEquals(s, "abc \xc2\x95")
  158. self.assertEquals(items, [("def \xc2\x96", "ghi \xc2\x97")])
  159. class HelperTestCase(unittest.TestCase):
  160. def test_escape(self):
  161. self.assertEqual(xmlrpclib.escape("a&b"), "a&amp;b")
  162. self.assertEqual(xmlrpclib.escape("a<b"), "a&lt;b")
  163. self.assertEqual(xmlrpclib.escape("a>b"), "a&gt;b")
  164. class FaultTestCase(unittest.TestCase):
  165. def test_repr(self):
  166. f = xmlrpclib.Fault(42, 'Test Fault')
  167. self.assertEqual(repr(f), "<Fault 42: 'Test Fault'>")
  168. self.assertEqual(repr(f), str(f))
  169. def test_dump_fault(self):
  170. f = xmlrpclib.Fault(42, 'Test Fault')
  171. s = xmlrpclib.dumps((f,))
  172. (newf,), m = xmlrpclib.loads(s)
  173. self.assertEquals(newf, {'faultCode': 42, 'faultString': 'Test Fault'})
  174. self.assertEquals(m, None)
  175. s = xmlrpclib.Marshaller().dumps(f)
  176. self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, s)
  177. class DateTimeTestCase(unittest.TestCase):
  178. def test_default(self):
  179. t = xmlrpclib.DateTime()
  180. def test_time(self):
  181. d = 1181399930.036952
  182. t = xmlrpclib.DateTime(d)
  183. self.assertEqual(str(t), time.strftime("%Y%m%dT%H:%M:%S", time.localtime(d)))
  184. def test_time_tuple(self):
  185. d = (2007,6,9,10,38,50,5,160,0)
  186. t = xmlrpclib.DateTime(d)
  187. self.assertEqual(str(t), '20070609T10:38:50')
  188. def test_time_struct(self):
  189. d = time.localtime(1181399930.036952)
  190. t = xmlrpclib.DateTime(d)
  191. self.assertEqual(str(t), time.strftime("%Y%m%dT%H:%M:%S", d))
  192. def test_datetime_datetime(self):
  193. d = datetime.datetime(2007,1,2,3,4,5)
  194. t = xmlrpclib.DateTime(d)
  195. self.assertEqual(str(t), '20070102T03:04:05')
  196. def test_repr(self):
  197. d = datetime.datetime(2007,1,2,3,4,5)
  198. t = xmlrpclib.DateTime(d)
  199. val ="<DateTime '20070102T03:04:05' at %x>" % id(t)
  200. self.assertEqual(repr(t), val)
  201. def test_decode(self):
  202. d = ' 20070908T07:11:13 '
  203. t1 = xmlrpclib.DateTime()
  204. t1.decode(d)
  205. tref = xmlrpclib.DateTime(datetime.datetime(2007,9,8,7,11,13))
  206. self.assertEqual(t1, tref)
  207. t2 = xmlrpclib._datetime(d)
  208. self.assertEqual(t1, tref)
  209. class BinaryTestCase(unittest.TestCase):
  210. def test_default(self):
  211. t = xmlrpclib.Binary()
  212. self.assertEqual(str(t), '')
  213. def test_string(self):
  214. d = '\x01\x02\x03abc123\xff\xfe'
  215. t = xmlrpclib.Binary(d)
  216. self.assertEqual(str(t), d)
  217. def test_decode(self):
  218. d = '\x01\x02\x03abc123\xff\xfe'
  219. de = base64.encodestring(d)
  220. t1 = xmlrpclib.Binary()
  221. t1.decode(de)
  222. self.assertEqual(str(t1), d)
  223. t2 = xmlrpclib._binary(de)
  224. self.assertEqual(str(t2), d)
  225. PORT = None
  226. # The evt is set twice. First when the server is ready to serve.
  227. # Second when the server has been shutdown. The user must clear
  228. # the event after it has been set the first time to catch the second set.
  229. def http_server(evt, numrequests):
  230. class TestInstanceClass:
  231. def div(self, x, y):
  232. return x // y
  233. def _methodHelp(self, name):
  234. if name == 'div':
  235. return 'This is the div function'
  236. def my_function():
  237. '''This is my function'''
  238. return True
  239. class MyXMLRPCServer(SimpleXMLRPCServer.SimpleXMLRPCServer):
  240. def get_request(self):
  241. # Ensure the socket is always non-blocking. On Linux, socket
  242. # attributes are not inherited like they are on *BSD and Windows.
  243. s, port = self.socket.accept()
  244. s.setblocking(True)
  245. return s, port
  246. try:
  247. serv = MyXMLRPCServer(("localhost", 0),
  248. logRequests=False, bind_and_activate=False)
  249. serv.socket.settimeout(3)
  250. serv.server_bind()
  251. global PORT
  252. PORT = serv.socket.getsockname()[1]
  253. serv.server_activate()
  254. serv.register_introspection_functions()
  255. serv.register_multicall_functions()
  256. serv.register_function(pow)
  257. serv.register_function(lambda x,y: x+y, 'add')
  258. serv.register_function(my_function)
  259. serv.register_instance(TestInstanceClass())
  260. evt.set()
  261. # handle up to 'numrequests' requests
  262. while numrequests > 0:
  263. serv.handle_request()
  264. numrequests -= 1
  265. except socket.timeout:
  266. pass
  267. finally:
  268. serv.socket.close()
  269. PORT = None
  270. evt.set()
  271. # This function prevents errors like:
  272. # <ProtocolError for localhost:57527/RPC2: 500 Internal Server Error>
  273. def is_unavailable_exception(e):
  274. '''Returns True if the given ProtocolError is the product of a server-side
  275. exception caused by the 'temporarily unavailable' response sometimes
  276. given by operations on non-blocking sockets.'''
  277. # sometimes we get a -1 error code and/or empty headers
  278. try:
  279. if e.errcode == -1 or e.headers is None:
  280. return True
  281. exc_mess = e.headers.get('X-exception')
  282. except AttributeError:
  283. # Ignore socket.errors here.
  284. exc_mess = str(e)
  285. if exc_mess and 'temporarily unavailable' in exc_mess.lower():
  286. return True
  287. return False
  288. # NOTE: The tests in SimpleServerTestCase will ignore failures caused by
  289. # "temporarily unavailable" exceptions raised in SimpleXMLRPCServer. This
  290. # condition occurs infrequently on some platforms, frequently on others, and
  291. # is apparently caused by using SimpleXMLRPCServer with a non-blocking socket.
  292. # If the server class is updated at some point in the future to handle this
  293. # situation more gracefully, these tests should be modified appropriately.
  294. class SimpleServerTestCase(unittest.TestCase):
  295. def setUp(self):
  296. # enable traceback reporting
  297. SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = True
  298. self.evt = threading.Event()
  299. # start server thread to handle requests
  300. serv_args = (self.evt, 1)
  301. threading.Thread(target=http_server, args=serv_args).start()
  302. # wait for the server to be ready
  303. self.evt.wait()
  304. self.evt.clear()
  305. def tearDown(self):
  306. # wait on the server thread to terminate
  307. self.evt.wait()
  308. # disable traceback reporting
  309. SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = False
  310. def test_simple1(self):
  311. try:
  312. p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
  313. self.assertEqual(p.pow(6,8), 6**8)
  314. except (xmlrpclib.ProtocolError, socket.error), e:
  315. # ignore failures due to non-blocking socket 'unavailable' errors
  316. if not is_unavailable_exception(e):
  317. # protocol error; provide additional information in test output
  318. self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  319. # [ch] The test 404 is causing lots of false alarms.
  320. def XXXtest_404(self):
  321. # send POST with httplib, it should return 404 header and
  322. # 'Not Found' message.
  323. conn = httplib.HTTPConnection('localhost', PORT)
  324. conn.request('POST', '/this-is-not-valid')
  325. response = conn.getresponse()
  326. conn.close()
  327. self.assertEqual(response.status, 404)
  328. self.assertEqual(response.reason, 'Not Found')
  329. def test_introspection1(self):
  330. try:
  331. p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
  332. meth = p.system.listMethods()
  333. expected_methods = set(['pow', 'div', 'my_function', 'add',
  334. 'system.listMethods', 'system.methodHelp',
  335. 'system.methodSignature', 'system.multicall'])
  336. self.assertEqual(set(meth), expected_methods)
  337. except (xmlrpclib.ProtocolError, socket.error), e:
  338. # ignore failures due to non-blocking socket 'unavailable' errors
  339. if not is_unavailable_exception(e):
  340. # protocol error; provide additional information in test output
  341. self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  342. def test_introspection2(self):
  343. try:
  344. # test _methodHelp()
  345. p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
  346. divhelp = p.system.methodHelp('div')
  347. self.assertEqual(divhelp, 'This is the div function')
  348. except (xmlrpclib.ProtocolError, socket.error), e:
  349. # ignore failures due to non-blocking socket 'unavailable' errors
  350. if not is_unavailable_exception(e):
  351. # protocol error; provide additional information in test output
  352. self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  353. # This test relies on docstrings, which are omitted when -OO is passed.
  354. if sys.flags.optimize <= 1:
  355. def test_introspection3(self):
  356. try:
  357. # test native doc
  358. p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
  359. myfunction = p.system.methodHelp('my_function')
  360. self.assertEqual(myfunction, 'This is my function')
  361. except (xmlrpclib.ProtocolError, socket.error), e:
  362. # ignore failures due to non-blocking socket 'unavailable'
  363. # errors
  364. if not is_unavailable_exception(e):
  365. # protocol error; provide additional information in test
  366. # output
  367. self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  368. def test_introspection4(self):
  369. # the SimpleXMLRPCServer doesn't support signatures, but
  370. # at least check that we can try making the call
  371. try:
  372. p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
  373. divsig = p.system.methodSignature('div')
  374. self.assertEqual(divsig, 'signatures not supported')
  375. except (xmlrpclib.ProtocolError, socket.error), e:
  376. # ignore failures due to non-blocking socket 'unavailable' errors
  377. if not is_unavailable_exception(e):
  378. # protocol error; provide additional information in test output
  379. self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  380. def test_multicall(self):
  381. try:
  382. p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
  383. multicall = xmlrpclib.MultiCall(p)
  384. multicall.add(2,3)
  385. multicall.pow(6,8)
  386. multicall.div(127,42)
  387. add_result, pow_result, div_result = multicall()
  388. self.assertEqual(add_result, 2+3)
  389. self.assertEqual(pow_result, 6**8)
  390. self.assertEqual(div_result, 127//42)
  391. except (xmlrpclib.ProtocolError, socket.error), e:
  392. # ignore failures due to non-blocking socket 'unavailable' errors
  393. if not is_unavailable_exception(e):
  394. # protocol error; provide additional information in test output
  395. self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  396. def test_non_existing_multicall(self):
  397. try:
  398. p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
  399. multicall = xmlrpclib.MultiCall(p)
  400. multicall.this_is_not_exists()
  401. result = multicall()
  402. # result.results contains;
  403. # [{'faultCode': 1, 'faultString': '<type \'exceptions.Exception\'>:'
  404. # 'method "this_is_not_exists" is not supported'>}]
  405. self.assertEqual(result.results[0]['faultCode'], 1)
  406. self.assertEqual(result.results[0]['faultString'],
  407. '<type \'exceptions.Exception\'>:method "this_is_not_exists" '
  408. 'is not supported')
  409. except (xmlrpclib.ProtocolError, socket.error), e:
  410. # ignore failures due to non-blocking socket 'unavailable' errors
  411. if not is_unavailable_exception(e):
  412. # protocol error; provide additional information in test output
  413. self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  414. def test_dotted_attribute(self):
  415. # Raises an AttributeError because private methods are not allowed.
  416. self.assertRaises(AttributeError,
  417. SimpleXMLRPCServer.resolve_dotted_attribute, str, '__add')
  418. self.assert_(SimpleXMLRPCServer.resolve_dotted_attribute(str, 'title'))
  419. # Get the test to run faster by sending a request with test_simple1.
  420. # This avoids waiting for the socket timeout.
  421. self.test_simple1()
  422. # This is a contrived way to make a failure occur on the server side
  423. # in order to test the _send_traceback_header flag on the server
  424. class FailingMessageClass(mimetools.Message):
  425. def __getitem__(self, key):
  426. key = key.lower()
  427. if key == 'content-length':
  428. return 'I am broken'
  429. return mimetools.Message.__getitem__(self, key)
  430. class FailingServerTestCase(unittest.TestCase):
  431. def setUp(self):
  432. self.evt = threading.Event()
  433. # start server thread to handle requests
  434. serv_args = (self.evt, 1)
  435. threading.Thread(target=http_server, args=serv_args).start()
  436. # wait for the server to be ready
  437. self.evt.wait()
  438. self.evt.clear()
  439. def tearDown(self):
  440. # wait on the server thread to terminate
  441. self.evt.wait()
  442. # reset flag
  443. SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = False
  444. # reset message class
  445. SimpleXMLRPCServer.SimpleXMLRPCRequestHandler.MessageClass = mimetools.Message
  446. def test_basic(self):
  447. # check that flag is false by default
  448. flagval = SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header
  449. self.assertEqual(flagval, False)
  450. # enable traceback reporting
  451. SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = True
  452. # test a call that shouldn't fail just as a smoke test
  453. try:
  454. p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
  455. self.assertEqual(p.pow(6,8), 6**8)
  456. except (xmlrpclib.ProtocolError, socket.error), e:
  457. # ignore failures due to non-blocking socket 'unavailable' errors
  458. if not is_unavailable_exception(e):
  459. # protocol error; provide additional information in test output
  460. self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
  461. def test_fail_no_info(self):
  462. # use the broken message class
  463. SimpleXMLRPCServer.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass
  464. try:
  465. p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
  466. p.pow(6,8)
  467. except (xmlrpclib.ProtocolError, socket.error), e:
  468. # ignore failures due to non-blocking socket 'unavailable' errors
  469. if not is_unavailable_exception(e) and hasattr(e, "headers"):
  470. # The two server-side error headers shouldn't be sent back in this case
  471. self.assertTrue(e.headers.get("X-exception") is None)
  472. self.assertTrue(e.headers.get("X-traceback") is None)
  473. else:
  474. self.fail('ProtocolError not raised')
  475. def test_fail_with_info(self):
  476. # use the broken message class
  477. SimpleXMLRPCServer.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass
  478. # Check that errors in the server send back exception/traceback
  479. # info when flag is set
  480. SimpleXMLRPCServer.SimpleXMLRPCServer._send_traceback_header = True
  481. try:
  482. p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
  483. p.pow(6,8)
  484. except (xmlrpclib.ProtocolError, socket.error), e:
  485. # ignore failures due to non-blocking socket 'unavailable' errors
  486. if not is_unavailable_exception(e) and hasattr(e, "headers"):
  487. # We should get error info in the response
  488. expected_err = "invalid literal for int() with base 10: 'I am broken'"
  489. self.assertEqual(e.headers.get("x-exception"), expected_err)
  490. self.assertTrue(e.headers.get("x-traceback") is not None)
  491. else:
  492. self.fail('ProtocolError not raised')
  493. class CGIHandlerTestCase(unittest.TestCase):
  494. def setUp(self):
  495. self.cgi = SimpleXMLRPCServer.CGIXMLRPCRequestHandler()
  496. def tearDown(self):
  497. self.cgi = None
  498. def test_cgi_get(self):
  499. with test_support.EnvironmentVarGuard() as env:
  500. env.set('REQUEST_METHOD', 'GET')
  501. # if the method is GET and no request_text is given, it runs handle_get
  502. # get sysout output
  503. tmp = sys.stdout
  504. sys.stdout = open(test_support.TESTFN, "w")
  505. self.cgi.handle_request()
  506. sys.stdout.close()
  507. sys.stdout = tmp
  508. # parse Status header
  509. handle = open(test_support.TESTFN, "r").read()
  510. status = handle.split()[1]
  511. message = ' '.join(handle.split()[2:4])
  512. self.assertEqual(status, '400')
  513. self.assertEqual(message, 'Bad Request')
  514. os.remove(test_support.TESTFN)
  515. def test_cgi_xmlrpc_response(self):
  516. data = """<?xml version='1.0'?>
  517. <methodCall>
  518. <methodName>test_method</methodName>
  519. <params>
  520. <param>
  521. <value><string>foo</string></value>
  522. </param>
  523. <param>
  524. <value><string>bar</string></value>
  525. </param>
  526. </params>
  527. </methodCall>
  528. """
  529. open("xmldata.txt", "w").write(data)
  530. tmp1 = sys.stdin
  531. tmp2 = sys.stdout
  532. sys.stdin = open("xmldata.txt", "r")
  533. sys.stdout = open(test_support.TESTFN, "w")
  534. with test_support.EnvironmentVarGuard() as env:
  535. env.set('CONTENT_LENGTH', str(len(data)))
  536. self.cgi.handle_request()
  537. sys.stdin.close()
  538. sys.stdout.close()
  539. sys.stdin = tmp1
  540. sys.stdout = tmp2
  541. # will respond exception, if so, our goal is achieved ;)
  542. handle = open(test_support.TESTFN, "r").read()
  543. # start with 44th char so as not to get http header, we just need only xml
  544. self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, handle[44:])
  545. os.remove("xmldata.txt")
  546. os.remove(test_support.TESTFN)
  547. class FakeSocket:
  548. def __init__(self):
  549. self.data = StringIO.StringIO()
  550. def send(self, buf):
  551. self.data.write(buf)
  552. return len(buf)
  553. def sendall(self, buf):
  554. self.data.write(buf)
  555. def getvalue(self):
  556. return self.data.getvalue()
  557. def makefile(self, x, y):
  558. raise RuntimeError
  559. class FakeTransport(xmlrpclib.Transport):
  560. """A Transport instance that records instead of sending a request.
  561. This class replaces the actual socket used by httplib with a
  562. FakeSocket object that records the request. It doesn't provide a
  563. response.
  564. """
  565. def make_connection(self, host):
  566. conn = xmlrpclib.Transport.make_connection(self, host)
  567. conn._conn.sock = self.fake_socket = FakeSocket()
  568. return conn
  569. class TransportSubclassTestCase(unittest.TestCase):
  570. def issue_request(self, transport_class):
  571. """Return an HTTP request made via transport_class."""
  572. transport = transport_class()
  573. proxy = xmlrpclib.ServerProxy("http://example.com/",
  574. transport=transport)
  575. try:
  576. proxy.pow(6, 8)
  577. except RuntimeError:
  578. return transport.fake_socket.getvalue()
  579. return None
  580. def test_custom_user_agent(self):
  581. class TestTransport(FakeTransport):
  582. def send_user_agent(self, conn):
  583. xmlrpclib.Transport.send_user_agent(self, conn)
  584. conn.putheader("X-Test", "test_custom_user_agent")
  585. req = self.issue_request(TestTransport)
  586. self.assert_("X-Test: test_custom_user_agent\r\n" in req)
  587. def test_send_host(self):
  588. class TestTransport(FakeTransport):
  589. def send_host(self, conn, host):
  590. xmlrpclib.Transport.send_host(self, conn, host)
  591. conn.putheader("X-Test", "test_send_host")
  592. req = self.issue_request(TestTransport)
  593. self.assert_("X-Test: test_send_host\r\n" in req)
  594. def test_send_request(self):
  595. class TestTransport(FakeTransport):
  596. def send_request(self, conn, url, body):
  597. xmlrpclib.Transport.send_request(self, conn, url, body)
  598. conn.putheader("X-Test", "test_send_request")
  599. req = self.issue_request(TestTransport)
  600. self.assert_("X-Test: test_send_request\r\n" in req)
  601. def test_send_content(self):
  602. class TestTransport(FakeTransport):
  603. def send_content(self, conn, body):
  604. conn.putheader("X-Test", "test_send_content")
  605. xmlrpclib.Transport.send_content(self, conn, body)
  606. req = self.issue_request(TestTransport)
  607. self.assert_("X-Test: test_send_content\r\n" in req)
  608. def test_main():
  609. if sys.flags.optimize >= 2:
  610. print >>sys.stderr, "test_xmlrpc -- skipping some tests due to -O flag."
  611. sys.stderr.flush()
  612. xmlrpc_tests = [XMLRPCTestCase, HelperTestCase, DateTimeTestCase,
  613. BinaryTestCase, FaultTestCase, TransportSubclassTestCase]
  614. # The test cases against a SimpleXMLRPCServer raise a socket error
  615. # 10035 (WSAEWOULDBLOCK) in the server thread handle_request call when
  616. # run on Windows. This only happens on the first test to run, but it
  617. # fails every time and so these tests are skipped on win32 platforms.
  618. if sys.platform != 'win32':
  619. xmlrpc_tests.append(SimpleServerTestCase)
  620. xmlrpc_tests.append(FailingServerTestCase)
  621. xmlrpc_tests.append(CGIHandlerTestCase)
  622. test_support.run_unittest(*xmlrpc_tests)
  623. if __name__ == "__main__":
  624. test_main()