Debian Codegraph @

Lib/test/test_xmlrpc.py

raw
1 import base64
2 import datetime
3 import decimal
4 import sys
5 import time
6 import unittest
7 from unittest import mock
8 import xmlrpc.client as xmlrpclib
9 import xmlrpc.server
10 import http.client
11 import http, http.server
12 import socket
13 import threading
14 import re
15 import io
16 import contextlib
17 from test import support
18 from test.support import os_helper
19 from test.support import socket_helper
20 from test.support import threading_helper
21 from test.support import ALWAYS_EQ, LARGEST, SMALLEST
22
23 try:
24 import gzip
25 except ImportError:
26 gzip = None
27
28 support.requires_working_socket(module=True)
29
30 alist = [{'astring': '[email protected]',
31 'afloat': 7283.43,
32 'anint': 2**20,
33 'ashortlong': 2,
34 'anotherlist': ['.zyx.41'],
35 'abase64': xmlrpclib.Binary(b"my dog has fleas"),
36 'b64bytes': b"my dog has fleas",
37 'b64bytearray': bytearray(b"my dog has fleas"),
38 'boolean': False,
39 'unicode': '\u4000\u6000\u8000',
40 'ukey\u4000': 'regular value',
41 'datetime1': xmlrpclib.DateTime('20050210T11:41:23'),
42 'datetime2': xmlrpclib.DateTime(
43 (2005, 2, 10, 11, 41, 23, 0, 1, -1)),
44 'datetime3': xmlrpclib.DateTime(
45 datetime.datetime(2005, 2, 10, 11, 41, 23)),
46 }]
47
48 class XMLRPCTestCase(unittest.TestCase):
49
50 def test_dump_load(self):
51 dump = xmlrpclib.dumps((alist,))
52 load = xmlrpclib.loads(dump)
53 self.assertEqual(alist, load[0][0])
54
55 def test_dump_bare_datetime(self):
56 # This checks that an unwrapped datetime.date object can be handled
57 # by the marshalling code. This can't be done via test_dump_load()
58 # since with use_builtin_types set to 1 the unmarshaller would create
59 # datetime objects for the 'datetime[123]' keys as well
60 dt = datetime.datetime(2005, 2, 10, 11, 41, 23)
61 self.assertEqual(dt, xmlrpclib.DateTime('20050210T11:41:23'))
62 s = xmlrpclib.dumps((dt,))
63
64 result, m = xmlrpclib.loads(s, use_builtin_types=True)
65 (newdt,) = result
66 self.assertEqual(newdt, dt)
67 self.assertIs(type(newdt), datetime.datetime)
68 self.assertIsNone(m)
69
70 result, m = xmlrpclib.loads(s, use_builtin_types=False)
71 (newdt,) = result
72 self.assertEqual(newdt, dt)
73 self.assertIs(type(newdt), xmlrpclib.DateTime)
74 self.assertIsNone(m)
75
76 result, m = xmlrpclib.loads(s, use_datetime=True)
77 (newdt,) = result
78 self.assertEqual(newdt, dt)
79 self.assertIs(type(newdt), datetime.datetime)
80 self.assertIsNone(m)
81
82 result, m = xmlrpclib.loads(s, use_datetime=False)
83 (newdt,) = result
84 self.assertEqual(newdt, dt)
85 self.assertIs(type(newdt), xmlrpclib.DateTime)
86 self.assertIsNone(m)
87
88
89 def test_datetime_before_1900(self):
90 # same as before but with a date before 1900
91 dt = datetime.datetime(1, 2, 10, 11, 41, 23)
92 self.assertEqual(dt, xmlrpclib.DateTime('00010210T11:41:23'))
93 s = xmlrpclib.dumps((dt,))
94
95 result, m = xmlrpclib.loads(s, use_builtin_types=True)
96 (newdt,) = result
97 self.assertEqual(newdt, dt)
98 self.assertIs(type(newdt), datetime.datetime)
99 self.assertIsNone(m)
100
101 result, m = xmlrpclib.loads(s, use_builtin_types=False)
102 (newdt,) = result
103 self.assertEqual(newdt, dt)
104 self.assertIs(type(newdt), xmlrpclib.DateTime)
105 self.assertIsNone(m)
106
107 def test_bug_1164912 (self):
108 d = xmlrpclib.DateTime()
109 ((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,),
110 methodresponse=True))
111 self.assertIsInstance(new_d.value, str)
112
113 # Check that the output of dumps() is still an 8-bit string
114 s = xmlrpclib.dumps((new_d,), methodresponse=True)
115 self.assertIsInstance(s, str)
116
117 def test_newstyle_class(self):
118 class T(object):
119 pass
120 t = T()
121 t.x = 100
122 t.y = "Hello"
123 ((t2,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((t,)))
124 self.assertEqual(t2, t.__dict__)
125
126 def test_dump_big_long(self):
127 self.assertRaises(OverflowError, xmlrpclib.dumps, (2**99,))
128
129 def test_dump_bad_dict(self):
130 self.assertRaises(TypeError, xmlrpclib.dumps, ({(1,2,3): 1},))
131
132 def test_dump_recursive_seq(self):
133 l = [1,2,3]
134 t = [3,4,5,l]
135 l.append(t)
136 self.assertRaises(TypeError, xmlrpclib.dumps, (l,))
137
138 def test_dump_recursive_dict(self):
139 d = {'1':1, '2':1}
140 t = {'3':3, 'd':d}
141 d['t'] = t
142 self.assertRaises(TypeError, xmlrpclib.dumps, (d,))
143
144 def test_dump_big_int(self):
145 if sys.maxsize > 2**31-1:
146 self.assertRaises(OverflowError, xmlrpclib.dumps,
147 (int(2**34),))
148
149 xmlrpclib.dumps((xmlrpclib.MAXINT, xmlrpclib.MININT))
150 self.assertRaises(OverflowError, xmlrpclib.dumps,
151 (xmlrpclib.MAXINT+1,))
152 self.assertRaises(OverflowError, xmlrpclib.dumps,
153 (xmlrpclib.MININT-1,))
154
155 def dummy_write(s):
156 pass
157
158 m = xmlrpclib.Marshaller()
159 m.dump_int(xmlrpclib.MAXINT, dummy_write)
160 m.dump_int(xmlrpclib.MININT, dummy_write)
161 self.assertRaises(OverflowError, m.dump_int,
162 xmlrpclib.MAXINT+1, dummy_write)
163 self.assertRaises(OverflowError, m.dump_int,
164 xmlrpclib.MININT-1, dummy_write)
165
166 def test_dump_double(self):
167 xmlrpclib.dumps((float(2 ** 34),))
168 xmlrpclib.dumps((float(xmlrpclib.MAXINT),
169 float(xmlrpclib.MININT)))
170 xmlrpclib.dumps((float(xmlrpclib.MAXINT + 42),
171 float(xmlrpclib.MININT - 42)))
172
173 def dummy_write(s):
174 pass
175
176 m = xmlrpclib.Marshaller()
177 m.dump_double(xmlrpclib.MAXINT, dummy_write)
178 m.dump_double(xmlrpclib.MININT, dummy_write)
179 m.dump_double(xmlrpclib.MAXINT + 42, dummy_write)
180 m.dump_double(xmlrpclib.MININT - 42, dummy_write)
181
182 def test_dump_none(self):
183 value = alist + [None]
184 arg1 = (alist + [None],)
185 strg = xmlrpclib.dumps(arg1, allow_none=True)
186 self.assertEqual(value,
187 xmlrpclib.loads(strg)[0][0])
188 self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,))
189
190 def test_dump_encoding(self):
191 value = {'key\u20ac\xa4':
192 'value\u20ac\xa4'}
193 strg = xmlrpclib.dumps((value,), encoding='iso-8859-15')
194 strg = "<?xml version='1.0' encoding='iso-8859-15'?>" + strg
195 self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
196 strg = strg.encode('iso-8859-15', 'xmlcharrefreplace')
197 self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
198
199 strg = xmlrpclib.dumps((value,), encoding='iso-8859-15',
200 methodresponse=True)
201 self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
202 strg = strg.encode('iso-8859-15', 'xmlcharrefreplace')
203 self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
204
205 methodname = 'method\u20ac\xa4'
206 strg = xmlrpclib.dumps((value,), encoding='iso-8859-15',
207 methodname=methodname)
208 self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
209 self.assertEqual(xmlrpclib.loads(strg)[1], methodname)
210
211 def test_dump_escape_methodname(self):
212 payload = 'foo</methodName><injected attr="evil"/><methodName>bar'
213 s = xmlrpclib.dumps((), methodname=payload)
214 self.assertIn(
215 '<methodName>foo&lt;/methodName&gt;&lt;injected attr="evil"/&gt;'
216 '&lt;methodName&gt;bar</methodName>', s
217 )
218 self.assertNotIn('<injected attr="evil"/>', s)
219 load, m = xmlrpclib.loads(s)
220 self.assertEqual(m, payload)
221
222 def test_dump_bytes(self):
223 sample = b"my dog has fleas"
224 self.assertEqual(sample, xmlrpclib.Binary(sample))
225 for type_ in bytes, bytearray, xmlrpclib.Binary:
226 value = type_(sample)
227 s = xmlrpclib.dumps((value,))
228
229 result, m = xmlrpclib.loads(s, use_builtin_types=True)
230 (newvalue,) = result
231 self.assertEqual(newvalue, sample)
232 self.assertIs(type(newvalue), bytes)
233 self.assertIsNone(m)
234
235 result, m = xmlrpclib.loads(s, use_builtin_types=False)
236 (newvalue,) = result
237 self.assertEqual(newvalue, sample)
238 self.assertIs(type(newvalue), xmlrpclib.Binary)
239 self.assertIsNone(m)
240
241 def test_loads_unsupported(self):
242 ResponseError = xmlrpclib.ResponseError
243 data = '<params><param><value><spam/></value></param></params>'
244 self.assertRaises(ResponseError, xmlrpclib.loads, data)
245 data = ('<params><param><value><array>'
246 '<value><spam/></value>'
247 '</array></value></param></params>')
248 self.assertRaises(ResponseError, xmlrpclib.loads, data)
249 data = ('<params><param><value><struct>'
250 '<member><name>a</name><value><spam/></value></member>'
251 '<member><name>b</name><value><spam/></value></member>'
252 '</struct></value></param></params>')
253 self.assertRaises(ResponseError, xmlrpclib.loads, data)
254
255 def check_loads(self, s, value, **kwargs):
256 dump = '<params><param><value>%s</value></param></params>' % s
257 result, m = xmlrpclib.loads(dump, **kwargs)
258 (newvalue,) = result
259 self.assertEqual(newvalue, value)
260 self.assertIs(type(newvalue), type(value))
261 self.assertIsNone(m)
262
263 def test_load_standard_types(self):
264 check = self.check_loads
265 check('string', 'string')
266 check('<string>string</string>', 'string')
267 check('<string>𝔘𝔫𝔦𝔠𝔬𝔡𝔢 string</string>', '𝔘𝔫𝔦𝔠𝔬𝔡𝔢 string')
268 check('<int>2056183947</int>', 2056183947)
269 check('<int>-2056183947</int>', -2056183947)
270 check('<i4>2056183947</i4>', 2056183947)
271 check('<double>46093.78125</double>', 46093.78125)
272 check('<boolean>0</boolean>', False)
273 check('<base64>AGJ5dGUgc3RyaW5n/w==</base64>',
274 xmlrpclib.Binary(b'\x00byte string\xff'))
275 check('<base64>AGJ5dGUgc3RyaW5n/w==</base64>',
276 b'\x00byte string\xff', use_builtin_types=True)
277 check('<dateTime.iso8601>20050210T11:41:23</dateTime.iso8601>',
278 xmlrpclib.DateTime('20050210T11:41:23'))
279 check('<dateTime.iso8601>20050210T11:41:23</dateTime.iso8601>',
280 datetime.datetime(2005, 2, 10, 11, 41, 23),
281 use_builtin_types=True)
282 check('<array><data>'
283 '<value><int>1</int></value><value><int>2</int></value>'
284 '</data></array>', [1, 2])
285 check('<struct>'
286 '<member><name>b</name><value><int>2</int></value></member>'
287 '<member><name>a</name><value><int>1</int></value></member>'
288 '</struct>', {'a': 1, 'b': 2})
289
290 def test_load_extension_types(self):
291 check = self.check_loads
292 check('<nil/>', None)
293 check('<ex:nil/>', None)
294 check('<i1>205</i1>', 205)
295 check('<i2>20561</i2>', 20561)
296 check('<i8>9876543210</i8>', 9876543210)
297 check('<biginteger>98765432100123456789</biginteger>',
298 98765432100123456789)
299 check('<float>93.78125</float>', 93.78125)
300 check('<bigdecimal>9876543210.0123456789</bigdecimal>',
301 decimal.Decimal('9876543210.0123456789'))
302
303 def test_limit_int(self):
304 check = self.check_loads
305 maxdigits = 5000
306 with support.adjust_int_max_str_digits(maxdigits):
307 s = '1' * (maxdigits + 1)
308 with self.assertRaises(ValueError):
309 check(f'<int>{s}</int>', None)
310 with self.assertRaises(ValueError):
311 check(f'<biginteger>{s}</biginteger>', None)
312
313 def test_get_host_info(self):
314 # see bug #3613, this raised a TypeError
315 transp = xmlrpc.client.Transport()
316 self.assertEqual(transp.get_host_info("[email protected]"),
317 ('host.tld',
318 [('Authorization', 'Basic dXNlcg==')], {}))
319
320 def test_ssl_presence(self):
321 try:
322 import ssl # noqa: F401
323 except ImportError:
324 has_ssl = False
325 else:
326 has_ssl = True
327 try:
328 xmlrpc.client.ServerProxy('https://localhost:9999').bad_function()
329 except NotImplementedError:
330 self.assertFalse(has_ssl, "xmlrpc client's error with SSL support")
331 except OSError:
332 self.assertTrue(has_ssl)
333
334 def test_keepalive_disconnect(self):
335 class RequestHandler(http.server.BaseHTTPRequestHandler):
336 protocol_version = "HTTP/1.1"
337 handled = False
338
339 def do_POST(self):
340 length = int(self.headers.get("Content-Length"))
341 self.rfile.read(length)
342 if self.handled:
343 self.close_connection = True
344 return
345 response = xmlrpclib.dumps((5,), methodresponse=True)
346 response = response.encode()
347 self.send_response(http.HTTPStatus.OK)
348 self.send_header("Content-Length", len(response))
349 self.end_headers()
350 self.wfile.write(response)
351 self.handled = True
352 self.close_connection = False
353
354 def log_message(self, format, *args):
355 # don't clobber sys.stderr
356 pass
357
358 def run_server():
359 server.socket.settimeout(float(1)) # Don't hang if client fails
360 server.handle_request() # First request and attempt at second
361 server.handle_request() # Retried second request
362
363 server = http.server.HTTPServer((socket_helper.HOST, 0), RequestHandler)
364 self.addCleanup(server.server_close)
365 thread = threading.Thread(target=run_server)
366 thread.start()
367 self.addCleanup(thread.join)
368 url = "http://{}:{}/".format(*server.server_address)
369 with xmlrpclib.ServerProxy(url) as p:
370 self.assertEqual(p.method(), 5)
371 self.assertEqual(p.method(), 5)
372
373
374 class SimpleXMLRPCDispatcherTestCase(unittest.TestCase):
375 class DispatchExc(Exception):
376 """Raised inside the dispatched functions when checking for
377 chained exceptions"""
378
379 def test_call_registered_func(self):
380 """Calls explicitly registered function"""
381 # Makes sure any exception raised inside the function has no other
382 # exception chained to it
383
384 exp_params = 1, 2, 3
385
386 def dispatched_func(*params):
387 raise self.DispatchExc(params)
388
389 dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
390 dispatcher.register_function(dispatched_func)
391 with self.assertRaises(self.DispatchExc) as exc_ctx:
392 dispatcher._dispatch('dispatched_func', exp_params)
393 self.assertEqual(exc_ctx.exception.args, (exp_params,))
394 self.assertIsNone(exc_ctx.exception.__cause__)
395 self.assertIsNone(exc_ctx.exception.__context__)
396
397 def test_call_instance_func(self):
398 """Calls a registered instance attribute as a function"""
399 # Makes sure any exception raised inside the function has no other
400 # exception chained to it
401
402 exp_params = 1, 2, 3
403
404 class DispatchedClass:
405 def dispatched_func(self, *params):
406 raise SimpleXMLRPCDispatcherTestCase.DispatchExc(params)
407
408 dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
409 dispatcher.register_instance(DispatchedClass())
410 with self.assertRaises(self.DispatchExc) as exc_ctx:
411 dispatcher._dispatch('dispatched_func', exp_params)
412 self.assertEqual(exc_ctx.exception.args, (exp_params,))
413 self.assertIsNone(exc_ctx.exception.__cause__)
414 self.assertIsNone(exc_ctx.exception.__context__)
415
416 def test_call_dispatch_func(self):
417 """Calls the registered instance's `_dispatch` function"""
418 # Makes sure any exception raised inside the function has no other
419 # exception chained to it
420
421 exp_method = 'method'
422 exp_params = 1, 2, 3
423
424 class TestInstance:
425 def _dispatch(self, method, params):
426 raise SimpleXMLRPCDispatcherTestCase.DispatchExc(
427 method, params)
428
429 dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
430 dispatcher.register_instance(TestInstance())
431 with self.assertRaises(self.DispatchExc) as exc_ctx:
432 dispatcher._dispatch(exp_method, exp_params)
433 self.assertEqual(exc_ctx.exception.args, (exp_method, exp_params))
434 self.assertIsNone(exc_ctx.exception.__cause__)
435 self.assertIsNone(exc_ctx.exception.__context__)
436
437 def test_registered_func_is_none(self):
438 """Calls explicitly registered function which is None"""
439
440 dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
441 dispatcher.register_function(None, name='method')
442 with self.assertRaisesRegex(Exception, 'method'):
443 dispatcher._dispatch('method', ('param',))
444
445 def test_instance_has_no_func(self):
446 """Attempts to call nonexistent function on a registered instance"""
447
448 dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
449 dispatcher.register_instance(object())
450 with self.assertRaisesRegex(Exception, 'method'):
451 dispatcher._dispatch('method', ('param',))
452
453 def test_cannot_locate_func(self):
454 """Calls a function that the dispatcher cannot locate"""
455
456 dispatcher = xmlrpc.server.SimpleXMLRPCDispatcher()
457 with self.assertRaisesRegex(Exception, 'method'):
458 dispatcher._dispatch('method', ('param',))
459
460
461 class HelperTestCase(unittest.TestCase):
462 def test_escape(self):
463 self.assertEqual(xmlrpclib.escape("a&b"), "a&amp;b")
464 self.assertEqual(xmlrpclib.escape("a<b"), "a&lt;b")
465 self.assertEqual(xmlrpclib.escape("a>b"), "a&gt;b")
466
467 class FaultTestCase(unittest.TestCase):
468 def test_repr(self):
469 f = xmlrpclib.Fault(42, 'Test Fault')
470 self.assertEqual(repr(f), "<Fault 42: 'Test Fault'>")
471 self.assertEqual(repr(f), str(f))
472
473 def test_dump_fault(self):
474 f = xmlrpclib.Fault(42, 'Test Fault')
475 s = xmlrpclib.dumps((f,))
476 (newf,), m = xmlrpclib.loads(s)
477 self.assertEqual(newf, {'faultCode': 42, 'faultString': 'Test Fault'})
478 self.assertEqual(m, None)
479
480 s = xmlrpclib.Marshaller().dumps(f)
481 self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, s)
482
483 def test_dotted_attribute(self):
484 # this will raise AttributeError because code don't want us to use
485 # private methods
486 self.assertRaises(AttributeError,
487 xmlrpc.server.resolve_dotted_attribute, str, '__add')
488 self.assertTrue(xmlrpc.server.resolve_dotted_attribute(str, 'title'))
489
490 class DateTimeTestCase(unittest.TestCase):
491 def test_default(self):
492 with mock.patch('time.localtime') as localtime_mock:
493 time_struct = time.struct_time(
494 [2013, 7, 15, 0, 24, 49, 0, 196, 0])
495 localtime_mock.return_value = time_struct
496 localtime = time.localtime()
497 t = xmlrpclib.DateTime()
498 self.assertEqual(str(t),
499 time.strftime("%Y%m%dT%H:%M:%S", localtime))
500
501 def test_time(self):
502 d = 1181399930.036952
503 t = xmlrpclib.DateTime(d)
504 self.assertEqual(str(t),
505 time.strftime("%Y%m%dT%H:%M:%S", time.localtime(d)))
506
507 def test_time_tuple(self):
508 d = (2007,6,9,10,38,50,5,160,0)
509 t = xmlrpclib.DateTime(d)
510 self.assertEqual(str(t), '20070609T10:38:50')
511
512 def test_time_struct(self):
513 d = time.localtime(1181399930.036952)
514 t = xmlrpclib.DateTime(d)
515 self.assertEqual(str(t), time.strftime("%Y%m%dT%H:%M:%S", d))
516
517 def test_datetime_datetime(self):
518 # naive (no tzinfo)
519 d = datetime.datetime(2007,1,2,3,4,5)
520 t = xmlrpclib.DateTime(d)
521 self.assertEqual(str(t), '20070102T03:04:05')
522
523 # aware (with tzinfo): the timezone is ignored
524 d = datetime.datetime(2023, 6, 12, 13, 30, tzinfo=datetime.UTC)
525 t = xmlrpclib.DateTime(d)
526 self.assertEqual(str(t), '20230612T13:30:00')
527
528 def test_repr(self):
529 d = datetime.datetime(2007,1,2,3,4,5)
530 t = xmlrpclib.DateTime(d)
531 val ="<DateTime '20070102T03:04:05' at %#x>" % id(t)
532 self.assertEqual(repr(t), val)
533
534 def test_decode(self):
535 d = ' 20070908T07:11:13 '
536 t1 = xmlrpclib.DateTime()
537 t1.decode(d)
538 tref = xmlrpclib.DateTime(datetime.datetime(2007,9,8,7,11,13))
539 self.assertEqual(t1, tref)
540
541 t2 = xmlrpclib._datetime(d)
542 self.assertEqual(t2, tref)
543
544 def test_comparison(self):
545 now = datetime.datetime.now()
546 dtime = xmlrpclib.DateTime(now.timetuple())
547
548 # datetime vs. DateTime
549 self.assertTrue(dtime == now)
550 self.assertTrue(now == dtime)
551 then = now + datetime.timedelta(seconds=4)
552 self.assertTrue(then >= dtime)
553 self.assertTrue(dtime < then)
554
555 # str vs. DateTime
556 dstr = now.strftime("%Y%m%dT%H:%M:%S")
557 self.assertTrue(dtime == dstr)
558 self.assertTrue(dstr == dtime)
559 dtime_then = xmlrpclib.DateTime(then.timetuple())
560 self.assertTrue(dtime_then >= dstr)
561 self.assertTrue(dstr < dtime_then)
562
563 # some other types
564 dbytes = dstr.encode('ascii')
565 dtuple = now.timetuple()
566 self.assertFalse(dtime == 1970)
567 self.assertTrue(dtime != dbytes)
568 self.assertFalse(dtime == bytearray(dbytes))
569 self.assertTrue(dtime != dtuple)
570 with self.assertRaises(TypeError):
571 dtime < float(1970)
572 with self.assertRaises(TypeError):
573 dtime > dbytes
574 with self.assertRaises(TypeError):
575 dtime <= bytearray(dbytes)
576 with self.assertRaises(TypeError):
577 dtime >= dtuple
578
579 self.assertTrue(dtime == ALWAYS_EQ)
580 self.assertFalse(dtime != ALWAYS_EQ)
581 self.assertTrue(dtime < LARGEST)
582 self.assertFalse(dtime > LARGEST)
583 self.assertTrue(dtime <= LARGEST)
584 self.assertFalse(dtime >= LARGEST)
585 self.assertFalse(dtime < SMALLEST)
586 self.assertTrue(dtime > SMALLEST)
587 self.assertFalse(dtime <= SMALLEST)
588 self.assertTrue(dtime >= SMALLEST)
589
590
591 class BinaryTestCase(unittest.TestCase):
592
593 # XXX What should str(Binary(b"\xff")) return? I'm choosing "\xff"
594 # for now (i.e. interpreting the binary data as Latin-1-encoded
595 # text). But this feels very unsatisfactory. Perhaps we should
596 # only define repr(), and return r"Binary(b'\xff')" instead?
597
598 def test_default(self):
599 t = xmlrpclib.Binary()
600 self.assertEqual(str(t), '')
601
602 def test_string(self):
603 d = b'\x01\x02\x03abc123\xff\xfe'
604 t = xmlrpclib.Binary(d)
605 self.assertEqual(str(t), str(d, "latin-1"))
606
607 def test_decode(self):
608 d = b'\x01\x02\x03abc123\xff\xfe'
609 de = base64.encodebytes(d)
610 t1 = xmlrpclib.Binary()
611 t1.decode(de)
612 self.assertEqual(str(t1), str(d, "latin-1"))
613
614 t2 = xmlrpclib._binary(de)
615 self.assertEqual(str(t2), str(d, "latin-1"))
616
617
618 ADDR = PORT = URL = None
619
620 # The evt is set twice. First when the server is ready to serve.
621 # Second when the server has been shutdown. The user must clear
622 # the event after it has been set the first time to catch the second set.
623 def http_server(evt, numrequests, requestHandler=None, encoding=None):
624 class TestInstanceClass:
625 def div(self, x, y):
626 return x // y
627
628 def _methodHelp(self, name):
629 if name == 'div':
630 return 'This is the div function'
631
632 class Fixture:
633 @staticmethod
634 def getData():
635 return '42'
636
637 class MyXMLRPCServer(xmlrpc.server.SimpleXMLRPCServer):
638 def get_request(self):
639 # Ensure the socket is always non-blocking. On Linux, socket
640 # attributes are not inherited like they are on *BSD and Windows.
641 s, port = self.socket.accept()
642 s.setblocking(True)
643 return s, port
644
645 if not requestHandler:
646 requestHandler = xmlrpc.server.SimpleXMLRPCRequestHandler
647 serv = MyXMLRPCServer(("localhost", 0), requestHandler,
648 encoding=encoding,
649 logRequests=False, bind_and_activate=False)
650 try:
651 serv.server_bind()
652 global ADDR, PORT, URL
653 ADDR, PORT = serv.socket.getsockname()
654 #connect to IP address directly. This avoids socket.create_connection()
655 #trying to connect to "localhost" using all address families, which
656 #causes slowdown e.g. on vista which supports AF_INET6. The server listens
657 #on AF_INET only.
658 URL = "http://%s:%d"%(ADDR, PORT)
659 serv.server_activate()
660 serv.register_introspection_functions()
661 serv.register_multicall_functions()
662 serv.register_function(pow)
663 serv.register_function(lambda x: x, 'têšt')
664 @serv.register_function
665 def my_function():
666 '''This is my function'''
667 return True
668 @serv.register_function(name='add')
669 def _(x, y):
670 return x + y
671 testInstance = TestInstanceClass()
672 serv.register_instance(testInstance, allow_dotted_names=True)
673 evt.set()
674
675 # handle up to 'numrequests' requests
676 while numrequests > 0:
677 serv.handle_request()
678 numrequests -= 1
679
680 except TimeoutError:
681 pass
682 finally:
683 serv.socket.close()
684 PORT = None
685 evt.set()
686
687 def http_multi_server(evt, numrequests, requestHandler=None):
688 class TestInstanceClass:
689 def div(self, x, y):
690 return x // y
691
692 def _methodHelp(self, name):
693 if name == 'div':
694 return 'This is the div function'
695
696 def my_function():
697 '''This is my function'''
698 return True
699
700 class MyXMLRPCServer(xmlrpc.server.MultiPathXMLRPCServer):
701 def get_request(self):
702 # Ensure the socket is always non-blocking. On Linux, socket
703 # attributes are not inherited like they are on *BSD and Windows.
704 s, port = self.socket.accept()
705 s.setblocking(True)
706 return s, port
707
708 if not requestHandler:
709 requestHandler = xmlrpc.server.SimpleXMLRPCRequestHandler
710 class MyRequestHandler(requestHandler):
711 rpc_paths = []
712
713 class BrokenDispatcher:
714 def _marshaled_dispatch(self, data, dispatch_method=None, path=None):
715 raise RuntimeError("broken dispatcher")
716
717 serv = MyXMLRPCServer(("localhost", 0), MyRequestHandler,
718 logRequests=False, bind_and_activate=False)
719 serv.socket.settimeout(3)
720 serv.server_bind()
721 try:
722 global ADDR, PORT, URL
723 ADDR, PORT = serv.socket.getsockname()
724 #connect to IP address directly. This avoids socket.create_connection()
725 #trying to connect to "localhost" using all address families, which
726 #causes slowdown e.g. on vista which supports AF_INET6. The server listens
727 #on AF_INET only.
728 URL = "http://%s:%d"%(ADDR, PORT)
729 serv.server_activate()
730 paths = [
731 "/foo", "/foo/bar",
732 "/foo?k=v", "/foo#frag", "/foo?k=v#frag",
733 "", "/", "/RPC2", "?k=v", "#frag",
734 ]
735 for path in paths:
736 d = serv.add_dispatcher(path, xmlrpc.server.SimpleXMLRPCDispatcher())
737 d.register_introspection_functions()
738 d.register_multicall_functions()
739 d.register_function(lambda p=path: p, 'test')
740 serv.get_dispatcher(paths[0]).register_function(pow)
741 serv.get_dispatcher(paths[1]).register_function(lambda x,y: x+y, 'add')
742 serv.add_dispatcher("/is/broken", BrokenDispatcher())
743 evt.set()
744
745 # handle up to 'numrequests' requests
746 while numrequests > 0:
747 serv.handle_request()
748 numrequests -= 1
749
750 except TimeoutError:
751 pass
752 finally:
753 serv.socket.close()
754 PORT = None
755 evt.set()
756
757 # This function prevents errors like:
758 # <ProtocolError for localhost:57527/RPC2: 500 Internal Server Error>
759 def is_unavailable_exception(e):
760 '''Returns True if the given ProtocolError is the product of a server-side
761 exception caused by the 'temporarily unavailable' response sometimes
762 given by operations on non-blocking sockets.'''
763
764 # sometimes we get a -1 error code and/or empty headers
765 try:
766 if e.errcode == -1 or e.headers is None:
767 return True
768 exc_mess = e.headers.get('X-exception')
769 except AttributeError:
770 # Ignore OSErrors here.
771 exc_mess = str(e)
772
773 if exc_mess and 'temporarily unavailable' in exc_mess.lower():
774 return True
775
776 def make_request_and_skipIf(condition, reason):
777 # If we skip the test, we have to make a request because
778 # the server created in setUp blocks expecting one to come in.
779 if not condition:
780 return lambda func: func
781 def decorator(func):
782 def make_request_and_skip(self):
783 try:
784 xmlrpclib.ServerProxy(URL).my_function()
785 except (xmlrpclib.ProtocolError, OSError) as e:
786 if not is_unavailable_exception(e):
787 raise
788 raise unittest.SkipTest(reason)
789 return make_request_and_skip
790 return decorator
791
792 class BaseServerTestCase(unittest.TestCase):
793 requestHandler = None
794 request_count = 1
795 threadFunc = staticmethod(http_server)
796
797 def setUp(self):
798 # enable traceback reporting
799 xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = True
800
801 self.evt = threading.Event()
802 # start server thread to handle requests
803 serv_args = (self.evt, self.request_count, self.requestHandler)
804 thread = threading.Thread(target=self.threadFunc, args=serv_args)
805 thread.start()
806 self.addCleanup(thread.join)
807
808 # wait for the server to be ready
809 self.evt.wait()
810 self.evt.clear()
811
812 def tearDown(self):
813 # wait on the server thread to terminate
814 self.evt.wait()
815
816 # disable traceback reporting
817 xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = False
818
819 class SimpleServerTestCase(BaseServerTestCase):
820 def test_simple1(self):
821 try:
822 p = xmlrpclib.ServerProxy(URL)
823 self.assertEqual(p.pow(6,8), 6**8)
824 except (xmlrpclib.ProtocolError, OSError) as e:
825 # ignore failures due to non-blocking socket 'unavailable' errors
826 if not is_unavailable_exception(e):
827 # protocol error; provide additional information in test output
828 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
829
830 def test_nonascii(self):
831 start_string = 'P\N{LATIN SMALL LETTER Y WITH CIRCUMFLEX}t'
832 end_string = 'h\N{LATIN SMALL LETTER O WITH HORN}n'
833 try:
834 p = xmlrpclib.ServerProxy(URL)
835 self.assertEqual(p.add(start_string, end_string),
836 start_string + end_string)
837 except (xmlrpclib.ProtocolError, OSError) as e:
838 # ignore failures due to non-blocking socket 'unavailable' errors
839 if not is_unavailable_exception(e):
840 # protocol error; provide additional information in test output
841 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
842
843 def test_client_encoding(self):
844 start_string = '\u20ac'
845 end_string = '\xa4'
846
847 try:
848 p = xmlrpclib.ServerProxy(URL, encoding='iso-8859-15')
849 self.assertEqual(p.add(start_string, end_string),
850 start_string + end_string)
851 except (xmlrpclib.ProtocolError, socket.error) as e:
852 # ignore failures due to non-blocking socket unavailable errors.
853 if not is_unavailable_exception(e):
854 # protocol error; provide additional information in test output
855 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
856
857 def test_nonascii_methodname(self):
858 try:
859 p = xmlrpclib.ServerProxy(URL, encoding='ascii')
860 self.assertEqual(p.têšt(42), 42)
861 except (xmlrpclib.ProtocolError, socket.error) as e:
862 # ignore failures due to non-blocking socket unavailable errors.
863 if not is_unavailable_exception(e):
864 # protocol error; provide additional information in test output
865 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
866
867 def test_404(self):
868 # send POST with http.client, it should return 404 header and
869 # 'Not Found' message.
870 with contextlib.closing(http.client.HTTPConnection(ADDR, PORT)) as conn:
871 conn.request('POST', '/this-is-not-valid')
872 response = conn.getresponse()
873
874 self.assertEqual(response.status, 404)
875 self.assertEqual(response.reason, 'Not Found')
876
877 def test_introspection1(self):
878 expected_methods = set(['pow', 'div', 'my_function', 'add', 'têšt',
879 'system.listMethods', 'system.methodHelp',
880 'system.methodSignature', 'system.multicall',
881 'Fixture'])
882 try:
883 p = xmlrpclib.ServerProxy(URL)
884 meth = p.system.listMethods()
885 self.assertEqual(set(meth), expected_methods)
886 except (xmlrpclib.ProtocolError, OSError) as e:
887 # ignore failures due to non-blocking socket 'unavailable' errors
888 if not is_unavailable_exception(e):
889 # protocol error; provide additional information in test output
890 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
891
892
893 def test_introspection2(self):
894 try:
895 # test _methodHelp()
896 p = xmlrpclib.ServerProxy(URL)
897 divhelp = p.system.methodHelp('div')
898 self.assertEqual(divhelp, 'This is the div function')
899 except (xmlrpclib.ProtocolError, OSError) as e:
900 # ignore failures due to non-blocking socket 'unavailable' errors
901 if not is_unavailable_exception(e):
902 # protocol error; provide additional information in test output
903 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
904
905 @make_request_and_skipIf(sys.flags.optimize >= 2,
906 "Docstrings are omitted with -O2 and above")
907 def test_introspection3(self):
908 try:
909 # test native doc
910 p = xmlrpclib.ServerProxy(URL)
911 myfunction = p.system.methodHelp('my_function')
912 self.assertEqual(myfunction, 'This is my function')
913 except (xmlrpclib.ProtocolError, OSError) as e:
914 # ignore failures due to non-blocking socket 'unavailable' errors
915 if not is_unavailable_exception(e):
916 # protocol error; provide additional information in test output
917 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
918
919 def test_introspection4(self):
920 # the SimpleXMLRPCServer doesn't support signatures, but
921 # at least check that we can try making the call
922 try:
923 p = xmlrpclib.ServerProxy(URL)
924 divsig = p.system.methodSignature('div')
925 self.assertEqual(divsig, 'signatures not supported')
926 except (xmlrpclib.ProtocolError, OSError) as e:
927 # ignore failures due to non-blocking socket 'unavailable' errors
928 if not is_unavailable_exception(e):
929 # protocol error; provide additional information in test output
930 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
931
932 def test_multicall(self):
933 try:
934 p = xmlrpclib.ServerProxy(URL)
935 multicall = xmlrpclib.MultiCall(p)
936 multicall.add(2,3)
937 multicall.pow(6,8)
938 multicall.div(127,42)
939 add_result, pow_result, div_result = multicall()
940 self.assertEqual(add_result, 2+3)
941 self.assertEqual(pow_result, 6**8)
942 self.assertEqual(div_result, 127//42)
943 except (xmlrpclib.ProtocolError, OSError) as e:
944 # ignore failures due to non-blocking socket 'unavailable' errors
945 if not is_unavailable_exception(e):
946 # protocol error; provide additional information in test output
947 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
948
949 def test_non_existing_multicall(self):
950 try:
951 p = xmlrpclib.ServerProxy(URL)
952 multicall = xmlrpclib.MultiCall(p)
953 multicall.this_is_not_exists()
954 result = multicall()
955
956 # result.results contains;
957 # [{'faultCode': 1, 'faultString': '<class \'exceptions.Exception\'>:'
958 # 'method "this_is_not_exists" is not supported'>}]
959
960 self.assertEqual(result.results[0]['faultCode'], 1)
961 self.assertEqual(result.results[0]['faultString'],
962 '<class \'Exception\'>:method "this_is_not_exists" '
963 'is not supported')
964 except (xmlrpclib.ProtocolError, OSError) as e:
965 # ignore failures due to non-blocking socket 'unavailable' errors
966 if not is_unavailable_exception(e):
967 # protocol error; provide additional information in test output
968 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
969
970 def test_dotted_attribute(self):
971 # Raises an AttributeError because private methods are not allowed.
972 self.assertRaises(AttributeError,
973 xmlrpc.server.resolve_dotted_attribute, str, '__add')
974
975 self.assertTrue(xmlrpc.server.resolve_dotted_attribute(str, 'title'))
976 # Get the test to run faster by sending a request with test_simple1.
977 # This avoids waiting for the socket timeout.
978 self.test_simple1()
979
980 def test_allow_dotted_names_true(self):
981 # XXX also need allow_dotted_names_false test.
982 server = xmlrpclib.ServerProxy("http://%s:%d/RPC2" % (ADDR, PORT))
983 data = server.Fixture.getData()
984 self.assertEqual(data, '42')
985
986 def test_unicode_host(self):
987 server = xmlrpclib.ServerProxy("http://%s:%d/RPC2" % (ADDR, PORT))
988 self.assertEqual(server.add("a", "\xe9"), "a\xe9")
989
990 def test_partial_post(self):
991 # Check that a partial POST doesn't make the server loop: issue #14001.
992 with contextlib.closing(socket.create_connection((ADDR, PORT))) as conn:
993 conn.send('POST /RPC2 HTTP/1.0\r\n'
994 'Content-Length: 100\r\n\r\n'
995 'bye HTTP/1.1\r\n'
996 f'Host: {ADDR}:{PORT}\r\n'
997 'Accept-Encoding: identity\r\n'
998 'Content-Length: 0\r\n\r\n'.encode('ascii'))
999
1000 def test_context_manager(self):
1001 with xmlrpclib.ServerProxy(URL) as server:
1002 server.add(2, 3)
1003 self.assertNotEqual(server('transport')._connection,
1004 (None, None))
1005 self.assertEqual(server('transport')._connection,
1006 (None, None))
1007
1008 def test_context_manager_method_error(self):
1009 try:
1010 with xmlrpclib.ServerProxy(URL) as server:
1011 server.add(2, "a")
1012 except xmlrpclib.Fault:
1013 pass
1014 self.assertEqual(server('transport')._connection,
1015 (None, None))
1016
1017
1018 class SimpleServerEncodingTestCase(BaseServerTestCase):
1019 @staticmethod
1020 def threadFunc(evt, numrequests, requestHandler=None, encoding=None):
1021 http_server(evt, numrequests, requestHandler, 'iso-8859-15')
1022
1023 def test_server_encoding(self):
1024 start_string = '\u20ac'
1025 end_string = '\xa4'
1026
1027 try:
1028 p = xmlrpclib.ServerProxy(URL)
1029 self.assertEqual(p.add(start_string, end_string),
1030 start_string + end_string)
1031 except (xmlrpclib.ProtocolError, socket.error) as e:
1032 # ignore failures due to non-blocking socket unavailable errors.
1033 if not is_unavailable_exception(e):
1034 # protocol error; provide additional information in test output
1035 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
1036
1037
1038 class MultiPathServerTestCase(BaseServerTestCase):
1039 threadFunc = staticmethod(http_multi_server)
1040 request_count = 2
1041 def test_path1(self):
1042 p = xmlrpclib.ServerProxy(URL+"/foo")
1043 self.assertEqual(p.pow(6,8), 6**8)
1044 self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
1045
1046 def test_path2(self):
1047 p = xmlrpclib.ServerProxy(URL+"/foo/bar")
1048 self.assertEqual(p.add(6,8), 6+8)
1049 self.assertRaises(xmlrpclib.Fault, p.pow, 6, 8)
1050
1051 @support.requires_resource('walltime')
1052 def test_path3(self):
1053 p = xmlrpclib.ServerProxy(URL+"/is/broken")
1054 self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
1055
1056 @support.requires_resource('walltime')
1057 def test_invalid_path(self):
1058 p = xmlrpclib.ServerProxy(URL+"/invalid")
1059 self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
1060
1061 @support.requires_resource('walltime')
1062 def test_path_query_fragment(self):
1063 p = xmlrpclib.ServerProxy(URL+"/foo?k=v#frag")
1064 self.assertEqual(p.test(), "/foo?k=v#frag")
1065
1066 @support.requires_resource('walltime')
1067 def test_path_fragment(self):
1068 p = xmlrpclib.ServerProxy(URL+"/foo#frag")
1069 self.assertEqual(p.test(), "/foo#frag")
1070
1071 @support.requires_resource('walltime')
1072 def test_path_query(self):
1073 p = xmlrpclib.ServerProxy(URL+"/foo?k=v")
1074 self.assertEqual(p.test(), "/foo?k=v")
1075
1076 @support.requires_resource('walltime')
1077 def test_empty_path(self):
1078 p = xmlrpclib.ServerProxy(URL)
1079 self.assertEqual(p.test(), "/RPC2")
1080
1081 @support.requires_resource('walltime')
1082 def test_root_path(self):
1083 p = xmlrpclib.ServerProxy(URL + "/")
1084 self.assertEqual(p.test(), "/")
1085
1086 @support.requires_resource('walltime')
1087 def test_empty_path_query(self):
1088 p = xmlrpclib.ServerProxy(URL + "?k=v")
1089 self.assertEqual(p.test(), "?k=v")
1090
1091 @support.requires_resource('walltime')
1092 def test_empty_path_fragment(self):
1093 p = xmlrpclib.ServerProxy(URL + "#frag")
1094 self.assertEqual(p.test(), "#frag")
1095
1096
1097 #A test case that verifies that a server using the HTTP/1.1 keep-alive mechanism
1098 #does indeed serve subsequent requests on the same connection
1099 class BaseKeepaliveServerTestCase(BaseServerTestCase):
1100 #a request handler that supports keep-alive and logs requests into a
1101 #class variable
1102 class RequestHandler(xmlrpc.server.SimpleXMLRPCRequestHandler):
1103 parentClass = xmlrpc.server.SimpleXMLRPCRequestHandler
1104 protocol_version = 'HTTP/1.1'
1105 myRequests = []
1106 def handle(self):
1107 self.myRequests.append([])
1108 self.reqidx = len(self.myRequests)-1
1109 return self.parentClass.handle(self)
1110 def handle_one_request(self):
1111 result = self.parentClass.handle_one_request(self)
1112 self.myRequests[self.reqidx].append(self.raw_requestline)
1113 return result
1114
1115 requestHandler = RequestHandler
1116 def setUp(self):
1117 #clear request log
1118 self.RequestHandler.myRequests = []
1119 return BaseServerTestCase.setUp(self)
1120
1121 #A test case that verifies that a server using the HTTP/1.1 keep-alive mechanism
1122 #does indeed serve subsequent requests on the same connection
1123 class KeepaliveServerTestCase1(BaseKeepaliveServerTestCase):
1124 def test_two(self):
1125 p = xmlrpclib.ServerProxy(URL)
1126 #do three requests.
1127 self.assertEqual(p.pow(6,8), 6**8)
1128 self.assertEqual(p.pow(6,8), 6**8)
1129 self.assertEqual(p.pow(6,8), 6**8)
1130 p("close")()
1131
1132 #they should have all been handled by a single request handler
1133 self.assertEqual(len(self.RequestHandler.myRequests), 1)
1134
1135 #check that we did at least two (the third may be pending append
1136 #due to thread scheduling)
1137 self.assertGreaterEqual(len(self.RequestHandler.myRequests[-1]), 2)
1138
1139
1140 #test special attribute access on the serverproxy, through the __call__
1141 #function.
1142 class KeepaliveServerTestCase2(BaseKeepaliveServerTestCase):
1143 #ask for two keepalive requests to be handled.
1144 request_count=2
1145
1146 def test_close(self):
1147 p = xmlrpclib.ServerProxy(URL)
1148 #do some requests with close.
1149 self.assertEqual(p.pow(6,8), 6**8)
1150 self.assertEqual(p.pow(6,8), 6**8)
1151 self.assertEqual(p.pow(6,8), 6**8)
1152 p("close")() #this should trigger a new keep-alive request
1153 self.assertEqual(p.pow(6,8), 6**8)
1154 self.assertEqual(p.pow(6,8), 6**8)
1155 self.assertEqual(p.pow(6,8), 6**8)
1156 p("close")()
1157
1158 #they should have all been two request handlers, each having logged at least
1159 #two complete requests
1160 self.assertEqual(len(self.RequestHandler.myRequests), 2)
1161 self.assertGreaterEqual(len(self.RequestHandler.myRequests[-1]), 2)
1162 self.assertGreaterEqual(len(self.RequestHandler.myRequests[-2]), 2)
1163
1164
1165 def test_transport(self):
1166 p = xmlrpclib.ServerProxy(URL)
1167 #do some requests with close.
1168 self.assertEqual(p.pow(6,8), 6**8)
1169 p("transport").close() #same as above, really.
1170 self.assertEqual(p.pow(6,8), 6**8)
1171 p("close")()
1172 self.assertEqual(len(self.RequestHandler.myRequests), 2)
1173
1174 #A test case that verifies that gzip encoding works in both directions
1175 #(for a request and the response)
1176 @unittest.skipIf(gzip is None, 'requires gzip')
1177 class GzipServerTestCase(BaseServerTestCase):
1178 #a request handler that supports keep-alive and logs requests into a
1179 #class variable
1180 class RequestHandler(xmlrpc.server.SimpleXMLRPCRequestHandler):
1181 parentClass = xmlrpc.server.SimpleXMLRPCRequestHandler
1182 protocol_version = 'HTTP/1.1'
1183
1184 def do_POST(self):
1185 #store content of last request in class
1186 self.__class__.content_length = int(self.headers["content-length"])
1187 return self.parentClass.do_POST(self)
1188 requestHandler = RequestHandler
1189
1190 class Transport(xmlrpclib.Transport):
1191 #custom transport, stores the response length for our perusal
1192 fake_gzip = False
1193 def parse_response(self, response):
1194 self.response_length=int(response.getheader("content-length", 0))
1195 return xmlrpclib.Transport.parse_response(self, response)
1196
1197 def send_content(self, connection, body):
1198 if self.fake_gzip:
1199 #add a lone gzip header to induce decode error remotely
1200 connection.putheader("Content-Encoding", "gzip")
1201 return xmlrpclib.Transport.send_content(self, connection, body)
1202
1203 def setUp(self):
1204 BaseServerTestCase.setUp(self)
1205
1206 def test_gzip_request(self):
1207 t = self.Transport()
1208 t.encode_threshold = None
1209 p = xmlrpclib.ServerProxy(URL, transport=t)
1210 self.assertEqual(p.pow(6,8), 6**8)
1211 a = self.RequestHandler.content_length
1212 t.encode_threshold = 0 #turn on request encoding
1213 self.assertEqual(p.pow(6,8), 6**8)
1214 b = self.RequestHandler.content_length
1215 self.assertTrue(a>b)
1216 p("close")()
1217
1218 def test_bad_gzip_request(self):
1219 t = self.Transport()
1220 t.encode_threshold = None
1221 t.fake_gzip = True
1222 p = xmlrpclib.ServerProxy(URL, transport=t)
1223 cm = self.assertRaisesRegex(xmlrpclib.ProtocolError,
1224 re.compile(r"\b400\b"))
1225 with cm:
1226 p.pow(6, 8)
1227 p("close")()
1228
1229 def test_gzip_response(self):
1230 t = self.Transport()
1231 p = xmlrpclib.ServerProxy(URL, transport=t)
1232 old = self.requestHandler.encode_threshold
1233 self.requestHandler.encode_threshold = None #no encoding
1234 self.assertEqual(p.pow(6,8), 6**8)
1235 a = t.response_length
1236 self.requestHandler.encode_threshold = 0 #always encode
1237 self.assertEqual(p.pow(6,8), 6**8)
1238 p("close")()
1239 b = t.response_length
1240 self.requestHandler.encode_threshold = old
1241 self.assertTrue(a>b)
1242
1243
1244 @unittest.skipIf(gzip is None, 'requires gzip')
1245 class GzipUtilTestCase(unittest.TestCase):
1246
1247 def test_gzip_decode_limit(self):
1248 max_gzip_decode = 20 * 1024 * 1024
1249 data = b'\0' * max_gzip_decode
1250 encoded = xmlrpclib.gzip_encode(data)
1251 decoded = xmlrpclib.gzip_decode(encoded)
1252 self.assertEqual(len(decoded), max_gzip_decode)
1253
1254 data = b'\0' * (max_gzip_decode + 1)
1255 encoded = xmlrpclib.gzip_encode(data)
1256
1257 with self.assertRaisesRegex(ValueError,
1258 "max gzipped payload length exceeded"):
1259 xmlrpclib.gzip_decode(encoded)
1260
1261 xmlrpclib.gzip_decode(encoded, max_decode=-1)
1262
1263
1264 class HeadersServerTestCase(BaseServerTestCase):
1265 class RequestHandler(xmlrpc.server.SimpleXMLRPCRequestHandler):
1266 test_headers = None
1267
1268 def do_POST(self):
1269 self.__class__.test_headers = self.headers
1270 return super().do_POST()
1271 requestHandler = RequestHandler
1272 standard_headers = [
1273 'Host', 'Accept-Encoding', 'Content-Type', 'User-Agent',
1274 'Content-Length']
1275
1276 def setUp(self):
1277 self.RequestHandler.test_headers = None
1278 return super().setUp()
1279
1280 def assertContainsAdditionalHeaders(self, headers, additional):
1281 expected_keys = sorted(self.standard_headers + list(additional.keys()))
1282 self.assertListEqual(sorted(headers.keys()), expected_keys)
1283
1284 for key, value in additional.items():
1285 self.assertEqual(headers.get(key), value)
1286
1287 def test_header(self):
1288 p = xmlrpclib.ServerProxy(URL, headers=[('X-Test', 'foo')])
1289 self.assertEqual(p.pow(6, 8), 6**8)
1290
1291 headers = self.RequestHandler.test_headers
1292 self.assertContainsAdditionalHeaders(headers, {'X-Test': 'foo'})
1293
1294 def test_header_many(self):
1295 p = xmlrpclib.ServerProxy(
1296 URL, headers=[('X-Test', 'foo'), ('X-Test-Second', 'bar')])
1297 self.assertEqual(p.pow(6, 8), 6**8)
1298
1299 headers = self.RequestHandler.test_headers
1300 self.assertContainsAdditionalHeaders(
1301 headers, {'X-Test': 'foo', 'X-Test-Second': 'bar'})
1302
1303 def test_header_empty(self):
1304 p = xmlrpclib.ServerProxy(URL, headers=[])
1305 self.assertEqual(p.pow(6, 8), 6**8)
1306
1307 headers = self.RequestHandler.test_headers
1308 self.assertContainsAdditionalHeaders(headers, {})
1309
1310 def test_header_tuple(self):
1311 p = xmlrpclib.ServerProxy(URL, headers=(('X-Test', 'foo'),))
1312 self.assertEqual(p.pow(6, 8), 6**8)
1313
1314 headers = self.RequestHandler.test_headers
1315 self.assertContainsAdditionalHeaders(headers, {'X-Test': 'foo'})
1316
1317 def test_header_items(self):
1318 p = xmlrpclib.ServerProxy(URL, headers={'X-Test': 'foo'}.items())
1319 self.assertEqual(p.pow(6, 8), 6**8)
1320
1321 headers = self.RequestHandler.test_headers
1322 self.assertContainsAdditionalHeaders(headers, {'X-Test': 'foo'})
1323
1324
1325 #Test special attributes of the ServerProxy object
1326 class ServerProxyTestCase(unittest.TestCase):
1327 def setUp(self):
1328 unittest.TestCase.setUp(self)
1329 # Actual value of the URL doesn't matter if it is a string in
1330 # the correct format.
1331 self.url = 'http://fake.localhost'
1332
1333 def test_close(self):
1334 p = xmlrpclib.ServerProxy(self.url)
1335 self.assertEqual(p('close')(), None)
1336
1337 def test_transport(self):
1338 t = xmlrpclib.Transport()
1339 p = xmlrpclib.ServerProxy(self.url, transport=t)
1340 self.assertEqual(p('transport'), t)
1341
1342
1343 # This is a contrived way to make a failure occur on the server side
1344 # in order to test the _send_traceback_header flag on the server
1345 class FailingMessageClass(http.client.HTTPMessage):
1346 def get(self, key, failobj=None):
1347 key = key.lower()
1348 if key == 'content-length':
1349 return 'I am broken'
1350 return super().get(key, failobj)
1351
1352
1353 class FailingServerTestCase(unittest.TestCase):
1354 def setUp(self):
1355 self.evt = threading.Event()
1356 # start server thread to handle requests
1357 serv_args = (self.evt, 1)
1358 thread = threading.Thread(target=http_server, args=serv_args)
1359 thread.start()
1360 self.addCleanup(thread.join)
1361
1362 # wait for the server to be ready
1363 self.evt.wait()
1364 self.evt.clear()
1365
1366 def tearDown(self):
1367 # wait on the server thread to terminate
1368 self.evt.wait()
1369 # reset flag
1370 xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = False
1371 # reset message class
1372 default_class = http.client.HTTPMessage
1373 xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = default_class
1374
1375 def test_basic(self):
1376 # check that flag is false by default
1377 flagval = xmlrpc.server.SimpleXMLRPCServer._send_traceback_header
1378 self.assertEqual(flagval, False)
1379
1380 # enable traceback reporting
1381 xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = True
1382
1383 # test a call that shouldn't fail just as a smoke test
1384 try:
1385 p = xmlrpclib.ServerProxy(URL)
1386 self.assertEqual(p.pow(6,8), 6**8)
1387 except (xmlrpclib.ProtocolError, OSError) as e:
1388 # ignore failures due to non-blocking socket 'unavailable' errors
1389 if not is_unavailable_exception(e):
1390 # protocol error; provide additional information in test output
1391 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
1392
1393 def test_fail_no_info(self):
1394 # use the broken message class
1395 xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass
1396
1397 try:
1398 p = xmlrpclib.ServerProxy(URL)
1399 p.pow(6,8)
1400 except (xmlrpclib.ProtocolError, OSError) as e:
1401 # ignore failures due to non-blocking socket 'unavailable' errors
1402 if not is_unavailable_exception(e) and hasattr(e, "headers"):
1403 # The two server-side error headers shouldn't be sent back in this case
1404 self.assertTrue(e.headers.get("X-exception") is None)
1405 self.assertTrue(e.headers.get("X-traceback") is None)
1406 else:
1407 self.fail('ProtocolError not raised')
1408
1409 def test_fail_with_info(self):
1410 # use the broken message class
1411 xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = FailingMessageClass
1412
1413 # Check that errors in the server send back exception/traceback
1414 # info when flag is set
1415 xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = True
1416
1417 try:
1418 p = xmlrpclib.ServerProxy(URL)
1419 p.pow(6,8)
1420 except (xmlrpclib.ProtocolError, OSError) as e:
1421 # ignore failures due to non-blocking socket 'unavailable' errors
1422 if not is_unavailable_exception(e) and hasattr(e, "headers"):
1423 # We should get error info in the response
1424 expected_err = "invalid literal for int() with base 10: 'I am broken'"
1425 self.assertEqual(e.headers.get("X-exception"), expected_err)
1426 self.assertTrue(e.headers.get("X-traceback") is not None)
1427 else:
1428 self.fail('ProtocolError not raised')
1429
1430
1431 @contextlib.contextmanager
1432 def captured_stdout(encoding='utf-8'):
1433 """A variation on support.captured_stdout() which gives a text stream
1434 having a `buffer` attribute.
1435 """
1436 orig_stdout = sys.stdout
1437 sys.stdout = io.TextIOWrapper(io.BytesIO(), encoding=encoding)
1438 try:
1439 yield sys.stdout
1440 finally:
1441 sys.stdout = orig_stdout
1442
1443
1444 class CGIHandlerTestCase(unittest.TestCase):
1445 def setUp(self):
1446 self.cgi = xmlrpc.server.CGIXMLRPCRequestHandler()
1447
1448 def tearDown(self):
1449 self.cgi = None
1450
1451 def test_cgi_get(self):
1452 with os_helper.EnvironmentVarGuard() as env:
1453 env['REQUEST_METHOD'] = 'GET'
1454 # if the method is GET and no request_text is given, it runs handle_get
1455 # get sysout output
1456 with captured_stdout(encoding=self.cgi.encoding) as data_out:
1457 self.cgi.handle_request()
1458
1459 # parse Status header
1460 data_out.seek(0)
1461 handle = data_out.read()
1462 status = handle.split()[1]
1463 message = ' '.join(handle.split()[2:4])
1464
1465 self.assertEqual(status, '400')
1466 self.assertEqual(message, 'Bad Request')
1467
1468
1469 def test_cgi_xmlrpc_response(self):
1470 data = """<?xml version='1.0'?>
1471 <methodCall>
1472 <methodName>test_method</methodName>
1473 <params>
1474 <param>
1475 <value><string>foo</string></value>
1476 </param>
1477 <param>
1478 <value><string>bar</string></value>
1479 </param>
1480 </params>
1481 </methodCall>
1482 """
1483
1484 with os_helper.EnvironmentVarGuard() as env, \
1485 captured_stdout(encoding=self.cgi.encoding) as data_out, \
1486 support.captured_stdin() as data_in:
1487 data_in.write(data)
1488 data_in.seek(0)
1489 env['CONTENT_LENGTH'] = str(len(data))
1490 self.cgi.handle_request()
1491 data_out.seek(0)
1492
1493 # will respond exception, if so, our goal is achieved ;)
1494 handle = data_out.read()
1495
1496 # start with 44th char so as not to get http header, we just
1497 # need only xml
1498 self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, handle[44:])
1499
1500 # Also test the content-length returned by handle_request
1501 # Using the same test method inorder to avoid all the datapassing
1502 # boilerplate code.
1503 # Test for bug: http://bugs.python.org/issue5040
1504
1505 content = handle[handle.find("<?xml"):]
1506
1507 self.assertEqual(
1508 int(re.search(r'Content-Length: (\d+)', handle).group(1)),
1509 len(content))
1510
1511
1512 class UseBuiltinTypesTestCase(unittest.TestCase):
1513
1514 def test_use_builtin_types(self):
1515 # SimpleXMLRPCDispatcher.__init__ accepts use_builtin_types, which
1516 # makes all dispatch of binary data as bytes instances, and all
1517 # dispatch of datetime argument as datetime.datetime instances.
1518 self.log = []
1519 expected_bytes = b"my dog has fleas"
1520 expected_date = datetime.datetime(2008, 5, 26, 18, 25, 12)
1521 marshaled = xmlrpclib.dumps((expected_bytes, expected_date), 'foobar')
1522 def foobar(*args):
1523 self.log.extend(args)
1524 handler = xmlrpc.server.SimpleXMLRPCDispatcher(
1525 allow_none=True, encoding=None, use_builtin_types=True)
1526 handler.register_function(foobar)
1527 handler._marshaled_dispatch(marshaled)
1528 self.assertEqual(len(self.log), 2)
1529 mybytes, mydate = self.log
1530 self.assertEqual(self.log, [expected_bytes, expected_date])
1531 self.assertIs(type(mydate), datetime.datetime)
1532 self.assertIs(type(mybytes), bytes)
1533
1534 def test_cgihandler_has_use_builtin_types_flag(self):
1535 handler = xmlrpc.server.CGIXMLRPCRequestHandler(use_builtin_types=True)
1536 self.assertTrue(handler.use_builtin_types)
1537
1538 def test_xmlrpcserver_has_use_builtin_types_flag(self):
1539 server = xmlrpc.server.SimpleXMLRPCServer(("localhost", 0),
1540 use_builtin_types=True)
1541 server.server_close()
1542 self.assertTrue(server.use_builtin_types)
1543
1544
1545 def setUpModule():
1546 thread_info = threading_helper.threading_setup()
1547 unittest.addModuleCleanup(threading_helper.threading_cleanup, *thread_info)
1548
1549
1550 if __name__ == "__main__":
1551 unittest.main()