Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

That line changed count seemed a bit big

Browse Source
pull/23163/head
Richard Belleville 5 years ago
parent 5811df0fd0
commit 93477ae55f
1 changed files with 195 additions and 195 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 390
      src/python/grpcio_tests/tests_py3_only/unit/_simple_stubs_test.py

390
src/python/grpcio_tests/tests_py3_only/unit/_simple_stubs_test.py
Unescape View File

@ -180,201 +180,201 @@ class SimpleStubsTest(unittest.TestCase):
else: else:
self.fail(message() + " after " + str(timeout)) self.fail(message() + " after " + str(timeout))
# def test_unary_unary_insecure(self): def test_unary_unary_insecure(self):
# with _server(None) as port: with _server(None) as port:
# target = f'localhost:{port}' target = f'localhost:{port}'
# response = grpc.experimental.unary_unary( response = grpc.experimental.unary_unary(
# _REQUEST, _REQUEST,
# target, target,
# _UNARY_UNARY, _UNARY_UNARY,
# channel_credentials=grpc.experimental. channel_credentials=grpc.experimental.
# insecure_channel_credentials()) insecure_channel_credentials())
# self.assertEqual(_REQUEST, response) self.assertEqual(_REQUEST, response)
# def test_unary_unary_secure(self): def test_unary_unary_secure(self):
# with _server(grpc.local_server_credentials()) as port: with _server(grpc.local_server_credentials()) as port:
# target = f'localhost:{port}' target = f'localhost:{port}'
# response = grpc.experimental.unary_unary( response = grpc.experimental.unary_unary(
# _REQUEST, _REQUEST,
# target, target,
# _UNARY_UNARY, _UNARY_UNARY,
# channel_credentials=grpc.local_channel_credentials()) channel_credentials=grpc.local_channel_credentials())
# self.assertEqual(_REQUEST, response) self.assertEqual(_REQUEST, response)
# def test_channels_cached(self): def test_channels_cached(self):
# with _server(grpc.local_server_credentials()) as port: with _server(grpc.local_server_credentials()) as port:
# target = f'localhost:{port}' target = f'localhost:{port}'
# test_name = inspect.stack()[0][3] test_name = inspect.stack()[0][3]
# args = (_REQUEST, target, _UNARY_UNARY) args = (_REQUEST, target, _UNARY_UNARY)
# kwargs = {"channel_credentials": grpc.local_channel_credentials()} kwargs = {"channel_credentials": grpc.local_channel_credentials()}
# def _invoke(seed: str): def _invoke(seed: str):
# run_kwargs = dict(kwargs) run_kwargs = dict(kwargs)
# run_kwargs["options"] = ((test_name + seed, ""),) run_kwargs["options"] = ((test_name + seed, ""),)
# grpc.experimental.unary_unary(*args, **run_kwargs) grpc.experimental.unary_unary(*args, **run_kwargs)
# self.assert_cached(_invoke) self.assert_cached(_invoke)
# def test_channels_evicted(self): def test_channels_evicted(self):
# with _server(grpc.local_server_credentials()) as port: with _server(grpc.local_server_credentials()) as port:
# target = f'localhost:{port}' target = f'localhost:{port}'
# response = grpc.experimental.unary_unary( response = grpc.experimental.unary_unary(
# _REQUEST, _REQUEST,
# target, target,
# _UNARY_UNARY, _UNARY_UNARY,
# channel_credentials=grpc.local_channel_credentials()) channel_credentials=grpc.local_channel_credentials())
# self.assert_eventually( self.assert_eventually(
# lambda: grpc._simple_stubs.ChannelCache.get( lambda: grpc._simple_stubs.ChannelCache.get(
# )._test_only_channel_count() == 0, )._test_only_channel_count() == 0,
# message=lambda: message=lambda:
# f"{grpc._simple_stubs.ChannelCache.get()._test_only_channel_count()} remain" f"{grpc._simple_stubs.ChannelCache.get()._test_only_channel_count()} remain"
# ) )
# def test_total_channels_enforced(self): def test_total_channels_enforced(self):
# with _server(grpc.local_server_credentials()) as port: with _server(grpc.local_server_credentials()) as port:
# target = f'localhost:{port}' target = f'localhost:{port}'
# for i in range(_STRESS_EPOCHS): for i in range(_STRESS_EPOCHS):
# # Ensure we get a new channel each time. # Ensure we get a new channel each time.
# options = (("foo", str(i)),) options = (("foo", str(i)),)
# # Send messages at full blast. # Send messages at full blast.
# grpc.experimental.unary_unary( grpc.experimental.unary_unary(
# _REQUEST, _REQUEST,
# target, target,
# _UNARY_UNARY, _UNARY_UNARY,
# options=options, options=options,
# channel_credentials=grpc.local_channel_credentials()) channel_credentials=grpc.local_channel_credentials())
# self.assert_eventually( self.assert_eventually(
# lambda: grpc._simple_stubs.ChannelCache.get( lambda: grpc._simple_stubs.ChannelCache.get(
# )._test_only_channel_count() <= _MAXIMUM_CHANNELS + 1, )._test_only_channel_count() <= _MAXIMUM_CHANNELS + 1,
# message=lambda: message=lambda:
# f"{grpc._simple_stubs.ChannelCache.get()._test_only_channel_count()} channels remain" f"{grpc._simple_stubs.ChannelCache.get()._test_only_channel_count()} channels remain"
# ) )
# def test_unary_stream(self): def test_unary_stream(self):
# with _server(grpc.local_server_credentials()) as port: with _server(grpc.local_server_credentials()) as port:
# target = f'localhost:{port}' target = f'localhost:{port}'
# for response in grpc.experimental.unary_stream( for response in grpc.experimental.unary_stream(
# _REQUEST, _REQUEST,
# target, target,
# _UNARY_STREAM, _UNARY_STREAM,
# channel_credentials=grpc.local_channel_credentials()): channel_credentials=grpc.local_channel_credentials()):
# self.assertEqual(_REQUEST, response) self.assertEqual(_REQUEST, response)
# def test_stream_unary(self): def test_stream_unary(self):
# def request_iter(): def request_iter():
# for _ in range(_CLIENT_REQUEST_COUNT): for _ in range(_CLIENT_REQUEST_COUNT):
# yield _REQUEST yield _REQUEST
# with _server(grpc.local_server_credentials()) as port: with _server(grpc.local_server_credentials()) as port:
# target = f'localhost:{port}' target = f'localhost:{port}'
# response = grpc.experimental.stream_unary( response = grpc.experimental.stream_unary(
# request_iter(), request_iter(),
# target, target,
# _STREAM_UNARY, _STREAM_UNARY,
# channel_credentials=grpc.local_channel_credentials()) channel_credentials=grpc.local_channel_credentials())
# self.assertEqual(_REQUEST, response) self.assertEqual(_REQUEST, response)
# def test_stream_stream(self): def test_stream_stream(self):
# def request_iter(): def request_iter():
# for _ in range(_CLIENT_REQUEST_COUNT): for _ in range(_CLIENT_REQUEST_COUNT):
# yield _REQUEST yield _REQUEST
# with _server(grpc.local_server_credentials()) as port: with _server(grpc.local_server_credentials()) as port:
# target = f'localhost:{port}' target = f'localhost:{port}'
# for response in grpc.experimental.stream_stream( for response in grpc.experimental.stream_stream(
# request_iter(), request_iter(),
# target, target,
# _STREAM_STREAM, _STREAM_STREAM,
# channel_credentials=grpc.local_channel_credentials()): channel_credentials=grpc.local_channel_credentials()):
# self.assertEqual(_REQUEST, response) self.assertEqual(_REQUEST, response)
# def test_default_ssl(self): def test_default_ssl(self):
# _private_key = resources.private_key() _private_key = resources.private_key()
# _certificate_chain = resources.certificate_chain() _certificate_chain = resources.certificate_chain()
# _server_certs = ((_private_key, _certificate_chain),) _server_certs = ((_private_key, _certificate_chain),)
# _server_host_override = 'foo.test.google.fr' _server_host_override = 'foo.test.google.fr'
# _test_root_certificates = resources.test_root_certificates() _test_root_certificates = resources.test_root_certificates()
# _property_options = (( _property_options = ((
# 'grpc.ssl_target_name_override', 'grpc.ssl_target_name_override',
# _server_host_override, _server_host_override,
# ),) ),)
# cert_dir = os.path.join(os.path.dirname(resources.__file__), cert_dir = os.path.join(os.path.dirname(resources.__file__),
# "credentials") "credentials")
# cert_file = os.path.join(cert_dir, "ca.pem") cert_file = os.path.join(cert_dir, "ca.pem")
# with _env("GRPC_DEFAULT_SSL_ROOTS_FILE_PATH", cert_file): with _env("GRPC_DEFAULT_SSL_ROOTS_FILE_PATH", cert_file):
# server_creds = grpc.ssl_server_credentials(_server_certs) server_creds = grpc.ssl_server_credentials(_server_certs)
# with _server(server_creds) as port: with _server(server_creds) as port:
# target = f'localhost:{port}' target = f'localhost:{port}'
# response = grpc.experimental.unary_unary( response = grpc.experimental.unary_unary(
# _REQUEST, target, _UNARY_UNARY, options=_property_options) _REQUEST, target, _UNARY_UNARY, options=_property_options)
# def test_insecure_sugar(self): def test_insecure_sugar(self):
# with _server(None) as port: with _server(None) as port:
# target = f'localhost:{port}' target = f'localhost:{port}'
# response = grpc.experimental.unary_unary(_REQUEST, response = grpc.experimental.unary_unary(_REQUEST,
# target, target,
# _UNARY_UNARY, _UNARY_UNARY,
# insecure=True) insecure=True)
# self.assertEqual(_REQUEST, response) self.assertEqual(_REQUEST, response)
# def test_insecure_sugar_mutually_exclusive(self): def test_insecure_sugar_mutually_exclusive(self):
# with _server(None) as port: with _server(None) as port:
# target = f'localhost:{port}' target = f'localhost:{port}'
# with self.assertRaises(ValueError): with self.assertRaises(ValueError):
# response = grpc.experimental.unary_unary( response = grpc.experimental.unary_unary(
# _REQUEST, _REQUEST,
# target, target,
# _UNARY_UNARY, _UNARY_UNARY,
# insecure=True, insecure=True,
# channel_credentials=grpc.local_channel_credentials()) channel_credentials=grpc.local_channel_credentials())
# def test_default_wait_for_ready(self): def test_default_wait_for_ready(self):
# addr, port, sock = get_socket() addr, port, sock = get_socket()
# sock.close() sock.close()
# target = f'{addr}:{port}' target = f'{addr}:{port}'
# channel = grpc._simple_stubs.ChannelCache.get().get_channel( channel = grpc._simple_stubs.ChannelCache.get().get_channel(
# target, (), None, True, None) target, (), None, True, None)
# rpc_finished_event = threading.Event() rpc_finished_event = threading.Event()
# rpc_failed_event = threading.Event() rpc_failed_event = threading.Event()
# server = None server = None
# def _on_connectivity_changed(connectivity): def _on_connectivity_changed(connectivity):
# nonlocal server nonlocal server
# if connectivity is grpc.ChannelConnectivity.TRANSIENT_FAILURE: if connectivity is grpc.ChannelConnectivity.TRANSIENT_FAILURE:
# self.assertFalse(rpc_finished_event.is_set()) self.assertFalse(rpc_finished_event.is_set())
# self.assertFalse(rpc_failed_event.is_set()) self.assertFalse(rpc_failed_event.is_set())
# server = test_common.test_server() server = test_common.test_server()
# server.add_insecure_port(target) server.add_insecure_port(target)
# server.add_generic_rpc_handlers((_GenericHandler(),)) server.add_generic_rpc_handlers((_GenericHandler(),))
# server.start() server.start()
# channel.unsubscribe(_on_connectivity_changed) channel.unsubscribe(_on_connectivity_changed)
# elif connectivity in (grpc.ChannelConnectivity.IDLE, elif connectivity in (grpc.ChannelConnectivity.IDLE,
# grpc.ChannelConnectivity.CONNECTING): grpc.ChannelConnectivity.CONNECTING):
# pass pass
# else: else:
# self.fail("Encountered unknown state.") self.fail("Encountered unknown state.")
# channel.subscribe(_on_connectivity_changed) channel.subscribe(_on_connectivity_changed)
# def _send_rpc(): def _send_rpc():
# try: try:
# response = grpc.experimental.unary_unary(_REQUEST, response = grpc.experimental.unary_unary(_REQUEST,
# target, target,
# _UNARY_UNARY, _UNARY_UNARY,
# insecure=True) insecure=True)
# rpc_finished_event.set() rpc_finished_event.set()
# except Exception as e: except Exception as e:
# rpc_failed_event.set() rpc_failed_event.set()
# t = threading.Thread(target=_send_rpc) t = threading.Thread(target=_send_rpc)
# t.start() t.start()
# t.join() t.join()
# self.assertFalse(rpc_failed_event.is_set()) self.assertFalse(rpc_failed_event.is_set())
# self.assertTrue(rpc_finished_event.is_set()) self.assertTrue(rpc_finished_event.is_set())
# if server is not None: if server is not None:
# server.stop(None) server.stop(None)
def assert_times_out(self, invocation_args): def assert_times_out(self, invocation_args):
with _server(None) as port: with _server(None) as port:

Write Preview
Loading…
Cancel
Save