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_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 _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_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)