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