def testAbortedStreamUnary(self): test_cases = zip(_ABORT_CODES, _EXPECTED_CLIENT_CODES, _EXPECTED_DETAILS) for abort_code, expected_code, expected_details in test_cases: self._servicer.set_code(abort_code) self._servicer.set_details(_DETAILS) self._servicer.set_abort_call() with self.assertRaises(grpc.RpcError) as exception_context: self._stream_unary.with_call(iter( [_SERIALIZED_REQUEST] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, exception_context.exception.initial_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, exception_context.exception.trailing_metadata())) self.assertIs(expected_code, exception_context.exception.code()) self.assertEqual(expected_details, exception_context.exception.details())
def testAbortedStreamStream(self): test_cases = zip(_ABORT_CODES, _EXPECTED_CLIENT_CODES, _EXPECTED_DETAILS) for abort_code, expected_code, expected_details in test_cases: self._servicer.set_code(abort_code) self._servicer.set_details(_DETAILS) self._servicer.set_abort_call() response_iterator_call = self._stream_stream( iter([object()] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) received_initial_metadata = \ response_iterator_call.initial_metadata() with self.assertRaises(grpc.RpcError): self.assertEqual(len(list(response_iterator_call)), 0) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, response_iterator_call.trailing_metadata())) self.assertIs(expected_code, response_iterator_call.code()) self.assertEqual(expected_details, response_iterator_call.details())
def testAbortedStreamUnary(self): test_cases = zip(_ABORT_CODES, _EXPECTED_CLIENT_CODES, _EXPECTED_DETAILS) for abort_code, expected_code, expected_details in test_cases: self._servicer.set_code(abort_code) self._servicer.set_details(_DETAILS) self._servicer.set_abort_call() with self.assertRaises(grpc.RpcError) as exception_context: self._stream_unary.with_call( iter([_SERIALIZED_REQUEST] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, exception_context.exception.initial_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, exception_context.exception.trailing_metadata())) self.assertIs(expected_code, exception_context.exception.code()) self.assertEqual(expected_details, exception_context.exception.details())
def testUnaryUnary(self): multi_callable = self._channel.unary_unary(_UNARY_UNARY) unused_response, call = multi_callable.with_call( _REQUEST, metadata=_CLIENT_METADATA) self.assertTrue(test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, call.initial_metadata())) self.assertTrue(test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, call.trailing_metadata()))
def testStreamUnary(self): multi_callable = self._channel.stream_unary(_STREAM_UNARY) unused_response, call = multi_callable.with_call( [_REQUEST] * test_constants.STREAM_LENGTH, metadata=_CLIENT_METADATA) self.assertTrue(test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, call.initial_metadata())) self.assertTrue(test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, call.trailing_metadata()))
def testUnaryStream(self): multi_callable = self._channel.unary_stream(_UNARY_STREAM) call = multi_callable(_REQUEST, metadata=_CLIENT_METADATA) self.assertTrue(test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, call.initial_metadata())) for _ in call: pass self.assertTrue(test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, call.trailing_metadata()))
def testStreamStream(self): multi_callable = self._channel.stream_stream(_STREAM_STREAM) call = multi_callable([_REQUEST] * test_constants.STREAM_LENGTH, metadata=_CLIENT_METADATA) self.assertTrue(test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, call.initial_metadata())) for _ in call: pass self.assertTrue(test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, call.trailing_metadata()))
def testUnaryStream(self): multi_callable = self._channel.unary_stream(_UNARY_STREAM) call = multi_callable(_REQUEST, metadata=_INVOCATION_METADATA) # TODO(https://github.com/grpc/grpc/issues/20762): Make the call to # `next()` unnecessary. next(call) self.assertTrue( test_common.metadata_transmitted(_EXPECTED_INITIAL_METADATA, call.initial_metadata())) for _ in call: pass self.assertTrue( test_common.metadata_transmitted(_EXPECTED_TRAILING_METADATA, call.trailing_metadata()))
def assertMetadataTransmitted(self, original_metadata, transmitted_metadata): self.assertTrue( test_common.metadata_transmitted(original_metadata, transmitted_metadata), '%s erroneously transmitted as %s' % (original_metadata, transmitted_metadata))
def validate_client_metadata(test, servicer_context): test.assertTrue(test_common.metadata_transmitted( _CLIENT_METADATA, servicer_context.invocation_metadata())) test.assertTrue(user_agent(servicer_context.invocation_metadata()) .startswith('primary-agent ' + _USER_AGENT)) test.assertTrue(user_agent(servicer_context.invocation_metadata()) .endswith('secondary-agent'))
def testSuccessfulUnaryUnary(self): self._servicer.set_details(_DETAILS) unused_response, call = self._unary_unary.with_call( object(), metadata=_CLIENT_METADATA) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, call.initial_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_TRAILING_METADATA, call.trailing_metadata())) self.assertIs(grpc.StatusCode.OK, call.code())
def testSuccessfulUnaryUnary(self): self._servicer.set_details(_DETAILS) unused_response, call = self._unary_unary.with_call( object(), metadata=_CLIENT_METADATA) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, call.initial_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_TRAILING_METADATA, call.trailing_metadata())) self.assertIs(grpc.StatusCode.OK, call.code()) self.assertEqual(_DETAILS, call.details())
def testSuccessfulStreamUnary(self): self._servicer.set_details(_DETAILS) unused_response, call = self._stream_unary.with_call( iter([_SERIALIZED_REQUEST] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, call.initial_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_TRAILING_METADATA, call.trailing_metadata())) self.assertIs(grpc.StatusCode.OK, call.code())
def testSuccessfulStreamUnary(self): self._servicer.set_details(_DETAILS) unused_response, call = self._stream_unary.with_call( iter([_SERIALIZED_REQUEST] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, call.initial_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_TRAILING_METADATA, call.trailing_metadata())) self.assertIs(grpc.StatusCode.OK, call.code()) self.assertEqual(_DETAILS, call.details())
def validate_client_metadata(test, servicer_context): invocation_metadata = servicer_context.invocation_metadata() test.assertTrue( test_common.metadata_transmitted(_EXPECTED_INVOCATION_METADATA, invocation_metadata)) user_agent = _user_agent(invocation_metadata) test.assertTrue( user_agent.startswith('primary-agent ' + _channel._USER_AGENT)) test.assertTrue(user_agent.endswith('secondary-agent'))
def testSuccessfulUnaryStream(self): self._servicer.set_details(_DETAILS) response_iterator_call = self._unary_stream(_SERIALIZED_REQUEST, metadata=_CLIENT_METADATA) received_initial_metadata = response_iterator_call.initial_metadata() list(response_iterator_call) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, response_iterator_call.trailing_metadata())) self.assertIs(grpc.StatusCode.OK, response_iterator_call.code())
def testSuccessfulUnaryStream(self): self._servicer.set_details(_DETAILS) call = self._unary_stream(_SERIALIZED_REQUEST, metadata=_CLIENT_METADATA) received_initial_metadata = call.initial_metadata() for _ in call: pass self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, call.trailing_metadata())) self.assertIs(grpc.StatusCode.OK, call.code()) self.assertEqual(_DETAILS, call.details())
def testCustomCodeUnaryUnary(self): self._servicer.set_code(_NON_OK_CODE) self._servicer.set_details(_DETAILS) with self.assertRaises(grpc.RpcError) as exception_context: self._unary_unary.with_call(object(), metadata=_CLIENT_METADATA) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, exception_context.exception.initial_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, exception_context.exception.trailing_metadata())) self.assertIs(_NON_OK_CODE, exception_context.exception.code()) self.assertEqual(_DETAILS, exception_context.exception.details())
def testSuccessfulStreamStream(self): self._servicer.set_details(_DETAILS) response_iterator_call = self._stream_stream(iter( [object()] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) received_initial_metadata = response_iterator_call.initial_metadata() list(response_iterator_call) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, response_iterator_call.trailing_metadata())) self.assertIs(grpc.StatusCode.OK, response_iterator_call.code())
def testCustomCodeUnaryStream(self): self._servicer.set_code(_NON_OK_CODE) self._servicer.set_details(_DETAILS) call = self._unary_stream(_SERIALIZED_REQUEST, metadata=_CLIENT_METADATA) received_initial_metadata = call.initial_metadata() with self.assertRaises(grpc.RpcError): for _ in call: pass self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, call.trailing_metadata())) self.assertIs(_NON_OK_CODE, call.code()) self.assertEqual(_DETAILS, call.details())
def testSuccessfulStreamStream(self): self._servicer.set_details(_DETAILS) response_iterator_call = self._stream_stream( iter([object()] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) received_initial_metadata = response_iterator_call.initial_metadata() list(response_iterator_call) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, response_iterator_call.trailing_metadata())) self.assertIs(grpc.StatusCode.OK, response_iterator_call.code()) self.assertEqual(_DETAILS, response_iterator_call.details())
def completion_transmitted(self, original_completion, transmitted_completion): if (original_completion.terminal_metadata is not None and not grpc_test_common.metadata_transmitted( original_completion.terminal_metadata, transmitted_completion.terminal_metadata)): return False elif original_completion.code is not transmitted_completion.code: return False elif original_completion.message != transmitted_completion.message: return False else: return True
def testCustomCodeStreamUnary(self): self._servicer.set_code(_NON_OK_CODE) self._servicer.set_details(_DETAILS) with self.assertRaises(grpc.RpcError) as exception_context: self._stream_unary.with_call(iter([_SERIALIZED_REQUEST] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, exception_context.exception.initial_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, exception_context.exception.trailing_metadata())) self.assertIs(_NON_OK_CODE, exception_context.exception.code()) self.assertEqual(_DETAILS, exception_context.exception.details())
def testCustomCodeStreamUnary(self): self._servicer.set_code(_NON_OK_CODE) self._servicer.set_details(_DETAILS) with self.assertRaises(grpc.RpcError) as exception_context: self._stream_unary.with_call( iter([_SERIALIZED_REQUEST] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, exception_context.exception.initial_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, exception_context.exception.trailing_metadata())) self.assertIs(_NON_OK_CODE, exception_context.exception.code()) self.assertEqual(_DETAILS, exception_context.exception.details())
def testAbortedUnaryStream(self): self._servicer.set_code(_NON_OK_CODE) self._servicer.set_details(_DETAILS) self._servicer.set_abort_call() response_iterator_call = self._unary_stream(_SERIALIZED_REQUEST, metadata=_CLIENT_METADATA) received_initial_metadata = response_iterator_call.initial_metadata() with self.assertRaises(grpc.RpcError): self.assertEqual(len(list(response_iterator_call)), 0) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, response_iterator_call.trailing_metadata())) self.assertIs(_NON_OK_CODE, response_iterator_call.code()) self.assertEqual(_DETAILS, response_iterator_call.details())
def testAbortedUnaryStream(self): self._servicer.set_code(_NON_OK_CODE) self._servicer.set_details(_DETAILS) self._servicer.set_abort_call() response_iterator_call = self._unary_stream( _SERIALIZED_REQUEST, metadata=_CLIENT_METADATA) received_initial_metadata = response_iterator_call.initial_metadata() with self.assertRaises(grpc.RpcError): self.assertEqual(len(list(response_iterator_call)), 0) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, response_iterator_call.trailing_metadata())) self.assertIs(_NON_OK_CODE, response_iterator_call.code()) self.assertEqual(_DETAILS, response_iterator_call.details())
def testCustomCodeStreamStream(self): self._servicer.set_code(_NON_OK_CODE) self._servicer.set_details(_DETAILS) response_iterator_call = self._stream_stream( iter([object()] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) received_initial_metadata = response_iterator_call.initial_metadata() with self.assertRaises(grpc.RpcError) as exception_context: list(response_iterator_call) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, exception_context.exception.trailing_metadata())) self.assertIs(_NON_OK_CODE, exception_context.exception.code()) self.assertEqual(_DETAILS, exception_context.exception.details())
def testCustomCodeStreamStream(self): self._servicer.set_code(_NON_OK_CODE) self._servicer.set_details(_DETAILS) response_iterator_call = self._stream_stream(iter( [object()] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) received_initial_metadata = response_iterator_call.initial_metadata() with self.assertRaises(grpc.RpcError) as exception_context: list(response_iterator_call) self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, exception_context.exception.trailing_metadata())) self.assertIs(_NON_OK_CODE, exception_context.exception.code()) self.assertEqual(_DETAILS, exception_context.exception.details())
def testCustomCodeExceptionStreamStream(self): self._servicer.set_code(_NON_OK_CODE) self._servicer.set_details(_DETAILS) self._servicer.set_exception() call = self._stream_stream( iter([object()] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) received_initial_metadata = call.initial_metadata() with self.assertRaises(grpc.RpcError): for _ in call: pass self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted( _SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted( _SERVER_TRAILING_METADATA, call.trailing_metadata())) self.assertIs(_NON_OK_CODE, call.code()) self.assertEqual(_DETAILS, call.details())
def testCustomCodeExceptionStreamStream(self): self._servicer.set_code(_NON_OK_CODE) self._servicer.set_details(_DETAILS) self._servicer.set_exception() call = self._stream_stream(iter([object()] * test_constants.STREAM_LENGTH), metadata=_CLIENT_METADATA) received_initial_metadata = call.initial_metadata() with self.assertRaises(grpc.RpcError): for _ in call: pass self.assertTrue( test_common.metadata_transmitted( _CLIENT_METADATA, self._servicer.received_client_metadata())) self.assertTrue( test_common.metadata_transmitted(_SERVER_INITIAL_METADATA, received_initial_metadata)) self.assertTrue( test_common.metadata_transmitted(_SERVER_TRAILING_METADATA, call.trailing_metadata())) self.assertIs(_NON_OK_CODE, call.code()) self.assertEqual(_DETAILS, call.details())
def testEcho(self): deadline = time.time() + 5 event_time_tolerance = 2 deadline_tolerance = 0.25 client_metadata_ascii_key = 'key' client_metadata_ascii_value = 'val' client_metadata_bin_key = 'key-bin' client_metadata_bin_value = b'\0' * 1000 server_initial_metadata_key = 'init_me_me_me' server_initial_metadata_value = 'whodawha?' server_trailing_metadata_key = 'california_is_in_a_drought' server_trailing_metadata_value = 'zomg it is' server_status_code = _types.StatusCode.OK server_status_details = 'our work is never over' request = 'blarghaflargh' response = 'his name is robert paulson' method = 'twinkies' host = 'hostess' server_request_tag = object() request_call_result = self.server.request_call( self.server_completion_queue, server_request_tag) self.assertEqual(_types.CallError.OK, request_call_result) client_call_tag = object() client_call = self.client_channel.create_call( self.client_completion_queue, method, host, deadline) client_initial_metadata = [ (client_metadata_ascii_key, client_metadata_ascii_value), (client_metadata_bin_key, client_metadata_bin_value) ] client_start_batch_result = client_call.start_batch([ _types.OpArgs.send_initial_metadata(client_initial_metadata), _types.OpArgs.send_message(request, 0), _types.OpArgs.send_close_from_client(), _types.OpArgs.recv_initial_metadata(), _types.OpArgs.recv_message(), _types.OpArgs.recv_status_on_client() ], client_call_tag) self.assertEqual(_types.CallError.OK, client_start_batch_result) client_no_event, request_event, = wait_for_events( [self.client_completion_queue, self.server_completion_queue], time.time() + event_time_tolerance) self.assertEqual(client_no_event, None) self.assertEqual(_types.EventType.OP_COMPLETE, request_event.type) self.assertIsInstance(request_event.call, _low.Call) self.assertIs(server_request_tag, request_event.tag) self.assertEqual(1, len(request_event.results)) received_initial_metadata = request_event.results[0].initial_metadata # Check that our metadata were transmitted self.assertTrue( test_common.metadata_transmitted(client_initial_metadata, received_initial_metadata)) # Check that Python's user agent string is a part of the full user agent # string received_initial_metadata_dict = dict(received_initial_metadata) self.assertIn(b'user-agent', received_initial_metadata_dict) self.assertIn( 'Python-gRPC-{}'.format(_grpcio_metadata.__version__).encode(), received_initial_metadata_dict[b'user-agent']) self.assertEqual(method.encode(), request_event.call_details.method) self.assertEqual(host.encode(), request_event.call_details.host) self.assertLess(abs(deadline - request_event.call_details.deadline), deadline_tolerance) # Check that the channel is connected, and that both it and the call have # the proper target and peer; do this after the first flurry of messages to # avoid the possibility that connection was delayed by the core until the # first message was sent. self.assertEqual(_types.ConnectivityState.READY, self.client_channel.check_connectivity_state(False)) self.assertIsNotNone(self.client_channel.target()) self.assertIsNotNone(client_call.peer()) server_call_tag = object() server_call = request_event.call server_initial_metadata = [(server_initial_metadata_key, server_initial_metadata_value)] server_trailing_metadata = [(server_trailing_metadata_key, server_trailing_metadata_value)] server_start_batch_result = server_call.start_batch([ _types.OpArgs.send_initial_metadata(server_initial_metadata), _types.OpArgs.recv_message(), _types.OpArgs.send_message(response, 0), _types.OpArgs.recv_close_on_server(), _types.OpArgs.send_status_from_server(server_trailing_metadata, server_status_code, server_status_details) ], server_call_tag) self.assertEqual(_types.CallError.OK, server_start_batch_result) client_event, server_event, = wait_for_events( [self.client_completion_queue, self.server_completion_queue], time.time() + event_time_tolerance) self.assertEqual(6, len(client_event.results)) found_client_op_types = set() for client_result in client_event.results: # we expect each op type to be unique self.assertNotIn(client_result.type, found_client_op_types) found_client_op_types.add(client_result.type) if client_result.type == _types.OpType.RECV_INITIAL_METADATA: self.assertTrue( test_common.metadata_transmitted( server_initial_metadata, client_result.initial_metadata)) elif client_result.type == _types.OpType.RECV_MESSAGE: self.assertEqual(response.encode(), client_result.message) elif client_result.type == _types.OpType.RECV_STATUS_ON_CLIENT: self.assertTrue( test_common.metadata_transmitted( server_trailing_metadata, client_result.trailing_metadata)) self.assertEqual(server_status_details.encode(), client_result.status.details) self.assertEqual(server_status_code, client_result.status.code) self.assertEqual( set([ _types.OpType.SEND_INITIAL_METADATA, _types.OpType.SEND_MESSAGE, _types.OpType.SEND_CLOSE_FROM_CLIENT, _types.OpType.RECV_INITIAL_METADATA, _types.OpType.RECV_MESSAGE, _types.OpType.RECV_STATUS_ON_CLIENT ]), found_client_op_types) self.assertEqual(5, len(server_event.results)) found_server_op_types = set() for server_result in server_event.results: self.assertNotIn(client_result.type, found_server_op_types) found_server_op_types.add(server_result.type) if server_result.type == _types.OpType.RECV_MESSAGE: self.assertEqual(request.encode(), server_result.message) elif server_result.type == _types.OpType.RECV_CLOSE_ON_SERVER: self.assertFalse(server_result.cancelled) self.assertEqual( set([ _types.OpType.SEND_INITIAL_METADATA, _types.OpType.RECV_MESSAGE, _types.OpType.SEND_MESSAGE, _types.OpType.RECV_CLOSE_ON_SERVER, _types.OpType.SEND_STATUS_FROM_SERVER ]), found_server_op_types) del client_call del server_call
def testEcho(self): DEADLINE = time.time() + 5 DEADLINE_TOLERANCE = 0.25 CLIENT_METADATA_ASCII_KEY = b'key' CLIENT_METADATA_ASCII_VALUE = b'val' CLIENT_METADATA_BIN_KEY = b'key-bin' CLIENT_METADATA_BIN_VALUE = b'\0' * 1000 SERVER_INITIAL_METADATA_KEY = b'init_me_me_me' SERVER_INITIAL_METADATA_VALUE = b'whodawha?' SERVER_TRAILING_METADATA_KEY = b'california_is_in_a_drought' SERVER_TRAILING_METADATA_VALUE = b'zomg it is' SERVER_STATUS_CODE = cygrpc.StatusCode.ok SERVER_STATUS_DETAILS = b'our work is never over' REQUEST = b'in death a member of project mayhem has a name' RESPONSE = b'his name is robert paulson' METHOD = b'twinkies' cygrpc_deadline = cygrpc.Timespec(DEADLINE) server_request_tag = object() request_call_result = self.server.request_call( self.server_completion_queue, self.server_completion_queue, server_request_tag) self.assertEqual(cygrpc.CallError.ok, request_call_result) client_call_tag = object() client_call = self.client_channel.create_call( None, 0, self.client_completion_queue, METHOD, self.host_argument, cygrpc_deadline) client_initial_metadata = cygrpc.Metadata([ cygrpc.Metadatum(CLIENT_METADATA_ASCII_KEY, CLIENT_METADATA_ASCII_VALUE), cygrpc.Metadatum(CLIENT_METADATA_BIN_KEY, CLIENT_METADATA_BIN_VALUE) ]) client_start_batch_result = client_call.start_client_batch([ cygrpc.operation_send_initial_metadata(client_initial_metadata, _EMPTY_FLAGS), cygrpc.operation_send_message(REQUEST, _EMPTY_FLAGS), cygrpc.operation_send_close_from_client(_EMPTY_FLAGS), cygrpc.operation_receive_initial_metadata(_EMPTY_FLAGS), cygrpc.operation_receive_message(_EMPTY_FLAGS), cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS) ], client_call_tag) self.assertEqual(cygrpc.CallError.ok, client_start_batch_result) client_event_future = test_utilities.CompletionQueuePollFuture( self.client_completion_queue, cygrpc_deadline) request_event = self.server_completion_queue.poll(cygrpc_deadline) self.assertEqual(cygrpc.CompletionType.operation_complete, request_event.type) self.assertIsInstance(request_event.operation_call, cygrpc.Call) self.assertIs(server_request_tag, request_event.tag) self.assertEqual(0, len(request_event.batch_operations)) self.assertTrue( test_common.metadata_transmitted(client_initial_metadata, request_event.request_metadata)) self.assertEqual(METHOD, request_event.request_call_details.method) self.assertEqual(self.expected_host, request_event.request_call_details.host) self.assertLess( abs(DEADLINE - float(request_event.request_call_details.deadline)), DEADLINE_TOLERANCE) server_call_tag = object() server_call = request_event.operation_call server_initial_metadata = cygrpc.Metadata([ cygrpc.Metadatum(SERVER_INITIAL_METADATA_KEY, SERVER_INITIAL_METADATA_VALUE) ]) server_trailing_metadata = cygrpc.Metadata([ cygrpc.Metadatum(SERVER_TRAILING_METADATA_KEY, SERVER_TRAILING_METADATA_VALUE) ]) server_start_batch_result = server_call.start_server_batch([ cygrpc.operation_send_initial_metadata( server_initial_metadata, _EMPTY_FLAGS), cygrpc.operation_receive_message(_EMPTY_FLAGS), cygrpc.operation_send_message(RESPONSE, _EMPTY_FLAGS), cygrpc.operation_receive_close_on_server(_EMPTY_FLAGS), cygrpc.operation_send_status_from_server( server_trailing_metadata, SERVER_STATUS_CODE, SERVER_STATUS_DETAILS, _EMPTY_FLAGS) ], server_call_tag) self.assertEqual(cygrpc.CallError.ok, server_start_batch_result) server_event = self.server_completion_queue.poll(cygrpc_deadline) client_event = client_event_future.result() self.assertEqual(6, len(client_event.batch_operations)) found_client_op_types = set() for client_result in client_event.batch_operations: # we expect each op type to be unique self.assertNotIn(client_result.type, found_client_op_types) found_client_op_types.add(client_result.type) if client_result.type == cygrpc.OperationType.receive_initial_metadata: self.assertTrue( test_common.metadata_transmitted( server_initial_metadata, client_result.received_metadata)) elif client_result.type == cygrpc.OperationType.receive_message: self.assertEqual(RESPONSE, client_result.received_message.bytes()) elif client_result.type == cygrpc.OperationType.receive_status_on_client: self.assertTrue( test_common.metadata_transmitted( server_trailing_metadata, client_result.received_metadata)) self.assertEqual(SERVER_STATUS_DETAILS, client_result.received_status_details) self.assertEqual(SERVER_STATUS_CODE, client_result.received_status_code) self.assertEqual( set([ cygrpc.OperationType.send_initial_metadata, cygrpc.OperationType.send_message, cygrpc.OperationType.send_close_from_client, cygrpc.OperationType.receive_initial_metadata, cygrpc.OperationType.receive_message, cygrpc.OperationType.receive_status_on_client ]), found_client_op_types) self.assertEqual(5, len(server_event.batch_operations)) found_server_op_types = set() for server_result in server_event.batch_operations: self.assertNotIn(client_result.type, found_server_op_types) found_server_op_types.add(server_result.type) if server_result.type == cygrpc.OperationType.receive_message: self.assertEqual(REQUEST, server_result.received_message.bytes()) elif server_result.type == cygrpc.OperationType.receive_close_on_server: self.assertFalse(server_result.received_cancelled) self.assertEqual( set([ cygrpc.OperationType.send_initial_metadata, cygrpc.OperationType.receive_message, cygrpc.OperationType.send_message, cygrpc.OperationType.receive_close_on_server, cygrpc.OperationType.send_status_from_server ]), found_server_op_types) del client_call del server_call
def metadata_transmitted(self, original_metadata, transmitted_metadata): return original_metadata is None or grpc_test_common.metadata_transmitted( original_metadata, transmitted_metadata)
def test_echo(self): DEADLINE = time.time() + 5 DEADLINE_TOLERANCE = 0.25 CLIENT_METADATA_ASCII_KEY = 'key' CLIENT_METADATA_ASCII_VALUE = 'val' CLIENT_METADATA_BIN_KEY = 'key-bin' CLIENT_METADATA_BIN_VALUE = b'\0' * 1000 SERVER_INITIAL_METADATA_KEY = 'init_me_me_me' SERVER_INITIAL_METADATA_VALUE = 'whodawha?' SERVER_TRAILING_METADATA_KEY = 'california_is_in_a_drought' SERVER_TRAILING_METADATA_VALUE = 'zomg it is' SERVER_STATUS_CODE = cygrpc.StatusCode.ok SERVER_STATUS_DETAILS = 'our work is never over' REQUEST = b'in death a member of project mayhem has a name' RESPONSE = b'his name is robert paulson' METHOD = b'twinkies' server_request_tag = object() request_call_result = self.server.request_call( self.server_completion_queue, self.server_completion_queue, server_request_tag) self.assertEqual(cygrpc.CallError.ok, request_call_result) client_call_tag = object() client_initial_metadata = ( ( CLIENT_METADATA_ASCII_KEY, CLIENT_METADATA_ASCII_VALUE, ), ( CLIENT_METADATA_BIN_KEY, CLIENT_METADATA_BIN_VALUE, ), ) client_call = self.client_channel.integrated_call( 0, METHOD, self.host_argument, DEADLINE, client_initial_metadata, None, [ ( [ cygrpc.SendInitialMetadataOperation( client_initial_metadata, _EMPTY_FLAGS), cygrpc.SendMessageOperation(REQUEST, _EMPTY_FLAGS), cygrpc.SendCloseFromClientOperation(_EMPTY_FLAGS), cygrpc.ReceiveInitialMetadataOperation(_EMPTY_FLAGS), cygrpc.ReceiveMessageOperation(_EMPTY_FLAGS), cygrpc.ReceiveStatusOnClientOperation(_EMPTY_FLAGS), ], client_call_tag, ), ]) client_event_future = test_utilities.SimpleFuture( self.client_channel.next_call_event) request_event = self.server_completion_queue.poll(deadline=DEADLINE) self.assertEqual(cygrpc.CompletionType.operation_complete, request_event.completion_type) self.assertIsInstance(request_event.call, cygrpc.Call) self.assertIs(server_request_tag, request_event.tag) self.assertTrue( test_common.metadata_transmitted( client_initial_metadata, request_event.invocation_metadata)) self.assertEqual(METHOD, request_event.call_details.method) self.assertEqual(self.expected_host, request_event.call_details.host) self.assertLess(abs(DEADLINE - request_event.call_details.deadline), DEADLINE_TOLERANCE) server_call_tag = object() server_call = request_event.call server_initial_metadata = (( SERVER_INITIAL_METADATA_KEY, SERVER_INITIAL_METADATA_VALUE, ), ) server_trailing_metadata = (( SERVER_TRAILING_METADATA_KEY, SERVER_TRAILING_METADATA_VALUE, ), ) server_start_batch_result = server_call.start_server_batch([ cygrpc.SendInitialMetadataOperation(server_initial_metadata, _EMPTY_FLAGS), cygrpc.ReceiveMessageOperation(_EMPTY_FLAGS), cygrpc.SendMessageOperation(RESPONSE, _EMPTY_FLAGS), cygrpc.ReceiveCloseOnServerOperation(_EMPTY_FLAGS), cygrpc.SendStatusFromServerOperation( server_trailing_metadata, SERVER_STATUS_CODE, SERVER_STATUS_DETAILS, _EMPTY_FLAGS) ], server_call_tag) self.assertEqual(cygrpc.CallError.ok, server_start_batch_result) server_event = self.server_completion_queue.poll(deadline=DEADLINE) client_event = client_event_future.result() self.assertEqual(6, len(client_event.batch_operations)) found_client_op_types = set() for client_result in client_event.batch_operations: # we expect each op type to be unique self.assertNotIn(client_result.type(), found_client_op_types) found_client_op_types.add(client_result.type()) if client_result.type( ) == cygrpc.OperationType.receive_initial_metadata: self.assertTrue( test_common.metadata_transmitted( server_initial_metadata, client_result.initial_metadata())) elif client_result.type() == cygrpc.OperationType.receive_message: self.assertEqual(RESPONSE, client_result.message()) elif client_result.type( ) == cygrpc.OperationType.receive_status_on_client: self.assertTrue( test_common.metadata_transmitted( server_trailing_metadata, client_result.trailing_metadata())) self.assertEqual(SERVER_STATUS_DETAILS, client_result.details()) self.assertEqual(SERVER_STATUS_CODE, client_result.code()) self.assertEqual( set([ cygrpc.OperationType.send_initial_metadata, cygrpc.OperationType.send_message, cygrpc.OperationType.send_close_from_client, cygrpc.OperationType.receive_initial_metadata, cygrpc.OperationType.receive_message, cygrpc.OperationType.receive_status_on_client ]), found_client_op_types) self.assertEqual(5, len(server_event.batch_operations)) found_server_op_types = set() for server_result in server_event.batch_operations: self.assertNotIn(server_result.type(), found_server_op_types) found_server_op_types.add(server_result.type()) if server_result.type() == cygrpc.OperationType.receive_message: self.assertEqual(REQUEST, server_result.message()) elif server_result.type( ) == cygrpc.OperationType.receive_close_on_server: self.assertFalse(server_result.cancelled()) self.assertEqual( set([ cygrpc.OperationType.send_initial_metadata, cygrpc.OperationType.receive_message, cygrpc.OperationType.send_message, cygrpc.OperationType.receive_close_on_server, cygrpc.OperationType.send_status_from_server ]), found_server_op_types) del client_call del server_call
def testEcho(self): deadline = time.time() + 5 event_time_tolerance = 2 deadline_tolerance = 0.25 client_metadata_ascii_key = 'key' client_metadata_ascii_value = 'val' client_metadata_bin_key = 'key-bin' client_metadata_bin_value = b'\0'*1000 server_initial_metadata_key = 'init_me_me_me' server_initial_metadata_value = 'whodawha?' server_trailing_metadata_key = 'california_is_in_a_drought' server_trailing_metadata_value = 'zomg it is' server_status_code = _types.StatusCode.OK server_status_details = 'our work is never over' request = 'blarghaflargh' response = 'his name is robert paulson' method = 'twinkies' host = 'hostess' server_request_tag = object() request_call_result = self.server.request_call(self.server_completion_queue, server_request_tag) self.assertEqual(_types.CallError.OK, request_call_result) client_call_tag = object() client_call = self.client_channel.create_call( self.client_completion_queue, method, host, deadline) client_initial_metadata = [ (client_metadata_ascii_key, client_metadata_ascii_value), (client_metadata_bin_key, client_metadata_bin_value) ] client_start_batch_result = client_call.start_batch([ _types.OpArgs.send_initial_metadata(client_initial_metadata), _types.OpArgs.send_message(request, 0), _types.OpArgs.send_close_from_client(), _types.OpArgs.recv_initial_metadata(), _types.OpArgs.recv_message(), _types.OpArgs.recv_status_on_client() ], client_call_tag) self.assertEqual(_types.CallError.OK, client_start_batch_result) client_no_event, request_event, = wait_for_events( [self.client_completion_queue, self.server_completion_queue], time.time() + event_time_tolerance) self.assertEqual(client_no_event, None) self.assertEqual(_types.EventType.OP_COMPLETE, request_event.type) self.assertIsInstance(request_event.call, _low.Call) self.assertIs(server_request_tag, request_event.tag) self.assertEqual(1, len(request_event.results)) received_initial_metadata = request_event.results[0].initial_metadata # Check that our metadata were transmitted self.assertTrue(test_common.metadata_transmitted(client_initial_metadata, received_initial_metadata)) # Check that Python's user agent string is a part of the full user agent # string received_initial_metadata_dict = dict(received_initial_metadata) self.assertIn('user-agent', received_initial_metadata_dict) self.assertIn('Python-gRPC-{}'.format(_grpcio_metadata.__version__), received_initial_metadata_dict['user-agent']) self.assertEqual(method, request_event.call_details.method) self.assertEqual(host, request_event.call_details.host) self.assertLess(abs(deadline - request_event.call_details.deadline), deadline_tolerance) # Check that the channel is connected, and that both it and the call have # the proper target and peer; do this after the first flurry of messages to # avoid the possibility that connection was delayed by the core until the # first message was sent. self.assertEqual(_types.ConnectivityState.READY, self.client_channel.check_connectivity_state(False)) self.assertIsNotNone(self.client_channel.target()) self.assertIsNotNone(client_call.peer()) server_call_tag = object() server_call = request_event.call server_initial_metadata = [ (server_initial_metadata_key, server_initial_metadata_value) ] server_trailing_metadata = [ (server_trailing_metadata_key, server_trailing_metadata_value) ] server_start_batch_result = server_call.start_batch([ _types.OpArgs.send_initial_metadata(server_initial_metadata), _types.OpArgs.recv_message(), _types.OpArgs.send_message(response, 0), _types.OpArgs.recv_close_on_server(), _types.OpArgs.send_status_from_server( server_trailing_metadata, server_status_code, server_status_details) ], server_call_tag) self.assertEqual(_types.CallError.OK, server_start_batch_result) client_event, server_event, = wait_for_events( [self.client_completion_queue, self.server_completion_queue], time.time() + event_time_tolerance) self.assertEqual(6, len(client_event.results)) found_client_op_types = set() for client_result in client_event.results: # we expect each op type to be unique self.assertNotIn(client_result.type, found_client_op_types) found_client_op_types.add(client_result.type) if client_result.type == _types.OpType.RECV_INITIAL_METADATA: self.assertTrue( test_common.metadata_transmitted(server_initial_metadata, client_result.initial_metadata)) elif client_result.type == _types.OpType.RECV_MESSAGE: self.assertEqual(response, client_result.message) elif client_result.type == _types.OpType.RECV_STATUS_ON_CLIENT: self.assertTrue( test_common.metadata_transmitted(server_trailing_metadata, client_result.trailing_metadata)) self.assertEqual(server_status_details, client_result.status.details) self.assertEqual(server_status_code, client_result.status.code) self.assertEqual(set([ _types.OpType.SEND_INITIAL_METADATA, _types.OpType.SEND_MESSAGE, _types.OpType.SEND_CLOSE_FROM_CLIENT, _types.OpType.RECV_INITIAL_METADATA, _types.OpType.RECV_MESSAGE, _types.OpType.RECV_STATUS_ON_CLIENT ]), found_client_op_types) self.assertEqual(5, len(server_event.results)) found_server_op_types = set() for server_result in server_event.results: self.assertNotIn(client_result.type, found_server_op_types) found_server_op_types.add(server_result.type) if server_result.type == _types.OpType.RECV_MESSAGE: self.assertEqual(request, server_result.message) elif server_result.type == _types.OpType.RECV_CLOSE_ON_SERVER: self.assertFalse(server_result.cancelled) self.assertEqual(set([ _types.OpType.SEND_INITIAL_METADATA, _types.OpType.RECV_MESSAGE, _types.OpType.SEND_MESSAGE, _types.OpType.RECV_CLOSE_ON_SERVER, _types.OpType.SEND_STATUS_FROM_SERVER ]), found_server_op_types) del client_call del server_call
def assertMetadataTransmitted(self, original_metadata, transmitted_metadata): self.assertTrue( test_common.metadata_transmitted( original_metadata, transmitted_metadata), '%s erroneously transmitted as %s' % ( original_metadata, transmitted_metadata))
def test_echo(self): DEADLINE = time.time() + 5 DEADLINE_TOLERANCE = 0.25 CLIENT_METADATA_ASCII_KEY = 'key' CLIENT_METADATA_ASCII_VALUE = 'val' CLIENT_METADATA_BIN_KEY = 'key-bin' CLIENT_METADATA_BIN_VALUE = b'\0' * 1000 SERVER_INITIAL_METADATA_KEY = 'init_me_me_me' SERVER_INITIAL_METADATA_VALUE = 'whodawha?' SERVER_TRAILING_METADATA_KEY = 'california_is_in_a_drought' SERVER_TRAILING_METADATA_VALUE = 'zomg it is' SERVER_STATUS_CODE = cygrpc.StatusCode.ok SERVER_STATUS_DETAILS = 'our work is never over' REQUEST = b'in death a member of project mayhem has a name' RESPONSE = b'his name is robert paulson' METHOD = b'twinkies' server_request_tag = object() request_call_result = self.server.request_call( self.server_completion_queue, self.server_completion_queue, server_request_tag) self.assertEqual(cygrpc.CallError.ok, request_call_result) client_call_tag = object() client_initial_metadata = ( ( CLIENT_METADATA_ASCII_KEY, CLIENT_METADATA_ASCII_VALUE, ), ( CLIENT_METADATA_BIN_KEY, CLIENT_METADATA_BIN_VALUE, ), ) client_call = self.client_channel.integrated_call( 0, METHOD, self.host_argument, DEADLINE, client_initial_metadata, None, [ ( [ cygrpc.SendInitialMetadataOperation( client_initial_metadata, _EMPTY_FLAGS), cygrpc.SendMessageOperation(REQUEST, _EMPTY_FLAGS), cygrpc.SendCloseFromClientOperation(_EMPTY_FLAGS), cygrpc.ReceiveInitialMetadataOperation(_EMPTY_FLAGS), cygrpc.ReceiveMessageOperation(_EMPTY_FLAGS), cygrpc.ReceiveStatusOnClientOperation(_EMPTY_FLAGS), ], client_call_tag, ), ]) client_event_future = test_utilities.SimpleFuture( self.client_channel.next_call_event) request_event = self.server_completion_queue.poll(deadline=DEADLINE) self.assertEqual(cygrpc.CompletionType.operation_complete, request_event.completion_type) self.assertIsInstance(request_event.call, cygrpc.Call) self.assertIs(server_request_tag, request_event.tag) self.assertTrue( test_common.metadata_transmitted(client_initial_metadata, request_event.invocation_metadata)) self.assertEqual(METHOD, request_event.call_details.method) self.assertEqual(self.expected_host, request_event.call_details.host) self.assertLess( abs(DEADLINE - request_event.call_details.deadline), DEADLINE_TOLERANCE) server_call_tag = object() server_call = request_event.call server_initial_metadata = (( SERVER_INITIAL_METADATA_KEY, SERVER_INITIAL_METADATA_VALUE, ),) server_trailing_metadata = (( SERVER_TRAILING_METADATA_KEY, SERVER_TRAILING_METADATA_VALUE, ),) server_start_batch_result = server_call.start_server_batch([ cygrpc.SendInitialMetadataOperation(server_initial_metadata, _EMPTY_FLAGS), cygrpc.ReceiveMessageOperation(_EMPTY_FLAGS), cygrpc.SendMessageOperation(RESPONSE, _EMPTY_FLAGS), cygrpc.ReceiveCloseOnServerOperation(_EMPTY_FLAGS), cygrpc.SendStatusFromServerOperation( server_trailing_metadata, SERVER_STATUS_CODE, SERVER_STATUS_DETAILS, _EMPTY_FLAGS) ], server_call_tag) self.assertEqual(cygrpc.CallError.ok, server_start_batch_result) server_event = self.server_completion_queue.poll(deadline=DEADLINE) client_event = client_event_future.result() self.assertEqual(6, len(client_event.batch_operations)) found_client_op_types = set() for client_result in client_event.batch_operations: # we expect each op type to be unique self.assertNotIn(client_result.type(), found_client_op_types) found_client_op_types.add(client_result.type()) if client_result.type( ) == cygrpc.OperationType.receive_initial_metadata: self.assertTrue( test_common.metadata_transmitted( server_initial_metadata, client_result.initial_metadata())) elif client_result.type() == cygrpc.OperationType.receive_message: self.assertEqual(RESPONSE, client_result.message()) elif client_result.type( ) == cygrpc.OperationType.receive_status_on_client: self.assertTrue( test_common.metadata_transmitted( server_trailing_metadata, client_result.trailing_metadata())) self.assertEqual(SERVER_STATUS_DETAILS, client_result.details()) self.assertEqual(SERVER_STATUS_CODE, client_result.code()) self.assertEqual( set([ cygrpc.OperationType.send_initial_metadata, cygrpc.OperationType.send_message, cygrpc.OperationType.send_close_from_client, cygrpc.OperationType.receive_initial_metadata, cygrpc.OperationType.receive_message, cygrpc.OperationType.receive_status_on_client ]), found_client_op_types) self.assertEqual(5, len(server_event.batch_operations)) found_server_op_types = set() for server_result in server_event.batch_operations: self.assertNotIn(server_result.type(), found_server_op_types) found_server_op_types.add(server_result.type()) if server_result.type() == cygrpc.OperationType.receive_message: self.assertEqual(REQUEST, server_result.message()) elif server_result.type( ) == cygrpc.OperationType.receive_close_on_server: self.assertFalse(server_result.cancelled()) self.assertEqual( set([ cygrpc.OperationType.send_initial_metadata, cygrpc.OperationType.receive_message, cygrpc.OperationType.send_message, cygrpc.OperationType.receive_close_on_server, cygrpc.OperationType.send_status_from_server ]), found_server_op_types) del client_call del server_call