|
|
|
@ -59,11 +59,12 @@ STUB_FACTORY_IDENTIFIER = 'beta_create_TestService_stub' |
|
|
|
|
|
|
|
|
|
|
|
class _ServicerMethods(object): |
|
|
|
class _ServicerMethods(object): |
|
|
|
|
|
|
|
|
|
|
|
def __init__(self, test_pb2): |
|
|
|
def __init__(self, response_pb2, payload_pb2): |
|
|
|
self._condition = threading.Condition() |
|
|
|
self._condition = threading.Condition() |
|
|
|
self._paused = False |
|
|
|
self._paused = False |
|
|
|
self._fail = False |
|
|
|
self._fail = False |
|
|
|
self._test_pb2 = test_pb2 |
|
|
|
self._response_pb2 = response_pb2 |
|
|
|
|
|
|
|
self._payload_pb2 = payload_pb2 |
|
|
|
|
|
|
|
|
|
|
|
@contextlib.contextmanager |
|
|
|
@contextlib.contextmanager |
|
|
|
def pause(self): # pylint: disable=invalid-name |
|
|
|
def pause(self): # pylint: disable=invalid-name |
|
|
|
@ -90,22 +91,22 @@ class _ServicerMethods(object): |
|
|
|
self._condition.wait() |
|
|
|
self._condition.wait() |
|
|
|
|
|
|
|
|
|
|
|
def UnaryCall(self, request, unused_rpc_context): |
|
|
|
def UnaryCall(self, request, unused_rpc_context): |
|
|
|
response = self._test_pb2.SimpleResponse() |
|
|
|
response = self._response_pb2.SimpleResponse() |
|
|
|
response.payload.payload_type = self._test_pb2.COMPRESSABLE |
|
|
|
response.payload.payload_type = self._payload_pb2.COMPRESSABLE |
|
|
|
response.payload.payload_compressable = 'a' * request.response_size |
|
|
|
response.payload.payload_compressable = 'a' * request.response_size |
|
|
|
self._control() |
|
|
|
self._control() |
|
|
|
return response |
|
|
|
return response |
|
|
|
|
|
|
|
|
|
|
|
def StreamingOutputCall(self, request, unused_rpc_context): |
|
|
|
def StreamingOutputCall(self, request, unused_rpc_context): |
|
|
|
for parameter in request.response_parameters: |
|
|
|
for parameter in request.response_parameters: |
|
|
|
response = self._test_pb2.StreamingOutputCallResponse() |
|
|
|
response = self._response_pb2.StreamingOutputCallResponse() |
|
|
|
response.payload.payload_type = self._test_pb2.COMPRESSABLE |
|
|
|
response.payload.payload_type = self._payload_pb2.COMPRESSABLE |
|
|
|
response.payload.payload_compressable = 'a' * parameter.size |
|
|
|
response.payload.payload_compressable = 'a' * parameter.size |
|
|
|
self._control() |
|
|
|
self._control() |
|
|
|
yield response |
|
|
|
yield response |
|
|
|
|
|
|
|
|
|
|
|
def StreamingInputCall(self, request_iter, unused_rpc_context): |
|
|
|
def StreamingInputCall(self, request_iter, unused_rpc_context): |
|
|
|
response = self._test_pb2.StreamingInputCallResponse() |
|
|
|
response = self._response_pb2.StreamingInputCallResponse() |
|
|
|
aggregated_payload_size = 0 |
|
|
|
aggregated_payload_size = 0 |
|
|
|
for request in request_iter: |
|
|
|
for request in request_iter: |
|
|
|
aggregated_payload_size += len(request.payload.payload_compressable) |
|
|
|
aggregated_payload_size += len(request.payload.payload_compressable) |
|
|
|
@ -116,8 +117,8 @@ class _ServicerMethods(object): |
|
|
|
def FullDuplexCall(self, request_iter, unused_rpc_context): |
|
|
|
def FullDuplexCall(self, request_iter, unused_rpc_context): |
|
|
|
for request in request_iter: |
|
|
|
for request in request_iter: |
|
|
|
for parameter in request.response_parameters: |
|
|
|
for parameter in request.response_parameters: |
|
|
|
response = self._test_pb2.StreamingOutputCallResponse() |
|
|
|
response = self._response_pb2.StreamingOutputCallResponse() |
|
|
|
response.payload.payload_type = self._test_pb2.COMPRESSABLE |
|
|
|
response.payload.payload_type = self._payload_pb2.COMPRESSABLE |
|
|
|
response.payload.payload_compressable = 'a' * parameter.size |
|
|
|
response.payload.payload_compressable = 'a' * parameter.size |
|
|
|
self._control() |
|
|
|
self._control() |
|
|
|
yield response |
|
|
|
yield response |
|
|
|
@ -126,8 +127,8 @@ class _ServicerMethods(object): |
|
|
|
responses = [] |
|
|
|
responses = [] |
|
|
|
for request in request_iter: |
|
|
|
for request in request_iter: |
|
|
|
for parameter in request.response_parameters: |
|
|
|
for parameter in request.response_parameters: |
|
|
|
response = self._test_pb2.StreamingOutputCallResponse() |
|
|
|
response = self._response_pb2.StreamingOutputCallResponse() |
|
|
|
response.payload.payload_type = self._test_pb2.COMPRESSABLE |
|
|
|
response.payload.payload_type = self._payload_pb2.COMPRESSABLE |
|
|
|
response.payload.payload_compressable = 'a' * parameter.size |
|
|
|
response.payload.payload_compressable = 'a' * parameter.size |
|
|
|
self._control() |
|
|
|
self._control() |
|
|
|
responses.append(response) |
|
|
|
responses.append(response) |
|
|
|
@ -136,23 +137,25 @@ class _ServicerMethods(object): |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@contextlib.contextmanager |
|
|
|
@contextlib.contextmanager |
|
|
|
def _CreateService(test_pb2): |
|
|
|
def _CreateService(service_pb2, response_pb2, payload_pb2): |
|
|
|
"""Provides a servicer backend and a stub. |
|
|
|
"""Provides a servicer backend and a stub. |
|
|
|
|
|
|
|
|
|
|
|
The servicer is just the implementation of the actual servicer passed to the |
|
|
|
The servicer is just the implementation of the actual servicer passed to the |
|
|
|
face player of the python RPC implementation; the two are detached. |
|
|
|
face player of the python RPC implementation; the two are detached. |
|
|
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
Args: |
|
|
|
test_pb2: The test_pb2 module generated by this test. |
|
|
|
service_pb2: The service_pb2 module generated by this test. |
|
|
|
|
|
|
|
response_pb2: The response_pb2 module generated by this test |
|
|
|
|
|
|
|
payload_pb2: The payload_pb2 module generated by this test |
|
|
|
|
|
|
|
|
|
|
|
Yields: |
|
|
|
Yields: |
|
|
|
A (servicer_methods, stub) pair where servicer_methods is the back-end of |
|
|
|
A (servicer_methods, stub) pair where servicer_methods is the back-end of |
|
|
|
the service bound to the stub and and stub is the stub on which to invoke |
|
|
|
the service bound to the stub and and stub is the stub on which to invoke |
|
|
|
RPCs. |
|
|
|
RPCs. |
|
|
|
""" |
|
|
|
""" |
|
|
|
servicer_methods = _ServicerMethods(test_pb2) |
|
|
|
servicer_methods = _ServicerMethods(response_pb2, payload_pb2) |
|
|
|
|
|
|
|
|
|
|
|
class Servicer(getattr(test_pb2, SERVICER_IDENTIFIER)): |
|
|
|
class Servicer(getattr(service_pb2, SERVICER_IDENTIFIER)): |
|
|
|
|
|
|
|
|
|
|
|
def UnaryCall(self, request, context): |
|
|
|
def UnaryCall(self, request, context): |
|
|
|
return servicer_methods.UnaryCall(request, context) |
|
|
|
return servicer_methods.UnaryCall(request, context) |
|
|
|
@ -170,55 +173,52 @@ def _CreateService(test_pb2): |
|
|
|
return servicer_methods.HalfDuplexCall(request_iter, context) |
|
|
|
return servicer_methods.HalfDuplexCall(request_iter, context) |
|
|
|
|
|
|
|
|
|
|
|
servicer = Servicer() |
|
|
|
servicer = Servicer() |
|
|
|
server = getattr(test_pb2, SERVER_FACTORY_IDENTIFIER)(servicer) |
|
|
|
server = getattr(service_pb2, SERVER_FACTORY_IDENTIFIER)(servicer) |
|
|
|
port = server.add_insecure_port('[::]:0') |
|
|
|
port = server.add_insecure_port('[::]:0') |
|
|
|
server.start() |
|
|
|
server.start() |
|
|
|
channel = implementations.insecure_channel('localhost', port) |
|
|
|
channel = implementations.insecure_channel('localhost', port) |
|
|
|
stub = getattr(test_pb2, STUB_FACTORY_IDENTIFIER)(channel) |
|
|
|
stub = getattr(service_pb2, STUB_FACTORY_IDENTIFIER)(channel) |
|
|
|
yield servicer_methods, stub |
|
|
|
yield (servicer_methods, stub) |
|
|
|
server.stop(0) |
|
|
|
server.stop(0) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@contextlib.contextmanager |
|
|
|
@contextlib.contextmanager |
|
|
|
def _CreateIncompleteService(test_pb2): |
|
|
|
def _CreateIncompleteService(service_pb2): |
|
|
|
"""Provides a servicer backend that fails to implement methods and its stub. |
|
|
|
"""Provides a servicer backend that fails to implement methods and its stub. |
|
|
|
|
|
|
|
|
|
|
|
The servicer is just the implementation of the actual servicer passed to the |
|
|
|
The servicer is just the implementation of the actual servicer passed to the |
|
|
|
face player of the python RPC implementation; the two are detached. |
|
|
|
face player of the python RPC implementation; the two are detached. |
|
|
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
Args: |
|
|
|
test_pb2: The test_pb2 module generated by this test. |
|
|
|
service_pb2: The service_pb2 module generated by this test. |
|
|
|
|
|
|
|
|
|
|
|
Yields: |
|
|
|
Yields: |
|
|
|
A (servicer_methods, stub) pair where servicer_methods is the back-end of |
|
|
|
A (servicer_methods, stub) pair where servicer_methods is the back-end of |
|
|
|
the service bound to the stub and and stub is the stub on which to invoke |
|
|
|
the service bound to the stub and and stub is the stub on which to invoke |
|
|
|
RPCs. |
|
|
|
RPCs. |
|
|
|
""" |
|
|
|
""" |
|
|
|
servicer_methods = _ServicerMethods(test_pb2) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class Servicer(getattr(test_pb2, SERVICER_IDENTIFIER)): |
|
|
|
class Servicer(getattr(service_pb2, SERVICER_IDENTIFIER)): |
|
|
|
pass |
|
|
|
pass |
|
|
|
|
|
|
|
|
|
|
|
servicer = Servicer() |
|
|
|
servicer = Servicer() |
|
|
|
server = getattr(test_pb2, SERVER_FACTORY_IDENTIFIER)(servicer) |
|
|
|
server = getattr(service_pb2, SERVER_FACTORY_IDENTIFIER)(servicer) |
|
|
|
port = server.add_insecure_port('[::]:0') |
|
|
|
port = server.add_insecure_port('[::]:0') |
|
|
|
server.start() |
|
|
|
server.start() |
|
|
|
channel = implementations.insecure_channel('localhost', port) |
|
|
|
channel = implementations.insecure_channel('localhost', port) |
|
|
|
stub = getattr(test_pb2, STUB_FACTORY_IDENTIFIER)(channel) |
|
|
|
stub = getattr(service_pb2, STUB_FACTORY_IDENTIFIER)(channel) |
|
|
|
yield servicer_methods, stub |
|
|
|
yield None, stub |
|
|
|
server.stop(0) |
|
|
|
server.stop(0) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _streaming_input_request_iterator(test_pb2): |
|
|
|
def _streaming_input_request_iterator(request_pb2, payload_pb2): |
|
|
|
for _ in range(3): |
|
|
|
for _ in range(3): |
|
|
|
request = test_pb2.StreamingInputCallRequest() |
|
|
|
request = request_pb2.StreamingInputCallRequest() |
|
|
|
request.payload.payload_type = test_pb2.COMPRESSABLE |
|
|
|
request.payload.payload_type = payload_pb2.COMPRESSABLE |
|
|
|
request.payload.payload_compressable = 'a' |
|
|
|
request.payload.payload_compressable = 'a' |
|
|
|
yield request |
|
|
|
yield request |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _streaming_output_request(test_pb2): |
|
|
|
def _streaming_output_request(request_pb2): |
|
|
|
request = test_pb2.StreamingOutputCallRequest() |
|
|
|
request = request_pb2.StreamingOutputCallRequest() |
|
|
|
sizes = [1, 2, 3] |
|
|
|
sizes = [1, 2, 3] |
|
|
|
request.response_parameters.add(size=sizes[0], interval_us=0) |
|
|
|
request.response_parameters.add(size=sizes[0], interval_us=0) |
|
|
|
request.response_parameters.add(size=sizes[1], interval_us=0) |
|
|
|
request.response_parameters.add(size=sizes[1], interval_us=0) |
|
|
|
@ -226,11 +226,11 @@ def _streaming_output_request(test_pb2): |
|
|
|
return request |
|
|
|
return request |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _full_duplex_request_iterator(test_pb2): |
|
|
|
def _full_duplex_request_iterator(request_pb2): |
|
|
|
request = test_pb2.StreamingOutputCallRequest() |
|
|
|
request = request_pb2.StreamingOutputCallRequest() |
|
|
|
request.response_parameters.add(size=1, interval_us=0) |
|
|
|
request.response_parameters.add(size=1, interval_us=0) |
|
|
|
yield request |
|
|
|
yield request |
|
|
|
request = test_pb2.StreamingOutputCallRequest() |
|
|
|
request = request_pb2.StreamingOutputCallRequest() |
|
|
|
request.response_parameters.add(size=2, interval_us=0) |
|
|
|
request.response_parameters.add(size=2, interval_us=0) |
|
|
|
request.response_parameters.add(size=3, interval_us=0) |
|
|
|
request.response_parameters.add(size=3, interval_us=0) |
|
|
|
yield request |
|
|
|
yield request |
|
|
|
@ -250,8 +250,6 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
protoc_command = 'protoc' |
|
|
|
protoc_command = 'protoc' |
|
|
|
protoc_plugin_filename = distutils.spawn.find_executable( |
|
|
|
protoc_plugin_filename = distutils.spawn.find_executable( |
|
|
|
'grpc_python_plugin') |
|
|
|
'grpc_python_plugin') |
|
|
|
test_proto_filename = pkg_resources.resource_filename( |
|
|
|
|
|
|
|
'tests.protoc_plugin', 'protoc_plugin_test.proto') |
|
|
|
|
|
|
|
if not os.path.isfile(protoc_command): |
|
|
|
if not os.path.isfile(protoc_command): |
|
|
|
# Assume that if we haven't built protoc that it's on the system. |
|
|
|
# Assume that if we haven't built protoc that it's on the system. |
|
|
|
protoc_command = 'protoc' |
|
|
|
protoc_command = 'protoc' |
|
|
|
@ -259,19 +257,44 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
# Ensure that the output directory exists. |
|
|
|
# Ensure that the output directory exists. |
|
|
|
self.outdir = tempfile.mkdtemp() |
|
|
|
self.outdir = tempfile.mkdtemp() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Find all proto files |
|
|
|
|
|
|
|
paths = [] |
|
|
|
|
|
|
|
root_dir = os.path.dirname(os.path.realpath(__file__)) |
|
|
|
|
|
|
|
proto_dir = os.path.join(root_dir, 'protos') |
|
|
|
|
|
|
|
for walk_root, _, filenames in os.walk(proto_dir): |
|
|
|
|
|
|
|
for filename in filenames: |
|
|
|
|
|
|
|
if filename.endswith('.proto'): |
|
|
|
|
|
|
|
path = os.path.join(walk_root, filename) |
|
|
|
|
|
|
|
paths.append(path) |
|
|
|
|
|
|
|
|
|
|
|
# Invoke protoc with the plugin. |
|
|
|
# Invoke protoc with the plugin. |
|
|
|
cmd = [ |
|
|
|
cmd = [ |
|
|
|
protoc_command, |
|
|
|
protoc_command, |
|
|
|
'--plugin=protoc-gen-python-grpc=%s' % protoc_plugin_filename, |
|
|
|
'--plugin=protoc-gen-python-grpc=%s' % protoc_plugin_filename, |
|
|
|
'-I .', |
|
|
|
'-I %s' % root_dir, |
|
|
|
'--python_out=%s' % self.outdir, |
|
|
|
'--python_out=%s' % self.outdir, |
|
|
|
'--python-grpc_out=%s' % self.outdir, |
|
|
|
'--python-grpc_out=%s' % self.outdir |
|
|
|
os.path.basename(test_proto_filename), |
|
|
|
] + paths |
|
|
|
] |
|
|
|
|
|
|
|
subprocess.check_call(' '.join(cmd), shell=True, env=os.environ, |
|
|
|
subprocess.check_call(' '.join(cmd), shell=True, env=os.environ, |
|
|
|
cwd=os.path.dirname(test_proto_filename)) |
|
|
|
cwd=os.path.dirname(os.path.realpath(__file__))) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Generated proto directories dont include __init__.py, but |
|
|
|
|
|
|
|
# these are needed for python package resolution |
|
|
|
|
|
|
|
for walk_root, _, _ in os.walk(os.path.join(self.outdir, 'protos')): |
|
|
|
|
|
|
|
path = os.path.join(walk_root, '__init__.py') |
|
|
|
|
|
|
|
open(path, 'a').close() |
|
|
|
|
|
|
|
|
|
|
|
sys.path.insert(0, self.outdir) |
|
|
|
sys.path.insert(0, self.outdir) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import protos.payload.test_payload_pb2 as payload_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
|
|
|
|
import protos.requests.r.test_requests_pb2 as request_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
|
|
|
|
import protos.responses.test_responses_pb2 as response_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
|
|
|
|
import protos.service.test_service_pb2 as service_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
|
|
|
|
self._payload_pb2 = payload_pb2 |
|
|
|
|
|
|
|
self._request_pb2 = request_pb2 |
|
|
|
|
|
|
|
self._response_pb2 = response_pb2 |
|
|
|
|
|
|
|
self._service_pb2 = service_pb2 |
|
|
|
|
|
|
|
|
|
|
|
def tearDown(self): |
|
|
|
def tearDown(self): |
|
|
|
try: |
|
|
|
try: |
|
|
|
shutil.rmtree(self.outdir) |
|
|
|
shutil.rmtree(self.outdir) |
|
|
|
@ -282,43 +305,40 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
|
|
|
|
|
|
|
|
def testImportAttributes(self): |
|
|
|
def testImportAttributes(self): |
|
|
|
# check that we can access the generated module and its members. |
|
|
|
# check that we can access the generated module and its members. |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
self.assertIsNotNone( |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
getattr(self._service_pb2, SERVICER_IDENTIFIER, None)) |
|
|
|
self.assertIsNotNone(getattr(test_pb2, SERVICER_IDENTIFIER, None)) |
|
|
|
self.assertIsNotNone( |
|
|
|
self.assertIsNotNone(getattr(test_pb2, STUB_IDENTIFIER, None)) |
|
|
|
getattr(self._service_pb2, STUB_IDENTIFIER, None)) |
|
|
|
self.assertIsNotNone(getattr(test_pb2, SERVER_FACTORY_IDENTIFIER, None)) |
|
|
|
self.assertIsNotNone( |
|
|
|
self.assertIsNotNone(getattr(test_pb2, STUB_FACTORY_IDENTIFIER, None)) |
|
|
|
getattr(self._service_pb2, SERVER_FACTORY_IDENTIFIER, None)) |
|
|
|
|
|
|
|
self.assertIsNotNone( |
|
|
|
|
|
|
|
getattr(self._service_pb2, STUB_FACTORY_IDENTIFIER, None)) |
|
|
|
|
|
|
|
|
|
|
|
def testUpDown(self): |
|
|
|
def testUpDown(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 |
|
|
|
with _CreateService( |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._service_pb2, self._response_pb2, self._payload_pb2): |
|
|
|
with _CreateService(test_pb2) as (servicer, stub): |
|
|
|
self._request_pb2.SimpleRequest(response_size=13) |
|
|
|
request = test_pb2.SimpleRequest(response_size=13) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def testIncompleteServicer(self): |
|
|
|
def testIncompleteServicer(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 |
|
|
|
with _CreateIncompleteService(self._service_pb2) as (_, stub): |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
request = self._request_pb2.SimpleRequest(response_size=13) |
|
|
|
with _CreateIncompleteService(test_pb2) as (servicer, stub): |
|
|
|
|
|
|
|
request = test_pb2.SimpleRequest(response_size=13) |
|
|
|
|
|
|
|
try: |
|
|
|
try: |
|
|
|
response = stub.UnaryCall(request, test_constants.LONG_TIMEOUT) |
|
|
|
stub.UnaryCall(request, test_constants.LONG_TIMEOUT) |
|
|
|
except face.AbortionError as error: |
|
|
|
except face.AbortionError as error: |
|
|
|
self.assertEqual(interfaces.StatusCode.UNIMPLEMENTED, error.code) |
|
|
|
self.assertEqual(interfaces.StatusCode.UNIMPLEMENTED, error.code) |
|
|
|
|
|
|
|
|
|
|
|
def testUnaryCall(self): |
|
|
|
def testUnaryCall(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
request = self._request_pb2.SimpleRequest(response_size=13) |
|
|
|
request = test_pb2.SimpleRequest(response_size=13) |
|
|
|
|
|
|
|
response = stub.UnaryCall(request, test_constants.LONG_TIMEOUT) |
|
|
|
response = stub.UnaryCall(request, test_constants.LONG_TIMEOUT) |
|
|
|
expected_response = methods.UnaryCall(request, 'not a real context!') |
|
|
|
expected_response = methods.UnaryCall(request, 'not a real context!') |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
|
|
|
|
|
|
|
|
def testUnaryCallFuture(self): |
|
|
|
def testUnaryCallFuture(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
request = test_pb2.SimpleRequest(response_size=13) |
|
|
|
request = self._request_pb2.SimpleRequest(response_size=13) |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
# Check that the call does not block waiting for the server to respond. |
|
|
|
# Check that the call does not block waiting for the server to respond. |
|
|
|
with methods.pause(): |
|
|
|
with methods.pause(): |
|
|
|
response_future = stub.UnaryCall.future( |
|
|
|
response_future = stub.UnaryCall.future( |
|
|
|
@ -328,10 +348,9 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
|
|
|
|
|
|
|
|
def testUnaryCallFutureExpired(self): |
|
|
|
def testUnaryCallFutureExpired(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
request = self._request_pb2.SimpleRequest(response_size=13) |
|
|
|
request = test_pb2.SimpleRequest(response_size=13) |
|
|
|
|
|
|
|
with methods.pause(): |
|
|
|
with methods.pause(): |
|
|
|
response_future = stub.UnaryCall.future( |
|
|
|
response_future = stub.UnaryCall.future( |
|
|
|
request, test_constants.SHORT_TIMEOUT) |
|
|
|
request, test_constants.SHORT_TIMEOUT) |
|
|
|
@ -339,30 +358,27 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
response_future.result() |
|
|
|
response_future.result() |
|
|
|
|
|
|
|
|
|
|
|
def testUnaryCallFutureCancelled(self): |
|
|
|
def testUnaryCallFutureCancelled(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
request = test_pb2.SimpleRequest(response_size=13) |
|
|
|
request = self._request_pb2.SimpleRequest(response_size=13) |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
with methods.pause(): |
|
|
|
with methods.pause(): |
|
|
|
response_future = stub.UnaryCall.future(request, 1) |
|
|
|
response_future = stub.UnaryCall.future(request, 1) |
|
|
|
response_future.cancel() |
|
|
|
response_future.cancel() |
|
|
|
self.assertTrue(response_future.cancelled()) |
|
|
|
self.assertTrue(response_future.cancelled()) |
|
|
|
|
|
|
|
|
|
|
|
def testUnaryCallFutureFailed(self): |
|
|
|
def testUnaryCallFutureFailed(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
request = test_pb2.SimpleRequest(response_size=13) |
|
|
|
request = self._request_pb2.SimpleRequest(response_size=13) |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
with methods.fail(): |
|
|
|
with methods.fail(): |
|
|
|
response_future = stub.UnaryCall.future( |
|
|
|
response_future = stub.UnaryCall.future( |
|
|
|
request, test_constants.LONG_TIMEOUT) |
|
|
|
request, test_constants.LONG_TIMEOUT) |
|
|
|
self.assertIsNotNone(response_future.exception()) |
|
|
|
self.assertIsNotNone(response_future.exception()) |
|
|
|
|
|
|
|
|
|
|
|
def testStreamingOutputCall(self): |
|
|
|
def testStreamingOutputCall(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
request = _streaming_output_request(test_pb2) |
|
|
|
request = _streaming_output_request(self._request_pb2) |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
responses = stub.StreamingOutputCall( |
|
|
|
responses = stub.StreamingOutputCall( |
|
|
|
request, test_constants.LONG_TIMEOUT) |
|
|
|
request, test_constants.LONG_TIMEOUT) |
|
|
|
expected_responses = methods.StreamingOutputCall( |
|
|
|
expected_responses = methods.StreamingOutputCall( |
|
|
|
@ -372,10 +388,9 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
|
|
|
|
|
|
|
|
def testStreamingOutputCallExpired(self): |
|
|
|
def testStreamingOutputCallExpired(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
request = _streaming_output_request(test_pb2) |
|
|
|
request = _streaming_output_request(self._request_pb2) |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
with methods.pause(): |
|
|
|
with methods.pause(): |
|
|
|
responses = stub.StreamingOutputCall( |
|
|
|
responses = stub.StreamingOutputCall( |
|
|
|
request, test_constants.SHORT_TIMEOUT) |
|
|
|
request, test_constants.SHORT_TIMEOUT) |
|
|
|
@ -383,10 +398,9 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
list(responses) |
|
|
|
list(responses) |
|
|
|
|
|
|
|
|
|
|
|
def testStreamingOutputCallCancelled(self): |
|
|
|
def testStreamingOutputCallCancelled(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
request = _streaming_output_request(test_pb2) |
|
|
|
request = _streaming_output_request(self._request_pb2) |
|
|
|
with _CreateService(test_pb2) as (unused_methods, stub): |
|
|
|
|
|
|
|
responses = stub.StreamingOutputCall( |
|
|
|
responses = stub.StreamingOutputCall( |
|
|
|
request, test_constants.LONG_TIMEOUT) |
|
|
|
request, test_constants.LONG_TIMEOUT) |
|
|
|
next(responses) |
|
|
|
next(responses) |
|
|
|
@ -395,10 +409,9 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
next(responses) |
|
|
|
next(responses) |
|
|
|
|
|
|
|
|
|
|
|
def testStreamingOutputCallFailed(self): |
|
|
|
def testStreamingOutputCallFailed(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
request = _streaming_output_request(test_pb2) |
|
|
|
request = _streaming_output_request(self._request_pb2) |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
with methods.fail(): |
|
|
|
with methods.fail(): |
|
|
|
responses = stub.StreamingOutputCall(request, 1) |
|
|
|
responses = stub.StreamingOutputCall(request, 1) |
|
|
|
self.assertIsNotNone(responses) |
|
|
|
self.assertIsNotNone(responses) |
|
|
|
@ -406,36 +419,38 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
next(responses) |
|
|
|
next(responses) |
|
|
|
|
|
|
|
|
|
|
|
def testStreamingInputCall(self): |
|
|
|
def testStreamingInputCall(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
response = stub.StreamingInputCall( |
|
|
|
response = stub.StreamingInputCall( |
|
|
|
_streaming_input_request_iterator(test_pb2), |
|
|
|
_streaming_input_request_iterator( |
|
|
|
|
|
|
|
self._request_pb2, self._payload_pb2), |
|
|
|
test_constants.LONG_TIMEOUT) |
|
|
|
test_constants.LONG_TIMEOUT) |
|
|
|
expected_response = methods.StreamingInputCall( |
|
|
|
expected_response = methods.StreamingInputCall( |
|
|
|
_streaming_input_request_iterator(test_pb2), 'not a real RpcContext!') |
|
|
|
_streaming_input_request_iterator(self._request_pb2, self._payload_pb2), |
|
|
|
|
|
|
|
'not a real RpcContext!') |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
|
|
|
|
|
|
|
|
def testStreamingInputCallFuture(self): |
|
|
|
def testStreamingInputCallFuture(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
with methods.pause(): |
|
|
|
with methods.pause(): |
|
|
|
response_future = stub.StreamingInputCall.future( |
|
|
|
response_future = stub.StreamingInputCall.future( |
|
|
|
_streaming_input_request_iterator(test_pb2), |
|
|
|
_streaming_input_request_iterator( |
|
|
|
|
|
|
|
self._request_pb2, self._payload_pb2), |
|
|
|
test_constants.LONG_TIMEOUT) |
|
|
|
test_constants.LONG_TIMEOUT) |
|
|
|
response = response_future.result() |
|
|
|
response = response_future.result() |
|
|
|
expected_response = methods.StreamingInputCall( |
|
|
|
expected_response = methods.StreamingInputCall( |
|
|
|
_streaming_input_request_iterator(test_pb2), 'not a real RpcContext!') |
|
|
|
_streaming_input_request_iterator(self._request_pb2, self._payload_pb2), |
|
|
|
|
|
|
|
'not a real RpcContext!') |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
|
|
|
|
|
|
|
|
def testStreamingInputCallFutureExpired(self): |
|
|
|
def testStreamingInputCallFutureExpired(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
with methods.pause(): |
|
|
|
with methods.pause(): |
|
|
|
response_future = stub.StreamingInputCall.future( |
|
|
|
response_future = stub.StreamingInputCall.future( |
|
|
|
_streaming_input_request_iterator(test_pb2), |
|
|
|
_streaming_input_request_iterator( |
|
|
|
|
|
|
|
self._request_pb2, self._payload_pb2), |
|
|
|
test_constants.SHORT_TIMEOUT) |
|
|
|
test_constants.SHORT_TIMEOUT) |
|
|
|
with self.assertRaises(face.ExpirationError): |
|
|
|
with self.assertRaises(face.ExpirationError): |
|
|
|
response_future.result() |
|
|
|
response_future.result() |
|
|
|
@ -443,12 +458,12 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
response_future.exception(), face.ExpirationError) |
|
|
|
response_future.exception(), face.ExpirationError) |
|
|
|
|
|
|
|
|
|
|
|
def testStreamingInputCallFutureCancelled(self): |
|
|
|
def testStreamingInputCallFutureCancelled(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
with methods.pause(): |
|
|
|
with methods.pause(): |
|
|
|
response_future = stub.StreamingInputCall.future( |
|
|
|
response_future = stub.StreamingInputCall.future( |
|
|
|
_streaming_input_request_iterator(test_pb2), |
|
|
|
_streaming_input_request_iterator( |
|
|
|
|
|
|
|
self._request_pb2, self._payload_pb2), |
|
|
|
test_constants.LONG_TIMEOUT) |
|
|
|
test_constants.LONG_TIMEOUT) |
|
|
|
response_future.cancel() |
|
|
|
response_future.cancel() |
|
|
|
self.assertTrue(response_future.cancelled()) |
|
|
|
self.assertTrue(response_future.cancelled()) |
|
|
|
@ -456,32 +471,32 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
response_future.result() |
|
|
|
response_future.result() |
|
|
|
|
|
|
|
|
|
|
|
def testStreamingInputCallFutureFailed(self): |
|
|
|
def testStreamingInputCallFutureFailed(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
with methods.fail(): |
|
|
|
with methods.fail(): |
|
|
|
response_future = stub.StreamingInputCall.future( |
|
|
|
response_future = stub.StreamingInputCall.future( |
|
|
|
_streaming_input_request_iterator(test_pb2), |
|
|
|
_streaming_input_request_iterator( |
|
|
|
|
|
|
|
self._request_pb2, self._payload_pb2), |
|
|
|
test_constants.LONG_TIMEOUT) |
|
|
|
test_constants.LONG_TIMEOUT) |
|
|
|
self.assertIsNotNone(response_future.exception()) |
|
|
|
self.assertIsNotNone(response_future.exception()) |
|
|
|
|
|
|
|
|
|
|
|
def testFullDuplexCall(self): |
|
|
|
def testFullDuplexCall(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
responses = stub.FullDuplexCall( |
|
|
|
responses = stub.FullDuplexCall( |
|
|
|
_full_duplex_request_iterator(test_pb2), test_constants.LONG_TIMEOUT) |
|
|
|
_full_duplex_request_iterator(self._request_pb2), |
|
|
|
|
|
|
|
test_constants.LONG_TIMEOUT) |
|
|
|
expected_responses = methods.FullDuplexCall( |
|
|
|
expected_responses = methods.FullDuplexCall( |
|
|
|
_full_duplex_request_iterator(test_pb2), 'not a real RpcContext!') |
|
|
|
_full_duplex_request_iterator(self._request_pb2), |
|
|
|
|
|
|
|
'not a real RpcContext!') |
|
|
|
for expected_response, response in moves.zip_longest( |
|
|
|
for expected_response, response in moves.zip_longest( |
|
|
|
expected_responses, responses): |
|
|
|
expected_responses, responses): |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
|
|
|
|
|
|
|
|
def testFullDuplexCallExpired(self): |
|
|
|
def testFullDuplexCallExpired(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
request_iterator = _full_duplex_request_iterator(self._request_pb2) |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
request_iterator = _full_duplex_request_iterator(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
with methods.pause(): |
|
|
|
with methods.pause(): |
|
|
|
responses = stub.FullDuplexCall( |
|
|
|
responses = stub.FullDuplexCall( |
|
|
|
request_iterator, test_constants.SHORT_TIMEOUT) |
|
|
|
request_iterator, test_constants.SHORT_TIMEOUT) |
|
|
|
@ -489,10 +504,9 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
list(responses) |
|
|
|
list(responses) |
|
|
|
|
|
|
|
|
|
|
|
def testFullDuplexCallCancelled(self): |
|
|
|
def testFullDuplexCallCancelled(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
request_iterator = _full_duplex_request_iterator(self._request_pb2) |
|
|
|
request_iterator = _full_duplex_request_iterator(test_pb2) |
|
|
|
|
|
|
|
responses = stub.FullDuplexCall( |
|
|
|
responses = stub.FullDuplexCall( |
|
|
|
request_iterator, test_constants.LONG_TIMEOUT) |
|
|
|
request_iterator, test_constants.LONG_TIMEOUT) |
|
|
|
next(responses) |
|
|
|
next(responses) |
|
|
|
@ -501,10 +515,9 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
next(responses) |
|
|
|
next(responses) |
|
|
|
|
|
|
|
|
|
|
|
def testFullDuplexCallFailed(self): |
|
|
|
def testFullDuplexCallFailed(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
request_iterator = _full_duplex_request_iterator(self._request_pb2) |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
request_iterator = _full_duplex_request_iterator(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
with methods.fail(): |
|
|
|
with methods.fail(): |
|
|
|
responses = stub.FullDuplexCall( |
|
|
|
responses = stub.FullDuplexCall( |
|
|
|
request_iterator, test_constants.LONG_TIMEOUT) |
|
|
|
request_iterator, test_constants.LONG_TIMEOUT) |
|
|
|
@ -513,14 +526,13 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
next(responses) |
|
|
|
next(responses) |
|
|
|
|
|
|
|
|
|
|
|
def testHalfDuplexCall(self): |
|
|
|
def testHalfDuplexCall(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
moves.reload_module(test_pb2) |
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
|
|
|
|
def half_duplex_request_iterator(): |
|
|
|
def half_duplex_request_iterator(): |
|
|
|
request = test_pb2.StreamingOutputCallRequest() |
|
|
|
request = self._request_pb2.StreamingOutputCallRequest() |
|
|
|
request.response_parameters.add(size=1, interval_us=0) |
|
|
|
request.response_parameters.add(size=1, interval_us=0) |
|
|
|
yield request |
|
|
|
yield request |
|
|
|
request = test_pb2.StreamingOutputCallRequest() |
|
|
|
request = self._request_pb2.StreamingOutputCallRequest() |
|
|
|
request.response_parameters.add(size=2, interval_us=0) |
|
|
|
request.response_parameters.add(size=2, interval_us=0) |
|
|
|
request.response_parameters.add(size=3, interval_us=0) |
|
|
|
request.response_parameters.add(size=3, interval_us=0) |
|
|
|
yield request |
|
|
|
yield request |
|
|
|
@ -533,8 +545,6 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
self.assertEqual(expected_response, response) |
|
|
|
|
|
|
|
|
|
|
|
def testHalfDuplexCallWedged(self): |
|
|
|
def testHalfDuplexCallWedged(self): |
|
|
|
import protoc_plugin_test_pb2 as test_pb2 # pylint: disable=g-import-not-at-top |
|
|
|
|
|
|
|
moves.reload_module(test_pb2) |
|
|
|
|
|
|
|
condition = threading.Condition() |
|
|
|
condition = threading.Condition() |
|
|
|
wait_cell = [False] |
|
|
|
wait_cell = [False] |
|
|
|
@contextlib.contextmanager |
|
|
|
@contextlib.contextmanager |
|
|
|
@ -547,13 +557,14 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
wait_cell[0] = False |
|
|
|
wait_cell[0] = False |
|
|
|
condition.notify_all() |
|
|
|
condition.notify_all() |
|
|
|
def half_duplex_request_iterator(): |
|
|
|
def half_duplex_request_iterator(): |
|
|
|
request = test_pb2.StreamingOutputCallRequest() |
|
|
|
request = self._request_pb2.StreamingOutputCallRequest() |
|
|
|
request.response_parameters.add(size=1, interval_us=0) |
|
|
|
request.response_parameters.add(size=1, interval_us=0) |
|
|
|
yield request |
|
|
|
yield request |
|
|
|
with condition: |
|
|
|
with condition: |
|
|
|
while wait_cell[0]: |
|
|
|
while wait_cell[0]: |
|
|
|
condition.wait() |
|
|
|
condition.wait() |
|
|
|
with _CreateService(test_pb2) as (methods, stub): |
|
|
|
with _CreateService(self._service_pb2, self._response_pb2, |
|
|
|
|
|
|
|
self._payload_pb2) as (methods, stub): |
|
|
|
with wait(): |
|
|
|
with wait(): |
|
|
|
responses = stub.HalfDuplexCall( |
|
|
|
responses = stub.HalfDuplexCall( |
|
|
|
half_duplex_request_iterator(), test_constants.SHORT_TIMEOUT) |
|
|
|
half_duplex_request_iterator(), test_constants.SHORT_TIMEOUT) |
|
|
|
@ -563,5 +574,5 @@ class PythonPluginTest(unittest.TestCase): |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__': |
|
|
|
if __name__ == '__main__': |
|
|
|
os.chdir(os.path.dirname(sys.argv[0])) |
|
|
|
#os.chdir(os.path.dirname(sys.argv[0])) |
|
|
|
unittest.main(verbosity=2) |
|
|
|
unittest.main(verbosity=2) |
|
|
|
|
David Klempner
9 years ago