| import datetime |
| import sys |
| import unittest |
| import xmlrpclib |
| from test import test_support |
| |
| try: |
| unicode |
| except NameError: |
| have_unicode = False |
| else: |
| have_unicode = True |
| |
| alist = [{'astring': 'foo@bar.baz.spam', |
| 'afloat': 7283.43, |
| 'anint': 2**20, |
| 'ashortlong': 2, |
| 'anotherlist': ['.zyx.41'], |
| 'abase64': xmlrpclib.Binary("my dog has fleas"), |
| 'boolean': xmlrpclib.False, |
| 'unicode': u'\u4000\u6000\u8000', |
| u'ukey\u4000': 'regular value', |
| 'datetime1': xmlrpclib.DateTime('20050210T11:41:23'), |
| 'datetime2': xmlrpclib.DateTime( |
| (2005, 02, 10, 11, 41, 23, 0, 1, -1)), |
| 'datetime3': xmlrpclib.DateTime( |
| datetime.datetime(2005, 02, 10, 11, 41, 23)), |
| }] |
| |
| class XMLRPCTestCase(unittest.TestCase): |
| |
| def test_dump_load(self): |
| self.assertEquals(alist, |
| xmlrpclib.loads(xmlrpclib.dumps((alist,)))[0][0]) |
| |
| def test_dump_bare_datetime(self): |
| # This checks that an unwrapped datetime.date object can be handled |
| # by the marshalling code. This can't be done via test_dump_load() |
| # since with use_datetime set to 1 the unmarshaller would create |
| # datetime objects for the 'datetime[123]' keys as well |
| dt = datetime.datetime(2005, 02, 10, 11, 41, 23) |
| s = xmlrpclib.dumps((dt,)) |
| (newdt,), m = xmlrpclib.loads(s, use_datetime=1) |
| self.assertEquals(newdt, dt) |
| self.assertEquals(m, None) |
| |
| (newdt,), m = xmlrpclib.loads(s, use_datetime=0) |
| self.assertEquals(newdt, xmlrpclib.DateTime('20050210T11:41:23')) |
| |
| def test_dump_bare_date(self): |
| # This checks that an unwrapped datetime.date object can be handled |
| # by the marshalling code. This can't be done via test_dump_load() |
| # since the unmarshaller produces a datetime object |
| d = datetime.datetime(2005, 02, 10, 11, 41, 23).date() |
| s = xmlrpclib.dumps((d,)) |
| (newd,), m = xmlrpclib.loads(s, use_datetime=1) |
| self.assertEquals(newd.date(), d) |
| self.assertEquals(newd.time(), datetime.time(0, 0, 0)) |
| self.assertEquals(m, None) |
| |
| (newdt,), m = xmlrpclib.loads(s, use_datetime=0) |
| self.assertEquals(newdt, xmlrpclib.DateTime('20050210T00:00:00')) |
| |
| def test_dump_bare_time(self): |
| # This checks that an unwrapped datetime.time object can be handled |
| # by the marshalling code. This can't be done via test_dump_load() |
| # since the unmarshaller produces a datetime object |
| t = datetime.datetime(2005, 02, 10, 11, 41, 23).time() |
| s = xmlrpclib.dumps((t,)) |
| (newt,), m = xmlrpclib.loads(s, use_datetime=1) |
| today = datetime.datetime.now().date().strftime("%Y%m%d") |
| self.assertEquals(newt.time(), t) |
| self.assertEquals(newt.date(), datetime.datetime.now().date()) |
| self.assertEquals(m, None) |
| |
| (newdt,), m = xmlrpclib.loads(s, use_datetime=0) |
| self.assertEquals(newdt, xmlrpclib.DateTime('%sT11:41:23'%today)) |
| |
| def test_bug_1164912 (self): |
| d = xmlrpclib.DateTime() |
| ((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,), |
| methodresponse=True)) |
| self.assert_(isinstance(new_d.value, str)) |
| |
| # Check that the output of dumps() is still an 8-bit string |
| s = xmlrpclib.dumps((new_d,), methodresponse=True) |
| self.assert_(isinstance(s, str)) |
| |
| def test_newstyle_class(self): |
| class T(object): |
| pass |
| t = T() |
| t.x = 100 |
| t.y = "Hello" |
| ((t2,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((t,))) |
| self.assertEquals(t2, t.__dict__) |
| |
| def test_dump_big_long(self): |
| self.assertRaises(OverflowError, xmlrpclib.dumps, (2**99,)) |
| |
| def test_dump_bad_dict(self): |
| self.assertRaises(TypeError, xmlrpclib.dumps, ({(1,2,3): 1},)) |
| |
| def test_dump_big_int(self): |
| if sys.maxint > 2**31-1: |
| self.assertRaises(OverflowError, xmlrpclib.dumps, |
| (int(2**34),)) |
| |
| def test_dump_none(self): |
| value = alist + [None] |
| arg1 = (alist + [None],) |
| strg = xmlrpclib.dumps(arg1, allow_none=True) |
| self.assertEquals(value, |
| xmlrpclib.loads(strg)[0][0]) |
| self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,)) |
| |
| def test_default_encoding_issues(self): |
| # SF bug #1115989: wrong decoding in '_stringify' |
| utf8 = """<?xml version='1.0' encoding='iso-8859-1'?> |
| <params> |
| <param><value> |
| <string>abc \x95</string> |
| </value></param> |
| <param><value> |
| <struct> |
| <member> |
| <name>def \x96</name> |
| <value><string>ghi \x97</string></value> |
| </member> |
| </struct> |
| </value></param> |
| </params> |
| """ |
| |
| # sys.setdefaultencoding() normally doesn't exist after site.py is |
| # loaded. reload(sys) is the way to get it back. |
| old_encoding = sys.getdefaultencoding() |
| setdefaultencoding_existed = hasattr(sys, "setdefaultencoding") |
| reload(sys) # ugh! |
| sys.setdefaultencoding("iso-8859-1") |
| try: |
| (s, d), m = xmlrpclib.loads(utf8) |
| finally: |
| sys.setdefaultencoding(old_encoding) |
| if not setdefaultencoding_existed: |
| del sys.setdefaultencoding |
| |
| items = d.items() |
| if have_unicode: |
| self.assertEquals(s, u"abc \x95") |
| self.assert_(isinstance(s, unicode)) |
| self.assertEquals(items, [(u"def \x96", u"ghi \x97")]) |
| self.assert_(isinstance(items[0][0], unicode)) |
| self.assert_(isinstance(items[0][1], unicode)) |
| else: |
| self.assertEquals(s, "abc \xc2\x95") |
| self.assertEquals(items, [("def \xc2\x96", "ghi \xc2\x97")]) |
| |
| def test_main(): |
| test_support.run_unittest(XMLRPCTestCase) |
| |
| |
| if __name__ == "__main__": |
| test_main() |