NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

test_xmlrpc.py (4952B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\carbon\common\lib\cherrypy\test\test_xmlrpc.py
      2 import sys
      3 from xmlrpclib import DateTime, Fault, ServerProxy, SafeTransport
      4 
      5 class HTTPSTransport(SafeTransport):
      6 
      7     def request(self, host, handler, request_body, verbose = 0):
      8         h = self.make_connection(host)
      9         if verbose:
     10             h.set_debuglevel(1)
     11         self.send_request(h, handler, request_body)
     12         self.send_host(h, host)
     13         self.send_user_agent(h)
     14         self.send_content(h, request_body)
     15         errcode, errmsg, headers = h.getreply()
     16         if errcode != 200:
     17             raise xmlrpclib.ProtocolError(host + handler, errcode, errmsg, headers)
     18         self.verbose = verbose
     19         return self.parse_response(h.getfile())
     20 
     21 
     22 import cherrypy
     23 
     24 def setup_server():
     25     from cherrypy import _cptools
     26 
     27     class Root:
     28 
     29         def index(self):
     30             return "I'm a standard index!"
     31 
     32         index.exposed = True
     33 
     34     class XmlRpc(_cptools.XMLRPCController):
     35 
     36         def foo(self):
     37             return 'Hello world!'
     38 
     39         foo.exposed = True
     40 
     41         def return_single_item_list(self):
     42             return [42]
     43 
     44         return_single_item_list.exposed = True
     45 
     46         def return_string(self):
     47             return 'here is a string'
     48 
     49         return_string.exposed = True
     50 
     51         def return_tuple(self):
     52             return ('here', 'is', 1, 'tuple')
     53 
     54         return_tuple.exposed = True
     55 
     56         def return_dict(self):
     57             return dict(a=1, b=2, c=3)
     58 
     59         return_dict.exposed = True
     60 
     61         def return_composite(self):
     62             return (dict(a=1, z=26), 'hi', ['welcome', 'friend'])
     63 
     64         return_composite.exposed = True
     65 
     66         def return_int(self):
     67             return 42
     68 
     69         return_int.exposed = True
     70 
     71         def return_float(self):
     72             return 3.14
     73 
     74         return_float.exposed = True
     75 
     76         def return_datetime(self):
     77             return DateTime((2003, 10, 7, 8, 1, 0, 1, 280, -1))
     78 
     79         return_datetime.exposed = True
     80 
     81         def return_boolean(self):
     82             return True
     83 
     84         return_boolean.exposed = True
     85 
     86         def test_argument_passing(self, num):
     87             return num * 2
     88 
     89         test_argument_passing.exposed = True
     90 
     91         def test_returning_Fault(self):
     92             return Fault(1, 'custom Fault response')
     93 
     94         test_returning_Fault.exposed = True
     95 
     96     root = Root()
     97     root.xmlrpc = XmlRpc()
     98     cherrypy.tree.mount(root, config={'/': {'request.dispatch': cherrypy.dispatch.XMLRPCDispatcher(),
     99            'tools.xmlrpc.allow_none': 0}})
    100 
    101 
    102 from cherrypy.test import helper
    103 
    104 class XmlRpcTest(helper.CPWebCase):
    105     setup_server = staticmethod(setup_server)
    106 
    107     def testXmlRpc(self):
    108         scheme = 'http'
    109         try:
    110             scheme = self.harness.scheme
    111         except AttributeError:
    112             pass
    113 
    114         if scheme == 'https':
    115             url = 'https://%s:%s/xmlrpc/' % (self.interface(), self.PORT)
    116             proxy = ServerProxy(url, transport=HTTPSTransport())
    117         else:
    118             url = 'http://%s:%s/xmlrpc/' % (self.interface(), self.PORT)
    119             proxy = ServerProxy(url)
    120         self.getPage('/xmlrpc/foo')
    121         self.assertBody('Hello world!')
    122         self.assertEqual(proxy.return_single_item_list(), [42])
    123         self.assertNotEqual(proxy.return_single_item_list(), 'one bazillion')
    124         self.assertEqual(proxy.return_string(), 'here is a string')
    125         self.assertEqual(proxy.return_tuple(), list(('here', 'is', 1, 'tuple')))
    126         self.assertEqual(proxy.return_dict(), {'a': 1,
    127          'c': 3,
    128          'b': 2})
    129         self.assertEqual(proxy.return_composite(), [{'a': 1,
    130           'z': 26}, 'hi', ['welcome', 'friend']])
    131         self.assertEqual(proxy.return_int(), 42)
    132         self.assertEqual(proxy.return_float(), 3.14)
    133         self.assertEqual(proxy.return_datetime(), DateTime((2003, 10, 7, 8, 1, 0, 1, 280, -1)))
    134         self.assertEqual(proxy.return_boolean(), True)
    135         self.assertEqual(proxy.test_argument_passing(22), 44)
    136         try:
    137             proxy.test_argument_passing({})
    138         except Exception:
    139             x = sys.exc_info()[1]
    140             self.assertEqual(x.__class__, Fault)
    141             self.assertEqual(x.faultString, "unsupported operand type(s) for *: 'dict' and 'int'")
    142         else:
    143             self.fail('Expected xmlrpclib.Fault')
    144 
    145         try:
    146             proxy.non_method()
    147         except Exception:
    148             x = sys.exc_info()[1]
    149             self.assertEqual(x.__class__, Fault)
    150             self.assertEqual(x.faultString, 'method "non_method" is not supported')
    151         else:
    152             self.fail('Expected xmlrpclib.Fault')
    153 
    154         try:
    155             proxy.test_returning_Fault()
    156         except Exception:
    157             x = sys.exc_info()[1]
    158             self.assertEqual(x.__class__, Fault)
    159             self.assertEqual(x.faultString, 'custom Fault response')
    160         else:
    161             self.fail('Expected xmlrpclib.Fault')