blob: 34534b3c432c94de9eb84e5fb76e412843ea0c3e [file]
# Copyright 2023 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import abc
import asyncio
import typing
import unittest
from typing import Any
import fidl_fuchsia_controller_othertest as fc_othertest
import fidl_fuchsia_controller_test as fc_test
import fidl_fuchsia_developer_ffx as ffx
import fidl_fuchsia_io as f_io
from fidl import (
DomainError,
FrameworkError,
GlobalHandleWaker,
StopEventHandler,
)
from fuchsia_controller_py import Channel, Context, FcTransportStatus, ZxStatus
T = typing.TypeVar("T")
# TODO(https://fxbug.dev/407643032): Extract to separate library and add unit tests.
def implement_missing_abstract_methods(cls: type[T]) -> type[T]:
"""
Class decorator to implement missing abstract methods to satisfy ABC requirements for stubbing.
Identifies abstract methods defined in base classes (using MRO and __abstractmethods__) that are
not implemented directly in the decorated class and adds a default implementation that raises
NotImplementedError.
Note: This only provides *runtime* implementations. Mypy will still require
`# type: ignore[abstract]` at locations where a class is instantiated.
"""
# Collect all unique abstract method names from the MRO (Method Resolution Order)
abstract_method_names: set[str] = set()
for base in cls.__mro__:
if hasattr(base, "__abstractmethods__") and isinstance(
base.__abstractmethods__, frozenset
):
abstract_method_names.update(base.__abstractmethods__)
implemented_members = set(cls.__dict__.keys())
pre_missing_methods = abstract_method_names - implemented_members
# First pass to check if each method is actually abstract *at this point* in the MRO. This
# avoids issues when the MRO is complex, i.e., there are both abstract and concrete method
# implementations in the MRO.
missing_methods: list[str] = []
for name in pre_missing_methods:
try:
member = getattr(cls, name)
if not getattr(member, "__isabstractmethod__", False):
continue
except AttributeError:
pass
missing_methods.append(name)
# Final pass to implement each method by raising a verbose NotImplementedError
for name in missing_methods:
def make_default_impl(method_name: str) -> typing.Callable[..., Any]:
def default_impl(*args: list[Any], **kwargs: dict[str, Any]) -> Any:
raise NotImplementedError(
f"Abstract method '{method_name}' was auto-implemented "
f"in {cls.__name__} and called without override."
)
default_impl.__name__ = method_name
return default_impl
setattr(cls, name, make_default_impl(name))
return abc.update_abstractmethods(cls)
# [START echo_server_impl]
class TestEchoer(ffx.EchoServer):
def echo_string(
self, request: ffx.EchoEchoStringRequest
) -> ffx.EchoEchoStringResponse:
return ffx.EchoEchoStringResponse(response=request.value)
# [END echo_server_impl]
class AsyncEchoer(ffx.EchoServer):
async def echo_string(
self, request: ffx.EchoEchoStringRequest
) -> ffx.EchoEchoStringResponse:
await asyncio.sleep(0) # This isn't necessary, but it is fun.
return ffx.EchoEchoStringResponse(response=request.value)
class TargetCollectionReaderImpl(ffx.TargetCollectionReaderServer):
def __init__(
self, channel: Channel, target_list: list[ffx.TargetInfo]
) -> None:
super().__init__(channel)
self.target_list = target_list
def next_(self, request: ffx.TargetCollectionReaderNextRequest) -> None:
if request.entry:
self.target_list.extend(request.entry)
class TargetCollectionImpl(ffx.TargetCollectionServer):
async def list_targets(
self, request: ffx.TargetCollectionListTargetsRequest
) -> None:
reader = ffx.TargetCollectionReaderClient(request.reader)
await reader.next_(
entry=[
ffx.TargetInfo(nodename="foo"),
ffx.TargetInfo(nodename="bar"),
]
)
await reader.next_(
entry=[
ffx.TargetInfo(nodename="baz"),
]
)
await reader.next_(entry=[])
@implement_missing_abstract_methods
class StubFileServer(f_io.FileServer):
def read(
self, request: f_io.ReadableReadRequest
) -> f_io.ReadableReadResponse:
return f_io.ReadableReadResponse(data=[1, 2, 3, 4])
@implement_missing_abstract_methods
class NotImplementedCrossLibraryNoopServer(fc_othertest.CrossLibraryNoopServer):
...
@implement_missing_abstract_methods
class NotImplementedCrossLibraryNoopEventHandler(
fc_othertest.CrossLibraryNoopEventHandler
):
...
class TestEventHandler(fc_othertest.CrossLibraryNoopEventHandler):
def __init__(
self,
client: fc_othertest.CrossLibraryNoopClient,
random_event_handler: typing.Callable[
[fc_othertest.CrossLibraryNoopOnRandomEventRequest], None
],
):
super().__init__(client)
self.random_event_handler = random_event_handler
def on_random_event(
self, request: fc_othertest.CrossLibraryNoopOnRandomEventRequest
) -> None:
self.random_event_handler(request)
def on_empty_event(self) -> None:
raise StopEventHandler
@implement_missing_abstract_methods
class FailingFileServer(f_io.FileServer):
def read(self, _: f_io.ReadableReadRequest) -> DomainError:
return DomainError(FcTransportStatus.FC_ERR_FDOMAIN)
@implement_missing_abstract_methods
class TestingServer(fc_test.TestingServer):
def return_union(self) -> fc_test.TestingReturnUnionResponse:
return fc_test.TestingReturnUnionResponse(y="foobar")
def return_union_with_table(
self,
) -> fc_test.TestingReturnUnionWithTableResponse:
return fc_test.TestingReturnUnionWithTableResponse(
y=fc_test.NoopTable(str_="bazzz", integer=-2)
)
class ServerTests(unittest.IsolatedAsyncioTestCase):
def setUp(self) -> None:
waker = GlobalHandleWaker()
# See this method definition for why this is (currently) necessary.
# Ideally we wouldn't need to do this, but when running tests in new
# asyncio loop we're getting into situations where old queues are still
# in the handle waker dictionary.
waker._reset_for_testing()
async def test_echo_server_sync(self) -> None:
# [START use_echoer_example]
# The context is necessary in order to create channels and other
# emulated Zircon objects (sockets, events, etc). An empty context
# with no arguments creates a local container for these objects, and
# is sufficient for testing.
ctx = Context()
(tx, rx) = ctx.channel_create()
server = TestEchoer(rx)
client = ffx.EchoClient(tx)
server_task = asyncio.create_task(server.serve())
res = await client.echo_string(value="foobar")
self.assertEqual(res.response, "foobar")
server_task.cancel()
# [END use_echoer_example]
async def test_epitaph_propagation(self) -> None:
ctx = Context()
(tx, rx) = ctx.channel_create()
client = ffx.EchoClient(tx)
coro1 = client.echo_string(value="foobar")
# Creating a task here so at least one task is awaiting on a staged
# message/notification.
task = asyncio.create_task(client.echo_string(value="foobar"))
coro2 = client.echo_string(value="foobar")
# Put `task` onto the executor so it makes partial progress, since this will yield
# to the executor.
await asyncio.sleep(0)
err_msg = ZxStatus.ZX_ERR_NOT_SUPPORTED
rx.close_with_epitaph(err_msg)
# The main thing here is to ensure that FDOMAIN is not sent early.
# After running rx.close_with_epitaph, the channel will be closed, and
# that message will have been queued for the client.
with self.assertRaises(ZxStatus) as cm:
await coro1
self.assertEqual(cm.exception.args[0], err_msg)
with self.assertRaises(ZxStatus) as cm:
await task
self.assertEqual(cm.exception.args[0], err_msg)
with self.assertRaises(ZxStatus) as cm:
await coro2
self.assertEqual(cm.exception.args[0], err_msg)
# Finally, ensure that the channel is just plain-old closed for new
# interactions.
with self.assertRaises(FcTransportStatus) as cm: # type: ignore
await client.echo_string(value="foobar")
self.assertEqual(
cm.exception.args[0], FcTransportStatus.FC_ERR_CHANNEL_WRITE
)
async def test_echo_server_async(self) -> None:
ctx = Context()
(tx, rx) = ctx.channel_create()
server = AsyncEchoer(rx)
client = ffx.EchoClient(tx)
server_task = asyncio.create_task(server.serve())
res = await client.echo_string(value="foobar")
self.assertEqual(res.response, "foobar")
server_task.cancel()
# TODO(https://fxbug.dev/364878315): This test sends many messages to AsyncEchoer which causes
# many spurious wakeups as a side-effect. Having this test ensures ServerBase is resilient
# to spurious wakeups, even several at a time.
async def test_echo_server_async_stress(self) -> None:
ctx = Context()
(tx, rx) = ctx.channel_create()
server = AsyncEchoer(rx)
client = ffx.EchoClient(tx)
server_task = asyncio.create_task(server.serve())
for _ in range(12):
res = await client.echo_string(value="foobar")
self.assertEqual(res.response, "foobar")
server_task.cancel()
async def test_target_iterator(self) -> None:
ctx = Context()
(reader_client_channel, reader_server_channel) = ctx.channel_create()
target_list: typing.List[typing.Any] = []
server = TargetCollectionReaderImpl(reader_server_channel, target_list)
(tc_client_channel, tc_server_channel) = ctx.channel_create()
target_collection_server = TargetCollectionImpl(tc_server_channel)
reader_task = asyncio.create_task(server.serve())
tc_task = asyncio.create_task(target_collection_server.serve())
tc_client = ffx.TargetCollectionClient(tc_client_channel)
tc_client.list_targets(
query=ffx.TargetQuery(), reader=reader_client_channel.take()
)
# Wait for the reader to finish processing all messages
await asyncio.wait_for(reader_task, timeout=5.0)
# Clean up the server task which is still waiting for more requests
tc_task.cancel()
self.assertEqual(len(target_list), 3)
foo_targets = [x for x in target_list if x.nodename == "foo"]
self.assertEqual(len(foo_targets), 1)
bar_targets = [x for x in target_list if x.nodename == "bar"]
self.assertEqual(len(bar_targets), 1)
baz_targets = [x for x in target_list if x.nodename == "baz"]
self.assertEqual(len(baz_targets), 1)
async def test_file_server(self) -> None:
# This handles the kind of case where a method has a signature of `-> (data) error Error;`
ctx = Context()
client, server = ctx.channel_create()
file_proxy = f_io.FileClient(client)
print(StubFileServer.get_flags)
file_server = StubFileServer(server) # type: ignore[abstract]
server_task = asyncio.create_task(file_server.serve())
response = (await file_proxy.read(count=4)).unwrap()
self.assertEqual(response.data, [1, 2, 3, 4])
server_task.cancel()
async def test_failing_file_server(self) -> None:
ctx = Context()
client, server = ctx.channel_create()
file_proxy = f_io.FileClient(client)
file_server = FailingFileServer(server) # type: ignore[abstract]
server_task = asyncio.create_task(file_server.serve())
result = await file_proxy.read(count=4)
self.assertEqual(result.err, FcTransportStatus.FC_ERR_FDOMAIN)
server_task.cancel()
async def test_testing_server(self) -> None:
ctx = Context()
client, server = ctx.channel_create()
t_client = fc_test.TestingClient(client)
t_server = TestingServer(server) # type: ignore[abstract]
server_task = asyncio.create_task(t_server.serve())
return_union_response = await t_client.return_union()
assert return_union_response.y is not None
self.assertEqual(return_union_response.y, "foobar")
return_union_with_table_response = (
await t_client.return_union_with_table()
)
assert return_union_with_table_response.y is not None
self.assertEqual(return_union_with_table_response.y.str_, "bazzz")
self.assertEqual(return_union_with_table_response.y.integer, -2)
server_task.cancel()
async def test_flexible_method_framework_err(self) -> None:
@implement_missing_abstract_methods
class FlexibleMethodTesterServer(fc_test.FlexibleMethodTesterServer):
def some_method(self) -> FrameworkError:
# This should be handled internally, but right now there's not really
# a good way to force this interaction without making multiple FIDL
# versions run in this program simultaneously somehow.
return FrameworkError.UNKNOWN_METHOD
def some_method_without_error(self) -> FrameworkError:
return FrameworkError.UNKNOWN_METHOD
def some_method_just_error(self) -> FrameworkError:
return FrameworkError.UNKNOWN_METHOD
ctx = Context()
client, server = ctx.channel_create()
t_client = fc_test.FlexibleMethodTesterClient(client)
t_server = FlexibleMethodTesterServer(server) # type: ignore[abstract]
server_task = asyncio.create_task(t_server.serve())
res1 = await t_client.some_method()
self.assertEqual(res1.framework_err, FrameworkError.UNKNOWN_METHOD)
res2 = await t_client.some_method_without_error()
self.assertEqual(res2.framework_err, FrameworkError.UNKNOWN_METHOD)
res3 = await t_client.some_method_just_error()
self.assertEqual(res3.framework_err, FrameworkError.UNKNOWN_METHOD)
server_task.cancel()
async def test_flexible_method_unwrap_response(self) -> None:
@implement_missing_abstract_methods
class FlexibleMethodTesterServer(fc_test.FlexibleMethodTesterServer):
def some_method(
self,
) -> fc_test.FlexibleMethodTesterSomeMethodResponse:
return fc_test.FlexibleMethodTesterSomeMethodResponse(
some_bool_value=True
)
def some_method_without_error(
self,
) -> fc_test.FlexibleMethodTesterSomeMethodWithoutErrorResponse:
return (
fc_test.FlexibleMethodTesterSomeMethodWithoutErrorResponse(
some_bool_value=False
)
)
def some_method_just_error(self) -> None:
return
ctx = Context()
client, server = ctx.channel_create()
t_client = fc_test.FlexibleMethodTesterClient(client)
t_server = FlexibleMethodTesterServer(server) # type: ignore[abstract]
server_task = asyncio.create_task(t_server.serve())
res1 = await t_client.some_method()
self.assertTrue(res1.unwrap().some_bool_value)
res2 = await t_client.some_method_without_error()
self.assertFalse(res2.unwrap().some_bool_value)
(await t_client.some_method_just_error()).unwrap()
server_task.cancel()
async def test_flexible_method_unwrap_error(self) -> None:
@implement_missing_abstract_methods
class FlexibleMethodTesterServer(fc_test.FlexibleMethodTesterServer):
def some_method(self) -> DomainError:
return DomainError(error=FcTransportStatus.FC_ERR_INTERNAL)
def some_method_without_error(self) -> FrameworkError:
return FrameworkError.UNKNOWN_METHOD
def some_method_just_error(self) -> DomainError:
return DomainError(error=FcTransportStatus.FC_ERR_INTERNAL)
ctx = Context()
client, server = ctx.channel_create()
t_client = fc_test.FlexibleMethodTesterClient(client)
t_server = FlexibleMethodTesterServer(server) # type: ignore[abstract]
server_task = asyncio.create_task(t_server.serve())
res1 = await t_client.some_method()
with self.assertRaisesRegex(AssertionError, "Result error"):
res1.unwrap()
res2 = await t_client.some_method_without_error()
with self.assertRaisesRegex(AssertionError, "Result framework error"):
res2.unwrap()
res3 = await t_client.some_method_just_error()
with self.assertRaisesRegex(AssertionError, "Result error"):
res3.unwrap()
server_task.cancel()
async def test_strict_one_way_union(self) -> None:
strict_one_way_union_called = asyncio.Event()
@implement_missing_abstract_methods
class NoopServer(fc_test.NoopServer):
def strict_one_way_union(self, value: Any) -> None:
strict_one_way_union_called.set()
ctx = Context()
client, server = ctx.channel_create()
t_client = fc_test.NoopClient(client)
t_server = NoopServer(server) # type: ignore[abstract]
server_task = asyncio.create_task(t_server.serve())
t_client.strict_one_way_union(value=1)
await asyncio.wait_for(strict_one_way_union_called.wait(), timeout=5.0)
with self.assertRaises(FcTransportStatus) as cm:
client.read()
self.assertEqual(
cm.exception.code(), FcTransportStatus.FC_ERR_SHOULD_WAIT
)
server_task.cancel()
async def test_strict_two_way_union(self) -> None:
@implement_missing_abstract_methods
class NoopServer(fc_test.NoopServer):
def strict_two_way_union(self, value: Any) -> None:
return
ctx = Context()
client, server = ctx.channel_create()
t_client = fc_test.NoopClient(client)
t_server = NoopServer(server) # type: ignore[abstract]
server_task = asyncio.create_task(t_server.serve())
await t_client.strict_two_way_union(other_value="foo")
server_task.cancel()
async def test_flexible_one_way_union(self) -> None:
flexible_one_way_union_called = asyncio.Event()
@implement_missing_abstract_methods
class FlexibleMethodTesterServer(fc_test.FlexibleMethodTesterServer):
def flexible_one_way_union(
self,
value: fc_test.FlexibleMethodTesterFlexibleOneWayUnionRequest,
) -> None:
flexible_one_way_union_called.set()
ctx = Context()
client, server = ctx.channel_create()
t_client = fc_test.FlexibleMethodTesterClient(client)
t_server = FlexibleMethodTesterServer(server) # type: ignore[abstract]
server_task = asyncio.create_task(t_server.serve())
t_client.flexible_one_way_union(value=1)
await asyncio.wait_for(
flexible_one_way_union_called.wait(), timeout=5.0
)
with self.assertRaises(FcTransportStatus) as cm:
client.read()
self.assertEqual(
cm.exception.code(), FcTransportStatus.FC_ERR_SHOULD_WAIT
)
server_task.cancel()
async def test_flexible_two_way_union(self) -> None:
@implement_missing_abstract_methods
class FlexibleMethodTesterServer(fc_test.FlexibleMethodTesterServer):
def flexible_two_way_union(self, value: Any) -> None:
return
ctx = Context()
client, server = ctx.channel_create()
t_client = fc_test.FlexibleMethodTesterClient(client)
t_server = FlexibleMethodTesterServer(server) # type: ignore[abstract]
server_task = asyncio.create_task(t_server.serve())
(await t_client.flexible_two_way_union(other_value="foo")).unwrap()
server_task.cancel()
async def test_sending_and_receiving_event(self) -> None:
ctx = Context()
client, server = ctx.channel_create()
t_client = fc_othertest.CrossLibraryNoopClient(client)
THIS_EXPECTED = 3
THAT_EXPECTED = fc_othertest.TestingEnum.FLIPPED_OTHER_TEST
def random_event_handler(
request: fc_othertest.CrossLibraryNoopOnRandomEventRequest,
) -> None:
self.assertEqual(request.this, THIS_EXPECTED)
self.assertEqual(request.that, THAT_EXPECTED)
raise StopEventHandler
# It's okay to use an unimplemented server here since we're not fielding any calls.
t_server = NotImplementedCrossLibraryNoopServer(server) # type: ignore[abstract]
event_handler = TestEventHandler(t_client, random_event_handler)
t_server.on_random_event(this=THIS_EXPECTED, that=THAT_EXPECTED)
task = asyncio.create_task(event_handler.serve())
# If the event is never received this will loop forever (since the channel is open, and the
# handler should stop service after receiving the event.
await task
async def test_sending_and_receiving_empty_event(self) -> None:
ctx = Context()
client, server = ctx.channel_create()
t_client = fc_othertest.CrossLibraryNoopClient(client)
# It's okay to use an unimplemented server here since we're not fielding any calls.
t_server = NotImplementedCrossLibraryNoopServer(server) # type: ignore[abstract]
event_handler = TestEventHandler(t_client, lambda _: None)
t_server.on_empty_event()
task = asyncio.create_task(event_handler.serve())
# If the event is never received this will loop forever (since the channel is open, and the
# handler should stop service after receiving the event.
await task
async def test_closing_channel_closes_event_loop(self) -> None:
ctx = Context()
client, server = ctx.channel_create()
t_client = fc_othertest.CrossLibraryNoopClient(client)
del server
# A generic unimplemented event handler is fine, since we're just making it exit.
event_handler = NotImplementedCrossLibraryNoopEventHandler(t_client) # type: ignore[abstract]
task = asyncio.create_task(event_handler.serve())
await task