async def test_invalid_query_get_channel(self):
with self.assertRaises(aio.AioRpcError) as exception_context:
await self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=_LARGE_UNASSIGNED_ID)
)
self.assertEqual(grpc.StatusCode.NOT_FOUND,
exception_context.exception.code())
async def test_streaming_rpc(self):
pairs = await _create_channel_server_pairs(1, self._channelz_stub)
# In C++, the argument for _send_successful_stream_stream is message length.
# Here the argument is still channel idx, to be consistent with the other two.
await self._send_successful_stream_stream(pairs[0])
gc_resp = await self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=pairs[0].channel_ref_id))
self.assertEqual(gc_resp.channel.data.calls_started, 1)
self.assertEqual(gc_resp.channel.data.calls_succeeded, 1)
self.assertEqual(gc_resp.channel.data.calls_failed, 0)
# Subchannel exists
self.assertGreater(len(gc_resp.channel.subchannel_ref), 0)
gsc_resp = await self._channelz_stub.GetSubchannel(
channelz_pb2.GetSubchannelRequest(
subchannel_id=gc_resp.channel.subchannel_ref[0].subchannel_id))
self.assertEqual(gsc_resp.subchannel.data.calls_started, 1)
self.assertEqual(gsc_resp.subchannel.data.calls_succeeded, 1)
self.assertEqual(gsc_resp.subchannel.data.calls_failed, 0)
# Socket exists
self.assertEqual(len(gsc_resp.subchannel.socket_ref), 1)
gs_resp = await self._channelz_stub.GetSocket(
channelz_pb2.GetSocketRequest(
socket_id=gsc_resp.subchannel.socket_ref[0].socket_id))
self.assertEqual(gs_resp.socket.data.streams_started, 1)
self.assertEqual(gs_resp.socket.data.streams_succeeded, 1)
self.assertEqual(gs_resp.socket.data.streams_failed, 0)
self.assertEqual(gs_resp.socket.data.messages_sent,
test_constants.STREAM_LENGTH)
self.assertEqual(gs_resp.socket.data.messages_received,
test_constants.STREAM_LENGTH)
await _destroy_channel_server_pairs(pairs)
def test_invalid_query_get_channel(self):
try:
self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=10000))
except BaseException as e:
self.assertIn('StatusCode.NOT_FOUND', str(e))
else:
self.fail('Invalid query not detected')
def test_failed_request(self):
self._pairs = _generate_channel_server_pairs(1)
self._send_failed_unary_unary(0)
resp = self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=self._get_channel_id(0)))
self.assertEqual(resp.channel.data.calls_started, 1)
self.assertEqual(resp.channel.data.calls_succeeded, 0)
self.assertEqual(resp.channel.data.calls_failed, 1)
async def test_many_requests_many_channel(self):
k_channels = 4
pairs = await _create_channel_server_pairs(k_channels,
self._channelz_stub)
k_success = 11
k_failed = 13
for i in range(k_success):
await self._send_successful_unary_unary(pairs[0])
await self._send_successful_unary_unary(pairs[2])
for i in range(k_failed):
await self._send_failed_unary_unary(pairs[1])
await self._send_failed_unary_unary(pairs[2])
# The first channel saw only successes
resp = await self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=pairs[0].channel_ref_id))
self.assertEqual(resp.channel.data.calls_started, k_success)
self.assertEqual(resp.channel.data.calls_succeeded, k_success)
self.assertEqual(resp.channel.data.calls_failed, 0)
# The second channel saw only failures
resp = await self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=pairs[1].channel_ref_id))
self.assertEqual(resp.channel.data.calls_started, k_failed)
self.assertEqual(resp.channel.data.calls_succeeded, 0)
self.assertEqual(resp.channel.data.calls_failed, k_failed)
# The third channel saw both successes and failures
resp = await self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=pairs[2].channel_ref_id))
self.assertEqual(resp.channel.data.calls_started, k_success + k_failed)
self.assertEqual(resp.channel.data.calls_succeeded, k_success)
self.assertEqual(resp.channel.data.calls_failed, k_failed)
# The fourth channel saw nothing
resp = await self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=pairs[3].channel_ref_id))
self.assertEqual(resp.channel.data.calls_started, 0)
self.assertEqual(resp.channel.data.calls_succeeded, 0)
self.assertEqual(resp.channel.data.calls_failed, 0)
await _destroy_channel_server_pairs(pairs)
async def test_failed_request(self):
pairs = await _create_channel_server_pairs(1, self._channelz_stub)
await self._send_failed_unary_unary(pairs[0])
resp = await self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=pairs[0].channel_ref_id))
self.assertEqual(resp.channel.data.calls_started, 1)
self.assertEqual(resp.channel.data.calls_succeeded, 0)
self.assertEqual(resp.channel.data.calls_failed, 1)
await _destroy_channel_server_pairs(pairs)
def test_many_requests_many_channel(self):
k_channels = 4
self._pairs = _generate_channel_server_pairs(k_channels)
k_success = 11
k_failed = 13
for i in range(k_success):
self._send_successful_unary_unary(0)
self._send_successful_unary_unary(2)
for i in range(k_failed):
self._send_failed_unary_unary(1)
self._send_failed_unary_unary(2)
# The first channel saw only successes
resp = self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=self._get_channel_id(0)))
self.assertEqual(resp.channel.data.calls_started, k_success)
self.assertEqual(resp.channel.data.calls_succeeded, k_success)
self.assertEqual(resp.channel.data.calls_failed, 0)
# The second channel saw only failures
resp = self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=self._get_channel_id(1)))
self.assertEqual(resp.channel.data.calls_started, k_failed)
self.assertEqual(resp.channel.data.calls_succeeded, 0)
self.assertEqual(resp.channel.data.calls_failed, k_failed)
# The third channel saw both successes and failures
resp = self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=self._get_channel_id(2)))
self.assertEqual(resp.channel.data.calls_started, k_success + k_failed)
self.assertEqual(resp.channel.data.calls_succeeded, k_success)
self.assertEqual(resp.channel.data.calls_failed, k_failed)
# The fourth channel saw nothing
resp = self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=self._get_channel_id(3)))
self.assertEqual(resp.channel.data.calls_started, 0)
self.assertEqual(resp.channel.data.calls_succeeded, 0)
self.assertEqual(resp.channel.data.calls_failed, 0)
def test_many_requests(self):
self._pairs = _generate_channel_server_pairs(1)
k_success = 7
k_failed = 9
for i in range(k_success):
self._send_successful_unary_unary(0)
for i in range(k_failed):
self._send_failed_unary_unary(0)
resp = self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=self._get_channel_id(0)))
self.assertEqual(resp.channel.data.calls_started, k_success + k_failed)
self.assertEqual(resp.channel.data.calls_succeeded, k_success)
self.assertEqual(resp.channel.data.calls_failed, k_failed)
async def test_many_requests(self):
pairs = await _create_channel_server_pairs(1, self._channelz_stub)
k_success = 7
k_failed = 9
for i in range(k_success):
await self._send_successful_unary_unary(pairs[0])
for i in range(k_failed):
await self._send_failed_unary_unary(pairs[0])
resp = await self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=pairs[0].channel_ref_id))
self.assertEqual(resp.channel.data.calls_started, k_success + k_failed)
self.assertEqual(resp.channel.data.calls_succeeded, k_success)
self.assertEqual(resp.channel.data.calls_failed, k_failed)
await _destroy_channel_server_pairs(pairs)
async def test_many_subchannels_and_sockets(self):
k_channels = 4
pairs = await _create_channel_server_pairs(k_channels,
self._channelz_stub)
k_success = 3
k_failed = 5
for i in range(k_success):
await self._send_successful_unary_unary(pairs[0])
await self._send_successful_unary_unary(pairs[2])
for i in range(k_failed):
await self._send_failed_unary_unary(pairs[1])
await self._send_failed_unary_unary(pairs[2])
for i in range(k_channels):
gc_resp = await self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(
channel_id=pairs[i].channel_ref_id))
# If no call performed in the channel, there shouldn't be any subchannel
if gc_resp.channel.data.calls_started == 0:
self.assertEqual(len(gc_resp.channel.subchannel_ref), 0)
continue
# Otherwise, the subchannel should exist
self.assertGreater(len(gc_resp.channel.subchannel_ref), 0)
gsc_resp = await self._channelz_stub.GetSubchannel(
channelz_pb2.GetSubchannelRequest(
subchannel_id=gc_resp.channel.subchannel_ref[0].
subchannel_id))
self.assertEqual(len(gsc_resp.subchannel.socket_ref), 1)
gs_resp = await self._channelz_stub.GetSocket(
channelz_pb2.GetSocketRequest(
socket_id=gsc_resp.subchannel.socket_ref[0].socket_id))
self.assertEqual(gsc_resp.subchannel.data.calls_started,
gs_resp.socket.data.streams_started)
self.assertEqual(0, gs_resp.socket.data.streams_failed)
# Calls started == messages sent, only valid for unary calls
self.assertEqual(gsc_resp.subchannel.data.calls_started,
gs_resp.socket.data.messages_sent)
await _destroy_channel_server_pairs(pairs)
def test_streaming_rpc(self):
self._pairs = _generate_channel_server_pairs(1)
# In C++, the argument for _send_successful_stream_stream is message length.
# Here the argument is still channel idx, to be consistent with the other two.
self._send_successful_stream_stream(0)
gc_resp = self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(channel_id=self._get_channel_id(0)))
self.assertEqual(gc_resp.channel.data.calls_started, 1)
self.assertEqual(gc_resp.channel.data.calls_succeeded, 1)
self.assertEqual(gc_resp.channel.data.calls_failed, 0)
# Subchannel exists
self.assertGreater(len(gc_resp.channel.subchannel_ref), 0)
while True:
gsc_resp = self._channelz_stub.GetSubchannel(
channelz_pb2.GetSubchannelRequest(
subchannel_id=gc_resp.channel.subchannel_ref[0].
subchannel_id))
if gsc_resp.subchannel.data.calls_started == gsc_resp.subchannel.data.calls_succeeded + gsc_resp.subchannel.data.calls_failed:
break
self.assertEqual(gsc_resp.subchannel.data.calls_started, 1)
self.assertEqual(gsc_resp.subchannel.data.calls_failed, 0)
self.assertEqual(gsc_resp.subchannel.data.calls_succeeded, 1)
# Socket exists
self.assertEqual(len(gsc_resp.subchannel.socket_ref), 1)
while True:
gs_resp = self._channelz_stub.GetSocket(
channelz_pb2.GetSocketRequest(
socket_id=gsc_resp.subchannel.socket_ref[0].socket_id))
if gs_resp.socket.data.streams_started == gs_resp.socket.data.streams_succeeded + gs_resp.socket.data.streams_failed:
break
self.assertEqual(gs_resp.socket.data.streams_started, 1)
self.assertEqual(gs_resp.socket.data.streams_succeeded, 1)
self.assertEqual(gs_resp.socket.data.streams_failed, 0)
self.assertEqual(gs_resp.socket.data.messages_sent,
test_constants.STREAM_LENGTH)
self.assertEqual(gs_resp.socket.data.messages_received,
test_constants.STREAM_LENGTH)
async def test_many_subchannels(self):
k_channels = 4
pairs = await _create_channel_server_pairs(k_channels,
self._channelz_stub)
k_success = 17
k_failed = 19
for i in range(k_success):
await self._send_successful_unary_unary(pairs[0])
await self._send_successful_unary_unary(pairs[2])
for i in range(k_failed):
await self._send_failed_unary_unary(pairs[1])
await self._send_failed_unary_unary(pairs[2])
for i in range(k_channels):
gc_resp = await self._channelz_stub.GetChannel(
channelz_pb2.GetChannelRequest(
channel_id=pairs[i].channel_ref_id))
# If no call performed in the channel, there shouldn't be any subchannel
if gc_resp.channel.data.calls_started == 0:
self.assertEqual(len(gc_resp.channel.subchannel_ref), 0)
continue
# Otherwise, the subchannel should exist
self.assertGreater(len(gc_resp.channel.subchannel_ref), 0)
gsc_resp = await self._channelz_stub.GetSubchannel(
channelz_pb2.GetSubchannelRequest(
subchannel_id=gc_resp.channel.subchannel_ref[0].
subchannel_id))
self.assertEqual(gc_resp.channel.data.calls_started,
gsc_resp.subchannel.data.calls_started)
self.assertEqual(gc_resp.channel.data.calls_succeeded,
gsc_resp.subchannel.data.calls_succeeded)
self.assertEqual(gc_resp.channel.data.calls_failed,
gsc_resp.subchannel.data.calls_failed)
await _destroy_channel_server_pairs(pairs)
