pw_rpc/py/tests/client_test.py - pigweed/pigweed - Git at Google

 #!/usr/bin/env python3
 # Copyright 2020 The Pigweed Authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); you may not
 # use this file except in compliance with the License. You may obtain a copy of
 # the License at
 #
 #     https://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 # License for the specific language governing permissions and limitations under
 # the License.
 """Tests creating pw_rpc client."""

 import unittest
 from typing import Any, Callable

 from pw_protobuf_compiler import python_protos
 from pw_status import Status

 from pw_rpc import callback_client, client, packets
 import pw_rpc.ids
 from pw_rpc.internal.packet_pb2 import PacketType, RpcPacket

 RpcIds = packets.RpcIds

 TEST_PROTO_1 = """\
 syntax = "proto3";

 package pw.test1;

 message SomeMessage {
   uint32 magic_number = 1;
 }

 message AnotherMessage {
   enum Result {
     FAILED = 0;
     FAILED_MISERABLY = 1;
     I_DONT_WANT_TO_TALK_ABOUT_IT = 2;
   }

   Result result = 1;
   string payload = 2;
 }

 service PublicService {
   rpc SomeUnary(SomeMessage) returns (AnotherMessage) {}
   rpc SomeServerStreaming(SomeMessage) returns (stream AnotherMessage) {}
   rpc SomeClientStreaming(stream SomeMessage) returns (AnotherMessage) {}
   rpc SomeBidiStreaming(stream SomeMessage) returns (stream AnotherMessage) {}
 }
 """

 TEST_PROTO_2 = """\
 syntax = "proto2";

 package pw.test2;

 message Request {
   optional float magic_number = 1;
 }

 message Response {
 }

 service Alpha {
   rpc Unary(Request) returns (Response) {}
 }

 service Bravo {
   rpc BidiStreaming(stream Request) returns (stream Response) {}
 }
 """

 SOME_CHANNEL_ID: int = 237
 SOME_SERVICE_ID: int = 193
 SOME_METHOD_ID: int = 769
 SOME_CALL_ID: int = 452

 CLIENT_FIRST_CHANNEL_ID: int = 557
 CLIENT_SECOND_CHANNEL_ID: int = 474


 def create_protos() -> Any:
     return python_protos.Library.from_strings([TEST_PROTO_1, TEST_PROTO_2])


 def create_client(
     proto_modules: Any,
     first_channel_output_fn: Callable[[bytes], Any] | None = None,
 ) -> client.Client:
     return client.Client.from_modules(
         callback_client.Impl(),
         [
             client.Channel(CLIENT_FIRST_CHANNEL_ID, first_channel_output_fn),
             client.Channel(CLIENT_SECOND_CHANNEL_ID, lambda _: None),
         ],
         proto_modules,
     )


 class ChannelClientTest(unittest.TestCase):
     """Tests the ChannelClient."""

     def setUp(self) -> None:
         client_instance = create_client(create_protos().modules())
         self._channel_client: client.ChannelClient = client_instance.channel(
             CLIENT_FIRST_CHANNEL_ID
         )

     def test_access_service_client_as_attribute_or_index(self) -> None:
         self.assertIs(
             self._channel_client.rpcs.pw.test1.PublicService,
             self._channel_client.rpcs['pw.test1.PublicService'],
         )
         self.assertIs(
             self._channel_client.rpcs.pw.test1.PublicService,
             self._channel_client.rpcs[
                 pw_rpc.ids.calculate('pw.test1.PublicService')
             ],
         )

     def test_access_method_client_as_attribute_or_index(self) -> None:
         self.assertIs(
             self._channel_client.rpcs.pw.test2.Alpha.Unary,
             self._channel_client.rpcs['pw.test2.Alpha']['Unary'],
         )
         self.assertIs(
             self._channel_client.rpcs.pw.test2.Alpha.Unary,
             self._channel_client.rpcs['pw.test2.Alpha'][
                 pw_rpc.ids.calculate('Unary')
             ],
         )

     def test_service_name(self) -> None:
         self.assertEqual(
             self._channel_client.rpcs.pw.test2.Alpha.Unary.service.name, 'Alpha'
         )
         self.assertEqual(
             self._channel_client.rpcs.pw.test2.Alpha.Unary.service.full_name,
             'pw.test2.Alpha',
         )

     def test_method_name(self) -> None:
         self.assertEqual(
             self._channel_client.rpcs.pw.test2.Alpha.Unary.method.name, 'Unary'
         )
         self.assertEqual(
             self._channel_client.rpcs.pw.test2.Alpha.Unary.method.full_name,
             'pw.test2.Alpha.Unary',
         )

     def test_iterate_over_all_methods(self) -> None:
         channel_client = self._channel_client
         all_methods = {
             channel_client.rpcs.pw.test1.PublicService.SomeUnary,
             channel_client.rpcs.pw.test1.PublicService.SomeServerStreaming,
             channel_client.rpcs.pw.test1.PublicService.SomeClientStreaming,
             channel_client.rpcs.pw.test1.PublicService.SomeBidiStreaming,
             channel_client.rpcs.pw.test2.Alpha.Unary,
             channel_client.rpcs.pw.test2.Bravo.BidiStreaming,
         }
         self.assertEqual(set(channel_client.methods()), all_methods)

     def test_check_for_presence_of_services(self) -> None:
         self.assertIn('pw.test1.PublicService', self._channel_client.rpcs)
         self.assertIn(
             pw_rpc.ids.calculate('pw.test1.PublicService'),
             self._channel_client.rpcs,
         )

     def test_check_for_presence_of_missing_services(self) -> None:
         self.assertNotIn('PublicService', self._channel_client.rpcs)
         self.assertNotIn('NotAService', self._channel_client.rpcs)
         self.assertNotIn(-1213, self._channel_client.rpcs)

     def test_check_for_presence_of_methods(self) -> None:
         service = self._channel_client.rpcs.pw.test1.PublicService
         self.assertIn('SomeUnary', service)
         self.assertIn(pw_rpc.ids.calculate('SomeUnary'), service)

     def test_check_for_presence_of_missing_methods(self) -> None:
         service = self._channel_client.rpcs.pw.test1.PublicService
         self.assertNotIn('Some', service)
         self.assertNotIn('Unary', service)
         self.assertNotIn(12345, service)

     def test_method_fully_qualified_name(self) -> None:
         self.assertIs(
             self._channel_client.method('pw.test2.Alpha/Unary'),
             self._channel_client.rpcs.pw.test2.Alpha.Unary,
         )
         self.assertIs(
             self._channel_client.method('pw.test2.Alpha.Unary'),
             self._channel_client.rpcs.pw.test2.Alpha.Unary,
         )


 class ClientTest(unittest.TestCase):
     """Tests the pw_rpc Client independently of the ClientImpl."""

     def setUp(self) -> None:
         self._last_packet_sent_bytes: bytes | None = None
         self._protos = create_protos()
         self._client = create_client(self._protos.modules(), self._save_packet)

     def _save_packet(self, packet) -> None:
         self._last_packet_sent_bytes = packet

     def _last_packet_sent(self) -> RpcPacket:
         packet = RpcPacket()
         assert self._last_packet_sent_bytes is not None
         packet.MergeFromString(self._last_packet_sent_bytes)
         return packet

     def test_channel(self) -> None:
         self.assertEqual(
             self._client.channel(CLIENT_FIRST_CHANNEL_ID).channel.id,
             CLIENT_FIRST_CHANNEL_ID,
         )
         self.assertEqual(
             self._client.channel(CLIENT_SECOND_CHANNEL_ID).channel.id,
             CLIENT_SECOND_CHANNEL_ID,
         )

     def test_channel_default_is_first_listed(self) -> None:
         self.assertEqual(
             self._client.channel().channel.id, CLIENT_FIRST_CHANNEL_ID
         )

     def test_channel_invalid(self) -> None:
         with self.assertRaises(KeyError):
             self._client.channel(404)

     def test_all_methods(self) -> None:
         services = self._client.services

         all_methods = {
             services['pw.test1.PublicService'].methods['SomeUnary'],
             services['pw.test1.PublicService'].methods['SomeServerStreaming'],
             services['pw.test1.PublicService'].methods['SomeClientStreaming'],
             services['pw.test1.PublicService'].methods['SomeBidiStreaming'],
             services['pw.test2.Alpha'].methods['Unary'],
             services['pw.test2.Bravo'].methods['BidiStreaming'],
         }
         self.assertEqual(set(self._client.methods()), all_methods)

     def test_method_present(self) -> None:
         self.assertIs(
             self._client.method('pw.test1.PublicService.SomeUnary'),
             self._client.services['pw.test1.PublicService'].methods[
                 'SomeUnary'
             ],
         )
         self.assertIs(
             self._client.method('pw.test1.PublicService/SomeUnary'),
             self._client.services['pw.test1.PublicService'].methods[
                 'SomeUnary'
             ],
         )

     def test_method_invalid_format(self) -> None:
         with self.assertRaises(ValueError):
             self._client.method('SomeUnary')

     def test_method_not_present(self) -> None:
         with self.assertRaises(KeyError):
             self._client.method('pw.test1.PublicService/ThisIsNotGood')

         with self.assertRaises(KeyError):
             self._client.method('nothing.Good')

     def test_process_packet_invalid_proto_data(self) -> None:
         self.assertIs(
             self._client.process_packet(b'NOT a packet!'), Status.DATA_LOSS
         )

     def test_process_packet_not_for_client(self) -> None:
         self.assertIs(
             self._client.process_packet(
                 RpcPacket(type=PacketType.REQUEST).SerializeToString()
             ),
             Status.INVALID_ARGUMENT,
         )

     def test_process_packet_unrecognized_channel(self) -> None:
         self.assertIs(
             self._client.process_packet(
                 packets.encode_response(
                     RpcIds(
                         SOME_CHANNEL_ID,
                         SOME_SERVICE_ID,
                         SOME_METHOD_ID,
                         SOME_CALL_ID,
                     ),
                     self._protos.packages.pw.test2.Request(),
                 )
             ),
             Status.NOT_FOUND,
         )

     def test_process_packet_unrecognized_service(self) -> None:
         self.assertIs(
             self._client.process_packet(
                 packets.encode_response(
                     RpcIds(
                         CLIENT_FIRST_CHANNEL_ID,
                         SOME_SERVICE_ID,
                         SOME_METHOD_ID,
                         SOME_CALL_ID,
                     ),
                     self._protos.packages.pw.test2.Request(),
                 )
             ),
             Status.OK,
         )

         self.assertEqual(
             self._last_packet_sent(),
             RpcPacket(
                 type=PacketType.CLIENT_ERROR,
                 channel_id=CLIENT_FIRST_CHANNEL_ID,
                 service_id=SOME_SERVICE_ID,
                 method_id=SOME_METHOD_ID,
                 call_id=SOME_CALL_ID,
                 status=Status.NOT_FOUND.value,
             ),
         )

     def test_process_packet_unrecognized_method(self) -> None:
         service = next(iter(self._client.services))

         self.assertIs(
             self._client.process_packet(
                 packets.encode_response(
                     RpcIds(
                         CLIENT_FIRST_CHANNEL_ID,
                         service.id,
                         SOME_METHOD_ID,
                         SOME_CALL_ID,
                     ),
                     self._protos.packages.pw.test2.Request(),
                 )
             ),
             Status.OK,
         )

         self.assertEqual(
             self._last_packet_sent(),
             RpcPacket(
                 type=PacketType.CLIENT_ERROR,
                 channel_id=CLIENT_FIRST_CHANNEL_ID,
                 service_id=service.id,
                 method_id=SOME_METHOD_ID,
                 call_id=SOME_CALL_ID,
                 status=Status.NOT_FOUND.value,
             ),
         )

     def test_process_packet_non_pending_method(self) -> None:
         service = next(iter(self._client.services))
         method = next(iter(service.methods))

         self.assertIs(
             self._client.process_packet(
                 packets.encode_response(
                     RpcIds(
                         CLIENT_FIRST_CHANNEL_ID,
                         service.id,
                         method.id,
                         SOME_CALL_ID,
                     ),
                     self._protos.packages.pw.test2.Request(),
                 )
             ),
             Status.OK,
         )

         self.assertEqual(
             self._last_packet_sent(),
             RpcPacket(
                 type=PacketType.CLIENT_ERROR,
                 channel_id=CLIENT_FIRST_CHANNEL_ID,
                 service_id=service.id,
                 method_id=method.id,
                 call_id=SOME_CALL_ID,
                 status=Status.FAILED_PRECONDITION.value,
             ),
         )

     def test_process_packet_non_pending_calls_response_callback(self) -> None:
         method = self._client.method('pw.test1.PublicService.SomeUnary')
         reply = method.response_type(payload='hello')

         def response_callback(
             rpc: client.PendingRpc,
             message,
             status: Status | None,
         ) -> None:
             self.assertEqual(
                 rpc,
                 client.PendingRpc(
                     self._client.channel(CLIENT_FIRST_CHANNEL_ID).channel,
                     method.service,
                     method,
                     call_id=SOME_CALL_ID,
                 ),
             )
             self.assertEqual(message, reply)
             self.assertIs(status, Status.OK)

         self._client.response_callback = response_callback

         self.assertIs(
             self._client.process_packet(
                 packets.encode_response(
                     RpcIds(
                         CLIENT_FIRST_CHANNEL_ID,
                         method.service.id,
                         method.id,
                         SOME_CALL_ID,
                     ),
                     reply,
                 )
             ),
             Status.OK,
         )


 if __name__ == '__main__':
     unittest.main()
	#!/usr/bin/env python3
	# Copyright 2020 The Pigweed Authors
	#
	# Licensed under the Apache License, Version 2.0 (the "License"); you may not
	# use this file except in compliance with the License. You may obtain a copy of
	# the License at
	#
	# https://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	# License for the specific language governing permissions and limitations under
	# the License.
	"""Tests creating pw_rpc client."""

	import unittest
	from typing import Any, Callable

	from pw_protobuf_compiler import python_protos
	from pw_status import Status

	from pw_rpc import callback_client, client, packets
	import pw_rpc.ids
	from pw_rpc.internal.packet_pb2 import PacketType, RpcPacket

	RpcIds = packets.RpcIds

	TEST_PROTO_1 = """\
	syntax = "proto3";

	package pw.test1;

	message SomeMessage {
	uint32 magic_number = 1;
	}

	message AnotherMessage {
	enum Result {
	FAILED = 0;
	FAILED_MISERABLY = 1;
	I_DONT_WANT_TO_TALK_ABOUT_IT = 2;
	}

	Result result = 1;
	string payload = 2;
	}

	service PublicService {
	rpc SomeUnary(SomeMessage) returns (AnotherMessage) {}
	rpc SomeServerStreaming(SomeMessage) returns (stream AnotherMessage) {}
	rpc SomeClientStreaming(stream SomeMessage) returns (AnotherMessage) {}
	rpc SomeBidiStreaming(stream SomeMessage) returns (stream AnotherMessage) {}
	}
	"""

	TEST_PROTO_2 = """\
	syntax = "proto2";

	package pw.test2;

	message Request {
	optional float magic_number = 1;
	}

	message Response {
	}

	service Alpha {
	rpc Unary(Request) returns (Response) {}
	}

	service Bravo {
	rpc BidiStreaming(stream Request) returns (stream Response) {}
	}
	"""

	SOME_CHANNEL_ID: int = 237
	SOME_SERVICE_ID: int = 193
	SOME_METHOD_ID: int = 769
	SOME_CALL_ID: int = 452

	CLIENT_FIRST_CHANNEL_ID: int = 557
	CLIENT_SECOND_CHANNEL_ID: int = 474


	def create_protos() -> Any:
	return python_protos.Library.from_strings([TEST_PROTO_1, TEST_PROTO_2])


	def create_client(
	proto_modules: Any,
	first_channel_output_fn: Callable[[bytes], Any] \| None = None,
	) -> client.Client:
	return client.Client.from_modules(
	callback_client.Impl(),
	[
	client.Channel(CLIENT_FIRST_CHANNEL_ID, first_channel_output_fn),
	client.Channel(CLIENT_SECOND_CHANNEL_ID, lambda _: None),
	],
	proto_modules,
	)


	class ChannelClientTest(unittest.TestCase):
	"""Tests the ChannelClient."""

	def setUp(self) -> None:
	client_instance = create_client(create_protos().modules())
	self._channel_client: client.ChannelClient = client_instance.channel(
	CLIENT_FIRST_CHANNEL_ID
	)

	def test_access_service_client_as_attribute_or_index(self) -> None:
	self.assertIs(
	self._channel_client.rpcs.pw.test1.PublicService,
	self._channel_client.rpcs['pw.test1.PublicService'],
	)
	self.assertIs(
	self._channel_client.rpcs.pw.test1.PublicService,
	self._channel_client.rpcs[
	pw_rpc.ids.calculate('pw.test1.PublicService')
	],
	)

	def test_access_method_client_as_attribute_or_index(self) -> None:
	self.assertIs(
	self._channel_client.rpcs.pw.test2.Alpha.Unary,
	self._channel_client.rpcs['pw.test2.Alpha']['Unary'],
	)
	self.assertIs(
	self._channel_client.rpcs.pw.test2.Alpha.Unary,
	self._channel_client.rpcs['pw.test2.Alpha'][
	pw_rpc.ids.calculate('Unary')
	],
	)

	def test_service_name(self) -> None:
	self.assertEqual(
	self._channel_client.rpcs.pw.test2.Alpha.Unary.service.name, 'Alpha'
	)
	self.assertEqual(
	self._channel_client.rpcs.pw.test2.Alpha.Unary.service.full_name,
	'pw.test2.Alpha',
	)

	def test_method_name(self) -> None:
	self.assertEqual(
	self._channel_client.rpcs.pw.test2.Alpha.Unary.method.name, 'Unary'
	)
	self.assertEqual(
	self._channel_client.rpcs.pw.test2.Alpha.Unary.method.full_name,
	'pw.test2.Alpha.Unary',
	)

	def test_iterate_over_all_methods(self) -> None:
	channel_client = self._channel_client
	all_methods = {
	channel_client.rpcs.pw.test1.PublicService.SomeUnary,
	channel_client.rpcs.pw.test1.PublicService.SomeServerStreaming,
	channel_client.rpcs.pw.test1.PublicService.SomeClientStreaming,
	channel_client.rpcs.pw.test1.PublicService.SomeBidiStreaming,
	channel_client.rpcs.pw.test2.Alpha.Unary,
	channel_client.rpcs.pw.test2.Bravo.BidiStreaming,
	}
	self.assertEqual(set(channel_client.methods()), all_methods)

	def test_check_for_presence_of_services(self) -> None:
	self.assertIn('pw.test1.PublicService', self._channel_client.rpcs)
	self.assertIn(
	pw_rpc.ids.calculate('pw.test1.PublicService'),
	self._channel_client.rpcs,
	)

	def test_check_for_presence_of_missing_services(self) -> None:
	self.assertNotIn('PublicService', self._channel_client.rpcs)
	self.assertNotIn('NotAService', self._channel_client.rpcs)
	self.assertNotIn(-1213, self._channel_client.rpcs)

	def test_check_for_presence_of_methods(self) -> None:
	service = self._channel_client.rpcs.pw.test1.PublicService
	self.assertIn('SomeUnary', service)
	self.assertIn(pw_rpc.ids.calculate('SomeUnary'), service)

	def test_check_for_presence_of_missing_methods(self) -> None:
	service = self._channel_client.rpcs.pw.test1.PublicService
	self.assertNotIn('Some', service)
	self.assertNotIn('Unary', service)
	self.assertNotIn(12345, service)

	def test_method_fully_qualified_name(self) -> None:
	self.assertIs(
	self._channel_client.method('pw.test2.Alpha/Unary'),
	self._channel_client.rpcs.pw.test2.Alpha.Unary,
	)
	self.assertIs(
	self._channel_client.method('pw.test2.Alpha.Unary'),
	self._channel_client.rpcs.pw.test2.Alpha.Unary,
	)


	class ClientTest(unittest.TestCase):
	"""Tests the pw_rpc Client independently of the ClientImpl."""

	def setUp(self) -> None:
	self._last_packet_sent_bytes: bytes \| None = None
	self._protos = create_protos()
	self._client = create_client(self._protos.modules(), self._save_packet)

	def _save_packet(self, packet) -> None:
	self._last_packet_sent_bytes = packet

	def _last_packet_sent(self) -> RpcPacket:
	packet = RpcPacket()
	assert self._last_packet_sent_bytes is not None
	packet.MergeFromString(self._last_packet_sent_bytes)
	return packet

	def test_channel(self) -> None:
	self.assertEqual(
	self._client.channel(CLIENT_FIRST_CHANNEL_ID).channel.id,
	CLIENT_FIRST_CHANNEL_ID,
	)
	self.assertEqual(
	self._client.channel(CLIENT_SECOND_CHANNEL_ID).channel.id,
	CLIENT_SECOND_CHANNEL_ID,
	)

	def test_channel_default_is_first_listed(self) -> None:
	self.assertEqual(
	self._client.channel().channel.id, CLIENT_FIRST_CHANNEL_ID
	)

	def test_channel_invalid(self) -> None:
	with self.assertRaises(KeyError):
	self._client.channel(404)

	def test_all_methods(self) -> None:
	services = self._client.services

	all_methods = {
	services['pw.test1.PublicService'].methods['SomeUnary'],
	services['pw.test1.PublicService'].methods['SomeServerStreaming'],
	services['pw.test1.PublicService'].methods['SomeClientStreaming'],
	services['pw.test1.PublicService'].methods['SomeBidiStreaming'],
	services['pw.test2.Alpha'].methods['Unary'],
	services['pw.test2.Bravo'].methods['BidiStreaming'],
	}
	self.assertEqual(set(self._client.methods()), all_methods)

	def test_method_present(self) -> None:
	self.assertIs(
	self._client.method('pw.test1.PublicService.SomeUnary'),
	self._client.services['pw.test1.PublicService'].methods[
	'SomeUnary'
	],
	)
	self.assertIs(
	self._client.method('pw.test1.PublicService/SomeUnary'),
	self._client.services['pw.test1.PublicService'].methods[
	'SomeUnary'
	],
	)

	def test_method_invalid_format(self) -> None:
	with self.assertRaises(ValueError):
	self._client.method('SomeUnary')

	def test_method_not_present(self) -> None:
	with self.assertRaises(KeyError):
	self._client.method('pw.test1.PublicService/ThisIsNotGood')

	with self.assertRaises(KeyError):
	self._client.method('nothing.Good')

	def test_process_packet_invalid_proto_data(self) -> None:
	self.assertIs(
	self._client.process_packet(b'NOT a packet!'), Status.DATA_LOSS
	)

	def test_process_packet_not_for_client(self) -> None:
	self.assertIs(
	self._client.process_packet(
	RpcPacket(type=PacketType.REQUEST).SerializeToString()
	),
	Status.INVALID_ARGUMENT,
	)

	def test_process_packet_unrecognized_channel(self) -> None:
	self.assertIs(
	self._client.process_packet(
	packets.encode_response(
	RpcIds(
	SOME_CHANNEL_ID,
	SOME_SERVICE_ID,
	SOME_METHOD_ID,
	SOME_CALL_ID,
	),
	self._protos.packages.pw.test2.Request(),
	)
	),
	Status.NOT_FOUND,
	)

	def test_process_packet_unrecognized_service(self) -> None:
	self.assertIs(
	self._client.process_packet(
	packets.encode_response(
	RpcIds(
	CLIENT_FIRST_CHANNEL_ID,
	SOME_SERVICE_ID,
	SOME_METHOD_ID,
	SOME_CALL_ID,
	),
	self._protos.packages.pw.test2.Request(),
	)
	),
	Status.OK,
	)

	self.assertEqual(
	self._last_packet_sent(),
	RpcPacket(
	type=PacketType.CLIENT_ERROR,
	channel_id=CLIENT_FIRST_CHANNEL_ID,
	service_id=SOME_SERVICE_ID,
	method_id=SOME_METHOD_ID,
	call_id=SOME_CALL_ID,
	status=Status.NOT_FOUND.value,
	),
	)

	def test_process_packet_unrecognized_method(self) -> None:
	service = next(iter(self._client.services))

	self.assertIs(
	self._client.process_packet(
	packets.encode_response(
	RpcIds(
	CLIENT_FIRST_CHANNEL_ID,
	service.id,
	SOME_METHOD_ID,
	SOME_CALL_ID,
	),
	self._protos.packages.pw.test2.Request(),
	)
	),
	Status.OK,
	)

	self.assertEqual(
	self._last_packet_sent(),
	RpcPacket(
	type=PacketType.CLIENT_ERROR,
	channel_id=CLIENT_FIRST_CHANNEL_ID,
	service_id=service.id,
	method_id=SOME_METHOD_ID,
	call_id=SOME_CALL_ID,
	status=Status.NOT_FOUND.value,
	),
	)

	def test_process_packet_non_pending_method(self) -> None:
	service = next(iter(self._client.services))
	method = next(iter(service.methods))

	self.assertIs(
	self._client.process_packet(
	packets.encode_response(
	RpcIds(
	CLIENT_FIRST_CHANNEL_ID,
	service.id,
	method.id,
	SOME_CALL_ID,
	),
	self._protos.packages.pw.test2.Request(),
	)
	),
	Status.OK,
	)

	self.assertEqual(
	self._last_packet_sent(),
	RpcPacket(
	type=PacketType.CLIENT_ERROR,
	channel_id=CLIENT_FIRST_CHANNEL_ID,
	service_id=service.id,
	method_id=method.id,
	call_id=SOME_CALL_ID,
	status=Status.FAILED_PRECONDITION.value,
	),
	)

	def test_process_packet_non_pending_calls_response_callback(self) -> None:
	method = self._client.method('pw.test1.PublicService.SomeUnary')
	reply = method.response_type(payload='hello')

	def response_callback(
	rpc: client.PendingRpc,
	message,
	status: Status \| None,
	) -> None:
	self.assertEqual(
	rpc,
	client.PendingRpc(
	self._client.channel(CLIENT_FIRST_CHANNEL_ID).channel,
	method.service,
	method,
	call_id=SOME_CALL_ID,
	),
	)
	self.assertEqual(message, reply)
	self.assertIs(status, Status.OK)

	self._client.response_callback = response_callback

	self.assertIs(
	self._client.process_packet(
	packets.encode_response(
	RpcIds(
	CLIENT_FIRST_CHANNEL_ID,
	method.service.id,
	method.id,
	SOME_CALL_ID,
	),
	reply,
	)
	),
	Status.OK,
	)


	if __name__ == '__main__':
	unittest.main()