← Back to branch summary

~j5-dev/+junk/cherrypy3-3.2.0rc1

« back to all changes in this revision

Viewing changes to cherrypy/test/test_xmlrpc.py

  • Committer: steveh at sjsoft
  • Date: 2010-07-01 13:07:15 UTC
  • Revision ID: steveh@sjsoft.com-20100701130715-w56oim8346qzqlka
New upstream release

Show diffs side-by-side

added added

removed removed

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