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