def test_continue_request_no_params_in_request(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
data = '<?xml version="1.0" encoding="UTF-8"?>' \
'<methodCall>' \
'<methodName>supervisor.getAPIVersion</methodName>' \
'</methodCall>'
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
from supervisor.xmlrpc import loads
if loads:
expected = 2
else:
expected = 3
self.assertEqual(len(logdata), expected)
self.assertEqual(logdata[-2],
u'XML-RPC method called: supervisor.getAPIVersion()')
self.assertEqual(logdata[-1],
u'XML-RPC method supervisor.getAPIVersion() returned successfully')
self.assertEqual(len(request.producers), 1)
xml_response = request.producers[0]
import xmlrpclib
response = xmlrpclib.loads(xml_response)
from supervisor.rpcinterface import API_VERSION
self.assertEqual(response[0][0], API_VERSION)
self.assertEqual(request._done, True)
self.assertEqual(request.headers['Content-Type'], 'text/xml')
self.assertEqual(request.headers['Content-Length'], len(xml_response))
def test_ctor(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
self.assertEqual(handler.supervisord, supervisor)
from supervisor.xmlrpc import RootRPCInterface
self.assertEqual(handler.rpcinterface.__class__, RootRPCInterface)
def test_continue_request_500_if_xmlrpc_dumps_raises(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
import xmlrpclib
data = xmlrpclib.dumps((), 'supervisor.getXmlRpcUnmarshallable')
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
from supervisor.xmlrpc import loads
if loads:
expected = 3
else:
expected = 4
self.assertEqual(len(logdata), expected)
self.assertEqual(logdata[-3],
'XML-RPC method called: supervisor.getXmlRpcUnmarshallable()')
self.assertEqual(logdata[-2],
'XML-RPC method supervisor.getXmlRpcUnmarshallable() '
'returned successfully')
self.assertTrue("unexpected exception" in logdata[-1])
self.assertTrue(repr(data) in logdata[-1])
self.assertTrue("Traceback" in logdata[-1])
self.assertTrue("TypeError: cannot marshal" in logdata[-1])
self.assertEqual(request._error, 500)
def test_continue_request_methodsuccess(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
import xmlrpclib
data = xmlrpclib.dumps((), 'supervisor.getAPIVersion')
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
from supervisor.xmlrpc import loads
if loads:
expected = 2
else:
expected = 3
self.assertEqual(len(logdata), expected)
self.assertEqual(logdata[-2],
u'XML-RPC method called: supervisor.getAPIVersion()')
self.assertEqual(logdata[-1],
u'XML-RPC method supervisor.getAPIVersion() returned successfully')
self.assertEqual(len(request.producers), 1)
xml_response = request.producers[0]
response = xmlrpclib.loads(xml_response)
self.assertEqual(response[0][0], '3.0')
self.assertEqual(request._done, True)
self.assertEqual(request.headers['Content-Type'], 'text/xml')
self.assertEqual(request.headers['Content-Length'], len(xml_response))
def test_continue_request_nosuchmethod(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
import xmlrpc.client
data = xmlrpc.client.dumps(('a', 'b'), 'supervisor.noSuchMethod')
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
from supervisor.xmlrpc_lib import loads
if loads:
expected = 2
else:
expected = 3
self.assertEqual(len(logdata), expected)
self.assertEqual(logdata[-2],
'XML-RPC method called: supervisor.noSuchMethod()')
self.assertEqual(
logdata[-1],
('XML-RPC method supervisor.noSuchMethod() returned fault: '
'[1] UNKNOWN_METHOD'))
self.assertEqual(len(request.producers), 1)
xml_response = request.producers[0]
self.assertRaises(xmlrpc.client.Fault, xmlrpc.client.loads,
xml_response)
def test_match(self):
class DummyRequest2:
def __init__(self, uri):
self.uri = uri
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
self.assertEqual(handler.match(DummyRequest2('/RPC2')), True)
self.assertEqual(handler.match(DummyRequest2('/nope')), False)
def test_continue_request_400_if_loads_raises_weird_xml(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
data = '<methodName></methodName><junk></junk>'
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
self.assertEqual(len(logdata), 1)
self.assertTrue(logdata[0].startswith('XML-RPC request data'))
self.assertTrue(repr(data) in logdata[0])
self.assertTrue(logdata[0].endswith('is invalid: unmarshallable'))
self.assertEqual(request._error, 400)
def test_continue_request_400_if_method_name_is_empty(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
data = '<?xml version="1.0" encoding="UTF-8"?>' \
'<methodCall><methodName></methodName></methodCall>'
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
self.assertEqual(len(logdata), 1)
self.assertEqual(logdata[-1],
'XML-RPC request received with no method name')
self.assertEqual(len(request.producers), 0)
self.assertEqual(request._error, 400)
def test_continue_request_400_if_method_name_is_empty(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
data = '<?xml version="1.0" encoding="UTF-8"?>' \
'<methodCall><methodName></methodName></methodCall>'
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
self.assertEqual(len(logdata), 1)
self.assertTrue(logdata[0].startswith('XML-RPC request data'))
self.assertTrue(repr(data) in logdata[0])
self.assertTrue(logdata[0].endswith('is invalid: no method name'))
self.assertEqual(request._error, 400)
def test_continue_request_500(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
data = xmlrpclib.dumps((), 'supervisor.raiseError')
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
self.assertEqual(len(logdata), 2)
self.assertEqual(logdata[-2],
'XML-RPC method called: supervisor.raiseError()')
self.assertTrue(logdata[-1].startswith('Traceback'))
self.assertTrue(logdata[-1].endswith('ValueError: error\n'))
self.assertEqual(len(request.producers), 0)
self.assertEqual(request._error, 500)
def test_continue_request_500_if_rpcinterface_method_call_raises(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
data = xmlrpclib.dumps((), 'supervisor.raiseError')
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
self.assertEqual(len(logdata), 2)
self.assertEqual(logdata[0],
'XML-RPC method called: supervisor.raiseError()')
self.assertTrue("unexpected exception" in logdata[1])
self.assertTrue(repr(data) in logdata[1])
self.assertTrue("Traceback" in logdata[1])
self.assertTrue("ValueError: error" in logdata[1])
self.assertEqual(request._error, 500)
def test_continue_request_400_if_loads_raises_not_xml(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
data = 'this is not an xml-rpc request body'
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
from supervisor.xmlrpc import loads
if loads:
expected = 1
else:
expected = 2
self.assertEqual(len(logdata), expected)
self.assertTrue(logdata[-1].startswith('XML-RPC request data'))
self.assertTrue(repr(data) in logdata[-1])
self.assertTrue(logdata[-1].endswith('is invalid: unmarshallable'))
self.assertEqual(request._error, 400)
def test_continue_request_500(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
import xmlrpclib
data = xmlrpclib.dumps((), 'supervisor.raiseError')
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
from supervisor.xmlrpc import loads
if loads:
expected = 2
else:
expected = 3
self.assertEqual(len(logdata), expected)
self.assertEqual(logdata[-2],
u'XML-RPC method called: supervisor.raiseError()')
self.failUnless(logdata[-1].startswith('Traceback'))
self.failUnless(logdata[-1].endswith('ValueError: error\n'))
self.assertEqual(len(request.producers), 0)
self.assertEqual(request._error, 500)
def test_continue_request_value_is_function(self):
class DummyRPCNamespace(object):
def foo(self):
def inner(self):
return 1
inner.delay = .05
return inner
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace()),
('ns1', DummyRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
data = xmlrpclib.dumps((), 'ns1.foo')
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
self.assertEqual(len(logdata), 2)
self.assertEqual(logdata[-2],
'XML-RPC method called: ns1.foo()')
self.assertEqual(logdata[-1],
'XML-RPC method ns1.foo() returned successfully')
self.assertEqual(len(request.producers), 0)
self.assertEqual(request._done, False)
def test_iterparse_loads_methodcall(self):
s = """<?xml version="1.0"?>
<methodCall>
<methodName>examples.getStateName</methodName>
<params>
<param>
<value><i4>41</i4></value>
</param>
<param>
<value><string>foo</string></value>
</param>
<param>
<value><string></string></value>
</param>
<param>
<!-- xml-rpc spec allows strings without <string> tag -->
<value>bar</value>
</param>
<param>
<value></value>
</param>
<param>
<value><boolean>1</boolean></value>
</param>
<param>
<value><double>-12.214</double></value>
</param>
<param>
<value>
<dateTime.iso8601>19980717T14:08:55</dateTime.iso8601>
</value>
</param>
<param>
<value><base64>eW91IGNhbid0IHJlYWQgdGhpcyE=</base64></value>
</param>
<param>
<struct>
<member><name>j</name><value><i4>5</i4></value></member>
<member><name>k</name><value>abc</value></member>
</struct>
</param>
<param>
<array>
<data>
<value><i4>12</i4></value>
<value><string>abc</string></value>
<value>def</value>
<value><i4>34</i4></value>
</data>
</array>
</param>
<param>
<struct>
<member>
<name>k</name>
<value><array><data>
<value><i4>1</i4></value>
<struct></struct>
</data></array></value>
</member>
</struct>
</param>
</params>
</methodCall>
"""
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
result = handler.loads(s)
params, method = result
import datetime
self.assertEqual(method, 'examples.getStateName')
self.assertEqual(params[0], 41)
self.assertEqual(params[1], 'foo')
self.assertEqual(params[2], '')
self.assertEqual(params[3], 'bar')
self.assertEqual(params[4], '')
self.assertEqual(params[5], True)
self.assertEqual(params[6], -12.214)
self.assertEqual(params[7], datetime.datetime(1998, 7, 17, 14, 8, 55))
self.assertEqual(params[8], "you can't read this!")
self.assertEqual(params[9], {'j': 5, 'k': 'abc'})
self.assertEqual(params[10], [12, 'abc', 'def', 34])
self.assertEqual(params[11], {'k': [1, {}]})
def setUp(self):
self.children = [ ("host1", DummySupervisorRPCNamespace()),
("host2", DummySupervisorRPCNamespace()) ]
self.dispatcher = Dispatcher(self.children)
