def test_badargs(self):
wrong_type = ["a", 0, 0.1, [], {}, True]
for value in wrong_type:
with self.assertRaises(TypeError):
xmlrpcplus.dumps(value, methodname="foo")
# responses much be singletons
value = (1, 2, 3)
with self.assertRaises(ValueError):
xmlrpcplus.dumps(value, methodresponse=1)
def test_badargs(self):
wrong_type = ["a", 0, 0.1, [], {}, True]
for value in wrong_type:
with self.assertRaises(TypeError):
xmlrpcplus.dumps(value, methodname="foo")
# responses much be singletons
value = (1, 2, 3)
with self.assertRaises(ValueError):
xmlrpcplus.dumps(value, methodresponse=1)
def _wrap_handler(self, handler, environ):
"""Catch exceptions and encode response of handler"""
# generate response
try:
response = handler(environ)
# wrap response in a singleton tuple
response = (response, )
response = dumps(response, methodresponse=1, marshaller=Marshaller)
except Fault, fault:
self.traceback = True
response = dumps(fault, marshaller=Marshaller)
def test_i8(self):
for value in self.long_data:
value = (value, )
enc = xmlrpcplus.dumps(value, methodresponse=1)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, None)
# and as a call
method = "foomethod"
value = tuple(self.long_data)
enc = xmlrpcplus.dumps(value, methodname=method)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, method)
def test_i8(self):
for value in self.long_data:
value = (value,)
enc = xmlrpcplus.dumps(value, methodresponse=1)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, None)
# and as a call
method = "foomethod"
value = tuple(self.long_data)
enc = xmlrpcplus.dumps(value, methodname=method)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, method)
def test_generator(self):
value = (self.gendata(),)
enc = xmlrpcplus.dumps(value, methodresponse=1)
params, method = xmlrpc_client.loads(enc)
expect = (list(self.gendata()),)
self.assertEqual(params, expect)
self.assertEqual(method, None)
def test_generator(self):
value = (self.gendata(), )
enc = xmlrpcplus.dumps(value, methodresponse=1)
params, method = xmlrpc_client.loads(enc)
expect = (list(self.gendata()), )
self.assertEqual(params, expect)
self.assertEqual(method, None)
def test_no_i8(self):
# we shouldn't use i8 if we don't have to
data = [
23,
42,
-1024,
2**31 - 1,
-2**31,
[2**31 - 1],
{
"a": -2**31,
"b": 3.14
},
]
for value in data:
value = (value, )
enc = xmlrpcplus.dumps(value,
methodresponse=1,
encoding='us-ascii')
_enc = xmlrpc_client.dumps(value,
methodresponse=1,
allow_none=1,
encoding='us-ascii')
if 'i8' in enc or 'I8' in enc:
raise Exception('i8 used unnecessarily')
self.assertEqual(enc, _enc)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, None)
def test_marshaller(self):
value = 3.14159
value = (value,)
enc = xmlrpcplus.dumps(value, methodresponse=1, marshaller=MyMarshaller)
params, method = xmlrpc_client.loads(enc)
# MyMarshaller rounds off floats
self.assertEqual(params, (3,))
self.assertEqual(method, None)
def test_response(self):
for value in self.standard_data:
value = (value, )
enc = xmlrpcplus.dumps(value, methodresponse=1)
_enc = xmlrpc_client.dumps(value, methodresponse=1, allow_none=1)
self.assertEqual(enc, _enc)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, None)
def test_response(self):
for value in self.standard_data:
value = (value,)
enc = xmlrpcplus.dumps(value, methodresponse=1)
_enc = xmlrpc_client.dumps(value, methodresponse=1, allow_none=1)
self.assertEqual(enc, _enc)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, None)
def test_call(self):
method = 'my_rpc_method'
for value in self.standard_data:
value = (value, "other arg")
enc = xmlrpcplus.dumps(value, methodname=method)
_enc = xmlrpc_client.dumps(value, methodname=method, allow_none=1)
self.assertEqual(enc, _enc)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, method)
def test_call(self):
method = 'my_rpc_method'
for value in self.standard_data:
value = (value, "other arg")
enc = xmlrpcplus.dumps(value, methodname=method)
_enc = xmlrpc_client.dumps(value, methodname=method, allow_none=1)
self.assertEqual(enc, _enc)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, method)
def test_just_data(self):
# xmlrpc_client supports this case, so I guess we should too
# neither method call nor response
for value in self.standard_data:
value = (value, "foo", "bar")
enc = xmlrpcplus.dumps(value)
_enc = xmlrpc_client.dumps(value, allow_none=1)
self.assertEqual(enc, _enc)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, None)
def _wrap_handler(self, handler, environ):
"""Catch exceptions and encode response of handler"""
# generate response
try:
response = handler(environ)
# wrap response in a singleton tuple
response = (response, )
response = dumps(response, methodresponse=1, marshaller=Marshaller)
except Fault as fault:
self.traceback = True
response = dumps(fault, marshaller=Marshaller)
except Exception:
self.traceback = True
# report exception back to server
faultCode, faultString = self._log_exception()
response = dumps(Fault(faultCode, faultString),
marshaller=Marshaller)
return response
def test_just_data(self):
# xmlrpc_client supports this case, so I guess we should too
# neither method call nor response
for value in self.standard_data:
value = (value, "foo", "bar")
enc = xmlrpcplus.dumps(value)
_enc = xmlrpc_client.dumps(value, allow_none=1)
self.assertEqual(enc, _enc)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, None)
def _wrap_handler(self, handler, environ):
"""Catch exceptions and encode response of handler"""
# generate response
try:
response = handler(environ)
# wrap response in a singleton tuple
response = (response, )
response = dumps(response, methodresponse=1, marshaller=Marshaller)
except Fault as fault:
self.traceback = True
response = dumps(fault, marshaller=Marshaller)
except:
self.traceback = True
# report exception back to server
e_class, e = sys.exc_info()[:2]
faultCode = getattr(e_class, 'faultCode', 1)
tb_type = context.opts.get('KojiTraceback', None)
tb_str = ''.join(traceback.format_exception(*sys.exc_info()))
if issubclass(e_class, koji.GenericError):
if context.opts.get('KojiDebug'):
if tb_type == "extended":
faultString = koji.format_exc_plus()
else:
faultString = tb_str
else:
faultString = str(e)
else:
if tb_type == "normal":
faultString = tb_str
elif tb_type == "extended":
faultString = koji.format_exc_plus()
else:
faultString = "%s: %s" % (e_class, e)
self.logger.warning(tb_str)
response = dumps(Fault(faultCode, faultString),
marshaller=Marshaller)
return response
def _wrap_handler(self, handler, environ):
"""Catch exceptions and encode response of handler"""
# generate response
try:
response = handler(environ)
# wrap response in a singleton tuple
response = (response,)
response = dumps(response, methodresponse=1, marshaller=Marshaller)
except Fault as fault:
self.traceback = True
response = dumps(fault, marshaller=Marshaller)
except:
self.traceback = True
# report exception back to server
e_class, e = sys.exc_info()[:2]
faultCode = getattr(e_class, 'faultCode', 1)
tb_type = context.opts.get('KojiTraceback', None)
tb_str = ''.join(traceback.format_exception(*sys.exc_info()))
if issubclass(e_class, koji.GenericError):
if context.opts.get('KojiDebug'):
if tb_type == "extended":
faultString = koji.format_exc_plus()
else:
faultString = tb_str
else:
faultString = str(e)
else:
if tb_type == "normal":
faultString = tb_str
elif tb_type == "extended":
faultString = koji.format_exc_plus()
else:
faultString = "%s: %s" % (e_class, e)
self.logger.warning(tb_str)
response = dumps(Fault(faultCode, faultString), marshaller=Marshaller)
return response
def test_encoding(self):
data = [
45,
["hello", "world"],
{"a": 5.5, "b": [None]},
]
for value in data:
value = (value,)
enc = xmlrpcplus.dumps(value, methodresponse=1, encoding='us-ascii')
_enc = xmlrpc_client.dumps(value, methodresponse=1, allow_none=1, encoding='us-ascii')
self.assertEqual(enc, _enc)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, None)
def offline_reply(start_response, msg=None):
"""Send a ServerOffline reply"""
faultCode = koji.ServerOffline.faultCode
if msg is None:
faultString = "server is offline"
else:
faultString = msg
response = dumps(Fault(faultCode, faultString))
headers = [
('Content-Length', str(len(response))),
('Content-Type', "text/xml"),
]
start_response('200 OK', headers)
return [response]
def test_fault(self):
code = 1001
msg = "some useless error"
f1 = xmlrpcplus.Fault(code, msg)
f2 = xmlrpc_client.Fault(code, msg)
value = f1
enc = xmlrpcplus.dumps(value, methodresponse=1)
_enc = xmlrpc_client.dumps(value, methodresponse=1, allow_none=1)
self.assertEqual(enc, _enc)
try:
params, method = xmlrpc_client.loads(enc)
except xmlrpc_client.Fault as e:
self.assertEqual(e.faultCode, code)
self.assertEqual(e.faultString, msg)
else:
raise Exception('Fault not raised')
def offline_reply(start_response, msg=None):
"""Send a ServerOffline reply"""
faultCode = koji.ServerOffline.faultCode
if msg is None:
faultString = "server is offline"
else:
faultString = msg
response = dumps(Fault(faultCode, faultString))
if six.PY3:
response = response.encode()
headers = [
('Content-Length', str(len(response))),
('Content-Type', "text/xml"),
]
start_response('200 OK', headers)
return [response]
def test_fault(self):
code = 1001
msg = "some useless error"
f1 = xmlrpcplus.Fault(code, msg)
f2 = xmlrpc_client.Fault(code, msg)
value = f1
enc = xmlrpcplus.dumps(value, methodresponse=1)
_enc = xmlrpc_client.dumps(value, methodresponse=1, allow_none=1)
self.assertEqual(enc, _enc)
try:
params, method = xmlrpc_client.loads(enc)
except xmlrpc_client.Fault as e:
self.assertEqual(e.faultCode, code)
self.assertEqual(e.faultString, msg)
else:
raise Exception('Fault not raised')
def test_no_i8(self):
# we shouldn't use i8 if we don't have to
data = [
23,
42,
-1024,
2 ** 31 - 1,
-2 ** 31,
[2**31 -1],
{"a": -2 ** 31, "b": 3.14},
]
for value in data:
value = (value,)
enc = xmlrpcplus.dumps(value, methodresponse=1, encoding='us-ascii')
_enc = xmlrpc_client.dumps(value, methodresponse=1, allow_none=1, encoding='us-ascii')
if 'i8' in enc or 'I8' in enc:
raise Exception('i8 used unnecessarily')
self.assertEqual(enc, _enc)
params, method = xmlrpc_client.loads(enc)
self.assertEqual(params, value)
self.assertEqual(method, None)
if context.opts.get('KojiDebug'):
if tb_type == "extended":
faultString = koji.format_exc_plus()
else:
faultString = tb_str
else:
faultString = str(e)
else:
if tb_type == "normal":
faultString = tb_str
elif tb_type == "extended":
faultString = koji.format_exc_plus()
else:
faultString = "%s: %s" % (e_class, e)
self.logger.warning(tb_str)
response = dumps(Fault(faultCode, faultString),
marshaller=Marshaller)
return response
def handle_upload(self, environ):
#uploads can't be in a multicall
context.method = None
self.check_session()
self.enforce_lockout()
return kojihub.handle_upload(environ)
def handle_rpc(self, environ):
params, method = self._read_request(environ['wsgi.input'])
return self._dispatch(method, params)
def check_session(self):
def test_overflow(self):
value = (2**64,)
with self.assertRaises(OverflowError):
xmlrpcplus.dumps(value)
def test_overflow(self):
value = (2**64, )
with self.assertRaises(OverflowError):
xmlrpcplus.dumps(value)
