def test_validateAndExecuteRequest(self):
'''Test a request for an existing service and method.'''
# Add a test service
service = self.registerTestService()
# Define an RPC request for an existing service and method
self.rpc_request.service_name = service.DESCRIPTOR.full_name
self.rpc_request.method_name = "TestMethod"
# Serialize the request
(bytestream, sock) = self.serializeRpcRequestToSocket()
# Construct the expected response from the service
expected_response = test_pb2.Response()
expected_response.str_data = service.response_str_data
expected_response.int_data = service.response_int_data
serialized_payload = expected_response.SerializeToString()
expected_rpc = rpc_pb2.Response()
expected_rpc.callback = True
expected_rpc.response_proto = serialized_payload
# Run the method on the server
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr, self.testserver)
received_rpc = handler.validateAndExecuteRequest(bytestream)
# Check the response message error code
self.assertEqual(received_rpc, expected_rpc, 'Normal response')
def test_retrieveProtoRequest(self):
'''Test normal return from retrieveMethod.'''
# Protocol message
expected_str_data = self.service_request.str_data
# Add a test service
expected_service = self.registerTestService()
expected_method = expected_service.DESCRIPTOR.FindMethodByName(
"TestMethod")
# Define an RPC request for an existing service and method
self.rpc_request.service_name = expected_service.DESCRIPTOR.full_name
self.rpc_request.method_name = "TestMethod"
# Serialize the request and create the socket handler
(bytestream, sock) = self.serializeRpcRequestToSocket()
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr, self.testserver)
proto_request = handler.retrieveProtoRequest(
expected_service, expected_method, self.rpc_request)
self.assertEqual(proto_request.str_data, expected_str_data,
'Normal response')
def test_retrieveProtoRequest_BAD_REQUEST_PROTO(self):
'''Test exceptional return from retrieveProtoRequest.'''
# Protocol message
expected_str_data = self.service_request.str_data
# Add a test service
expected_service = self.registerTestService()
expected_method = expected_service.DESCRIPTOR.FindMethodByName(
"TestMethod")
# Define an RPC request for an existing service and method
self.rpc_request.service_name = expected_service.DESCRIPTOR.full_name
self.rpc_request.method_name = "TestMethod"
# Serialize the request and create the socket handler
(bytestream, sock) = self.serializeRpcRequestToSocket()
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr, self.testserver)
# Force a bad protocol message
self.rpc_request.request_proto = "Bad protocol message"
# Run the method
self.assertRaises(error.BadRequestProtoError,
handler.retrieveProtoRequest,
expected_service, expected_method, self.rpc_request)
def test_callMethod(self):
''' Test normal return for callMethod '''
# Get the service and method
service = self.registerTestService()
method = service.DESCRIPTOR.FindMethodByName("TestMethod")
# Define an RPC request for an existing service and method
self.rpc_request.service_name = service.DESCRIPTOR.full_name
self.rpc_request.method_name = "TestMethod"
# Serialize the request
(bytestream, sock) = self.serializeRpcRequestToSocket()
# Construct the expected response from the service
expected_response = test_pb2.Response()
expected_response.str_data = service.response_str_data
expected_response.int_data = service.response_int_data
serialized_payload = expected_response.SerializeToString()
# Wrap the expected response in an RPC Response message
expected_rpc = rpc_pb2.Response()
expected_rpc.callback = True
expected_rpc.response_proto = serialized_payload
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr,
self.testserver)
response = handler.callMethod(service, method, self.service_request)
self.assertEquals(response, expected_rpc, 'Normal response')
def test_parseServiceRequest_junk_input(self):
'''Test the correct error is raised after sending complete crap.'''
# Bind an arbitrary bytestream to the socket
bytestream = 'ABCD'
socket_factory = FakeSocketFactory()
sock = socket_factory.createSocket()
# Test the server handler raises the BAD_REQUEST_DATA error code
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr, self.testserver)
self.assertRaises(error.BadRequestDataError,
handler.parseServiceRequest, bytestream)
def test_parseServiceRequest(self):
'''Test normal return from parseServiceRequest.'''
# Define the required fields of the RPC request
self.rpc_request.service_name = 'service_full_name'
self.rpc_request.method_name = 'method_name'
# Serialize the request
(bytestream, sock) = self.serializeRpcRequestToSocket()
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr, self.testserver)
self.assertEqual(handler.parseServiceRequest(bytestream),
self.rpc_request, "Parsing request - normal return")
def test_parseServiceRequest_BAD_REQUEST_DATA(self):
'''
Test the correct error is raised after sending an invalid
request.
'''
# Define an invalid RPC request (missing required service name)
self.rpc_request.method_name = 'method_name'
# Serialize the request (without checking initialisation status)
(bytestream, sock) = self.serializeRpcRequestToSocket(partial=True)
# Test the server handler raises the BAD_REQUEST_DATA error code
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr, self.testserver)
self.assertRaises(error.BadRequestDataError,
handler.parseServiceRequest, bytestream)
def test_validateAndExecuteRequest_SERVICE_NOT_FOUND(self):
'''Test a request for a non-existent service.'''
# Define an RPC request for a non-existent service
self.rpc_request.service_name = "Non-existent service"
self.rpc_request.method_name = "Dummy method"
# Serialize the request
(bytestream, sock) = self.serializeRpcRequestToSocket()
# Run the method on the server
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr, self.testserver)
response = handler.validateAndExecuteRequest(bytestream)
# Check the response message error code
self.assertEqual(response.error_reason, rpc_pb2.SERVICE_NOT_FOUND,
'Unexpected error code')
def test_retrieveService_SERVICE_NOT_FOUND(self):
'''Test exceptional return from retrieveService.'''
# Add a test service
expected_service = self.registerTestService()
# Define an RPC request for a non-existent service and method
self.rpc_request.service_name = "Non-existent service"
self.rpc_request.method_name = "Dummy method"
# Serialize the request and create the socket handler
(bytestream, sock) = self.serializeRpcRequestToSocket()
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr, self.testserver)
# Run the method on the server
self.assertRaises(error.ServiceNotFoundError, handler.retrieveService,
self.rpc_request.service_name)
def test_retrieveService(self):
'''Test normal return from retrieveService.'''
# Add a test service
expected_service = self.registerTestService()
# Define an RPC request for an existing service and method
self.rpc_request.service_name = expected_service.DESCRIPTOR.full_name
self.rpc_request.method_name = "TestMethod"
# Serialize the request and create the socket handler
(bytestream, sock) = self.serializeRpcRequestToSocket()
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr, self.testserver)
# Run the method on the server
received_service = handler.retrieveService(
self.rpc_request.service_name)
self.assertEqual(received_service, expected_service, 'Service found')
def test_retrieveMethod_METHOD_NOT_FOUND(self):
'''Test exceptional return from retrieveMethod.'''
# Add a test service
expected_service = self.registerTestService()
expected_method = expected_service.DESCRIPTOR.FindMethodByName(
"TestMethod")
# Define an RPC request for an existing service and method
self.rpc_request.service_name = expected_service.DESCRIPTOR.full_name
self.rpc_request.method_name = "Non-existent method"
# Serialize the request and create the socket handler
(bytestream, sock) = self.serializeRpcRequestToSocket()
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr, self.testserver)
# Run the method on the server
self.assertRaises(error.MethodNotFoundError, handler.retrieveMethod,
expected_service, self.rpc_request.method_name)
def test_validateAndExecuteRequest_METHOD_NOT_FOUND(self):
'''Test a request for a non-existent method.'''
# Add a test service
service = self.registerTestService()
# Define an RPC request for an existing service but non-existent method
self.rpc_request.service_name = service.DESCRIPTOR.full_name
self.rpc_request.method_name = 'Dummy method'
# Serialize the request
(bytestream, sock) = self.serializeRpcRequestToSocket()
# Run the method on the server
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr, self.testserver)
response = handler.validateAndExecuteRequest(bytestream)
# Check the response message error code
self.assertEqual(response.error_reason, rpc_pb2.METHOD_NOT_FOUND,
'Unexpected error code')
def test_callMethod_RPC_ERROR(self):
'''Test for RPCERROR state.'''
# Get the service and method
exception = Exception('An exception has been raised')
service = self.registerTestService(exception)
method = service.DESCRIPTOR.FindMethodByName("TestMethod")
# Define an RPC request for an existing service and method
self.rpc_request.service_name = service.DESCRIPTOR.full_name
self.rpc_request.method_name = "TestMethod"
# Serialize the request
(bytestream, sock) = self.serializeRpcRequestToSocket()
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr,
self.testserver)
self.assertRaises(
error.RpcError, handler.callMethod, service, method,
self.service_request)
def test_callMethod_RPC_FAILED(self):
'''Test for RPCFAILED state.'''
# Get the service and method
failmsg = "User defined error"
service = self.registerTestService(None, failmsg)
method = service.DESCRIPTOR.FindMethodByName("TestMethod")
# Define an RPC request for an existing service and method
self.rpc_request.service_name = service.DESCRIPTOR.full_name
self.rpc_request.method_name = "TestMethod"
# Serialize the request
(bytestream, sock) = self.serializeRpcRequestToSocket()
handler = server.SocketHandler(sock, self.client_addr,
self.server_addr,
self.testserver)
response = handler.callMethod(service, method, self.service_request)
self.assertEquals(response.error_reason, rpc_pb2.RPC_FAILED,
'RPC_FAILED - error code')
self.assertEquals(response.error, failmsg, 'RPC_FAILED - messsage')
