blob: b5f1989114ac8e0f7582a2a5b47b8cf4530de3c0 [file]
# Copyright 2025 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 asyncio
import json
import os
import tempfile
import typing
import unittest
import unittest.mock as mock
from pathlib import Path
import package_server
from async_utils.command import AsyncCommandError, CommandOutput
class TestPackageServer(unittest.IsolatedAsyncioTestCase):
@mock.patch("package_server.lib.FxCmd")
async def test_is_running_true(self, mock_fx_cmd: mock.Mock) -> None:
cmd_mock = mock.Mock()
process_mock = mock.Mock()
process_mock.return_code = 0
cmd_mock.run_to_completion = mock.AsyncMock(return_value=process_mock)
# Configure start to be an async mock that returns cmd_mock
mock_fx_cmd.return_value.start = mock.AsyncMock(return_value=cmd_mock)
self.assertTrue(await package_server.is_running())
mock_fx_cmd.return_value.start.assert_called_with(
"is-package-server-running"
)
@mock.patch("package_server.lib.FxCmd")
async def test_is_running_false(self, mock_fx_cmd: mock.Mock) -> None:
cmd_mock = mock.Mock()
process_mock = mock.Mock()
process_mock.return_code = 1
cmd_mock.run_to_completion = mock.AsyncMock(return_value=process_mock)
mock_fx_cmd.return_value.start = mock.AsyncMock(return_value=cmd_mock)
self.assertFalse(await package_server.is_running())
@mock.patch("package_server.lib.is_running")
async def test_wait_for_package_server_success(
self, mock_is_running: mock.Mock
) -> None:
mock_is_running.return_value = True
process_mock = mock.Mock()
process_mock.wait = mock.Mock(return_value=asyncio.Future())
self.assertTrue(
await package_server.wait_for_package_server(
process_mock, timeout=1, interval=0.1
)
)
@mock.patch("package_server.lib.is_running")
async def test_wait_for_package_server_process_exits(
self, mock_is_running: mock.Mock
) -> None:
mock_is_running.return_value = False
process_mock = mock.Mock()
process_mock.wait = mock.AsyncMock(return_value=None)
self.assertFalse(
await package_server.wait_for_package_server(
process_mock, timeout=1, interval=0.1
)
)
@mock.patch("package_server.lib.is_running")
async def test_wait_for_package_server_timeout(
self,
mock_is_running: mock.Mock,
) -> None:
mock_is_running.return_value = False
process_mock = mock.Mock()
process_mock.wait = mock.Mock(return_value=asyncio.Future())
self.assertFalse(
await package_server.wait_for_package_server(
process_mock, timeout=0.01, interval=0.001
)
)
@mock.patch("package_server.lib.build_dir.get_build_directory")
@mock.patch("package_server.lib.FfxCmd")
async def test_get_arguments(
self, mock_ffx_cmd: mock.Mock, mock_get_build_dir: mock.Mock
) -> None:
cmd_mock = mock.Mock()
process_mock = mock.Mock()
process_mock.stdout = "8084\n"
cmd_mock.run_to_completion = mock.AsyncMock(return_value=process_mock)
mock_ffx_cmd.return_value.start = mock.AsyncMock(return_value=cmd_mock)
mock_get_build_dir.return_value = Path("/some/out/dir")
args = await package_server.get_arguments()
self.assertIn("server", args)
self.assertIn("start", args)
self.assertIn("[::]:8084", args)
self.assertIn(package_server.ephemeral_repository_name(), args)
self.assertNotIn("fx", args)
self.assertNotIn("ffx", args)
mock_ffx_cmd.return_value.start.assert_called_with(
"config",
"get",
"repository.server.default_port",
)
@mock.patch("package_server.lib.build_dir.get_build_directory")
def test_ephemeral_repository_name(
self, mock_get_build_dir: mock.Mock
) -> None:
mock_get_build_dir.return_value = Path("/some/out/dir")
name1 = package_server.ephemeral_repository_name()
name2 = package_server.ephemeral_repository_name()
fxtest_name = package_server.ephemeral_repository_name("fxtest")
explicit_dir_name = package_server.ephemeral_repository_name(
"fxtest", "/some/out/dir"
)
mock_get_build_dir.return_value = Path("/other/out/dir")
name3 = package_server.ephemeral_repository_name()
self.assertEqual(name1, name2)
self.assertNotEqual(name1, name3)
self.assertEqual(fxtest_name, explicit_dir_name)
self.assertRegex(name1, r"^tmp-[0-9a-f]{16}$")
self.assertRegex(fxtest_name, r"^fxtest-[0-9a-f]{16}$")
self.assertEqual(name1.split("-", 1)[1], fxtest_name.split("-", 1)[1])
with tempfile.TemporaryDirectory() as td:
real_out = os.path.join(td, "real_out")
os.makedirs(os.path.join(real_out, "amber-files"))
link_out = os.path.join(td, "link_out")
os.symlink(real_out, link_out)
self.assertEqual(
package_server.ephemeral_repository_name("fxtest", real_out),
package_server.ephemeral_repository_name("fxtest", link_out),
)
@mock.patch("package_server.lib.build_dir.get_build_directory")
@mock.patch("package_server.lib.FfxCmd")
async def test_get_arguments_with_name(
self, mock_ffx_cmd: mock.Mock, mock_get_build_dir: mock.Mock
) -> None:
cmd_mock = mock.Mock()
process_mock = mock.Mock()
process_mock.stdout = "8083\n"
cmd_mock.run_to_completion = mock.AsyncMock(return_value=process_mock)
mock_ffx_cmd.return_value.start = mock.AsyncMock(return_value=cmd_mock)
mock_get_build_dir.return_value = Path("/some/out/dir")
args = await package_server.get_arguments(name="my-repo")
self.assertIn("my-repo", args)
@mock.patch("package_server.lib.build_dir.get_build_directory")
@mock.patch("package_server.lib.FfxCmd")
async def test_get_arguments_ffx_config_failure(
self, mock_ffx_cmd: mock.Mock, mock_get_build_dir: mock.Mock
) -> None:
cmd_mock = mock.Mock()
process_mock = mock.Mock()
process_mock.stdout = "invalid\n"
cmd_mock.run_to_completion = mock.AsyncMock(return_value=process_mock)
mock_ffx_cmd.return_value.start = mock.AsyncMock(return_value=cmd_mock)
mock_get_build_dir.return_value = Path("/some/out/dir")
args = await package_server.get_arguments()
# Should fallback to default port 8083
self.assertIn("[::]:8083", args)
@mock.patch("package_server.lib.build_dir.get_build_directory")
def test_is_package_repository_built(
self, mock_get_build_dir: mock.Mock
) -> None:
mock_path = mock.MagicMock()
mock_get_build_dir.return_value = mock_path
repo_json = mock_path / "amber-files" / "repository" / "9.root.json"
repo_json.is_file.return_value = True
self.assertTrue(package_server.is_package_repository_built())
repo_json.is_file.return_value = False
self.assertFalse(package_server.is_package_repository_built())
@mock.patch(
"package_server.lib.build_dir.get_build_directory",
return_value=Path("/some/out/dir"),
)
@mock.patch("package_server.lib.is_package_repository_built")
@mock.patch("package_server.lib.wait_for_package_server")
@mock.patch("package_server.lib.get_arguments")
@mock.patch("package_server.lib.FfxCmd")
@mock.patch("package_server.lib.FxCmd")
@mock.patch("asyncio.create_subprocess_exec")
async def test_start_success(
self,
mock_exec: mock.Mock,
mock_fx_cmd: mock.Mock,
mock_ffx_cmd: mock.Mock,
mock_get_arguments: mock.Mock,
mock_wait: mock.Mock,
mock_is_built: mock.Mock,
_mock_get_build_dir: mock.Mock,
) -> None:
mock_is_built.return_value = True
mock_wait.return_value = True
mock_get_arguments.return_value = ("arg1", "arg2")
mock_ffx_cmd.return_value.command_line.side_effect = (
lambda *args: ("ffx",) + args
)
mock_fx_cmd.return_value.command_line.side_effect = (
lambda *args: ("fx",) + args
)
# Mock for package server process
server_process_mock = mock.Mock()
mock_exec.return_value = server_process_mock
self.assertEqual(await package_server.start(), server_process_mock)
mock_get_arguments.assert_called_once_with(
package_server.ephemeral_repository_name()
)
mock_ffx_cmd.return_value.command_line.assert_called_with(
"arg1", "arg2"
)
mock_fx_cmd.return_value.command_line.assert_called_with(
"ffx", "arg1", "arg2"
)
mock_exec.assert_called_with(
"fx",
"ffx",
"arg1",
"arg2",
stdout=asyncio.subprocess.DEVNULL,
stderr=asyncio.subprocess.DEVNULL,
)
mock_wait.assert_called_with(server_process_mock, 30, 0.2)
@mock.patch("package_server.lib.is_package_repository_built")
async def test_start_fails_when_repo_not_built(
self,
mock_is_built: mock.Mock,
) -> None:
mock_is_built.return_value = False
with self.assertRaisesRegex(
package_server.PackageServingException,
"The package repository is not built!",
):
await package_server.start()
@mock.patch("package_server.lib.FfxCmd")
async def test_stop(self, mock_ffx_cmd: mock.Mock) -> None:
cmd_mock = mock.Mock()
process_mock = mock.Mock()
cmd_mock.run_to_completion = mock.AsyncMock(return_value=process_mock)
mock_ffx_cmd.return_value.start = mock.AsyncMock(return_value=cmd_mock)
await package_server.stop(name="my-repo")
mock_ffx_cmd.return_value.start.assert_called_with(
"repository",
"server",
"stop",
"my-repo",
)
cmd_mock.run_to_completion.assert_called()
@mock.patch("package_server.lib.FfxCmd")
async def test_stop_all(self, mock_ffx_cmd: mock.Mock) -> None:
cmd_mock = mock.Mock()
process_mock = mock.Mock()
cmd_mock.run_to_completion = mock.AsyncMock(return_value=process_mock)
mock_ffx_cmd.return_value.start = mock.AsyncMock(return_value=cmd_mock)
await package_server.stop()
mock_ffx_cmd.return_value.start.assert_called_with(
"repository",
"server",
"stop",
)
cmd_mock.run_to_completion.assert_called()
@mock.patch("package_server.lib.FxCmd")
async def test_deregister(self, mock_fx_cmd: mock.Mock) -> None:
cmd_mock = mock.Mock()
output = CommandOutput("", "", 0, 0.1, None)
cmd_mock.run_to_completion = mock.AsyncMock(return_value=output)
mock_fx_cmd.return_value.start = mock.AsyncMock(return_value=cmd_mock)
self.assertEqual(
await package_server.deregister(name="my-repo"),
output,
)
mock_fx_cmd.assert_called_once_with(build_directory=None, timeout=5.0)
mock_fx_cmd.return_value.start.assert_called_once_with(
"ffx",
"target",
"repository",
"deregister",
"-r",
"my-repo",
)
@mock.patch("package_server.lib.is_running")
async def test_run_and_stop_on_exit_already_running(
self,
mock_is_running: mock.Mock,
) -> None:
mock_is_running.return_value = True
async with package_server.run_and_stop_on_exit():
pass
mock_is_running.assert_called()
@mock.patch(
"package_server.lib.build_dir.get_build_directory",
return_value=Path("/some/out/dir"),
)
@mock.patch("package_server.lib.deregister")
@mock.patch("package_server.lib.stop")
@mock.patch("package_server.lib.start")
@mock.patch("package_server.lib.is_running")
async def test_run_and_stop_on_exit_starts_and_stops(
self,
mock_is_running: mock.Mock,
mock_start: mock.Mock,
mock_stop: mock.Mock,
mock_deregister: mock.Mock,
_mock_get_build_dir: mock.Mock,
) -> None:
mock_is_running.return_value = False
process_mock = mock.Mock()
process_mock.terminate = mock.Mock()
process_mock.wait = mock.AsyncMock(return_value=None)
mock_start.return_value = process_mock
async with package_server.run_and_stop_on_exit():
pass
expected_repo_name = package_server.ephemeral_repository_name()
mock_is_running.assert_called()
mock_start.assert_called_once_with(expected_repo_name)
mock_deregister.assert_called_once_with(expected_repo_name)
mock_stop.assert_called_once_with(expected_repo_name)
process_mock.terminate.assert_called()
process_mock.wait.assert_called()
@mock.patch(
"package_server.lib.build_dir.get_build_directory",
return_value=Path("/some/out/dir"),
)
@mock.patch("package_server.lib.start")
@mock.patch("package_server.lib.is_running")
async def test_run_and_stop_on_exit_failure(
self,
mock_is_running: mock.Mock,
mock_start: mock.Mock,
_mock_get_build_dir: mock.Mock,
) -> None:
mock_is_running.return_value = False
mock_start.side_effect = package_server.PackageServingException("fail")
with self.assertRaises(package_server.PackageServingCLIException):
async with package_server.run_and_stop_on_exit():
pass
def test_is_fuchsia_repo_registered(self) -> None:
data_aliases = json.dumps(
{"ok": {"data": [{"name": "devhost", "aliases": ["fuchsia.com"]}]}}
)
self.assertTrue(package_server.is_fuchsia_repo_registered(data_aliases))
data_name = json.dumps(
{"ok": {"data": [{"name": "fuchsia.com", "aliases": []}]}}
)
self.assertTrue(package_server.is_fuchsia_repo_registered(data_name))
data_pkg = json.dumps(
{
"ok": {
"data": [
{"name": "fuchsia-pkg://fuchsia.com", "aliases": []}
]
}
}
)
self.assertTrue(package_server.is_fuchsia_repo_registered(data_pkg))
self.assertFalse(
package_server.is_fuchsia_repo_registered(
json.dumps({"ok": {"data": []}})
)
)
with self.assertRaises(json.JSONDecodeError):
package_server.is_fuchsia_repo_registered("not json")
data_multiple = json.dumps(
{
"ok": {
"data": [
{"name": "stale-repo", "aliases": ["fuchsia.com"]},
{"name": "fxtest-abc123", "aliases": ["fuchsia.com"]},
]
}
}
)
self.assertTrue(
package_server.is_fuchsia_repo_registered(
data_multiple, repo_name="fxtest-abc123"
)
)
self.assertFalse(
package_server.is_fuchsia_repo_registered(
data_multiple, repo_name="fxtest-other"
)
)
data_pkg_repo = json.dumps(
{
"ok": {
"data": [
{
"name": "fuchsia-pkg://fxtest-abc123",
"aliases": ["fuchsia.com"],
}
]
}
}
)
self.assertTrue(
package_server.is_fuchsia_repo_registered(
data_pkg_repo, repo_name="fxtest-abc123"
)
)
async def test_is_connected_to_device(self) -> None:
runner = mock.AsyncMock(
side_effect=[
CommandOutput("ok", "", 0, 0.1, None),
CommandOutput(
json.dumps(
{
"ok": {
"data": [
{
"name": "devhost",
"aliases": ["fuchsia.com"],
}
]
}
}
),
"",
0,
0.1,
None,
),
]
)
self.assertTrue(
await package_server.is_connected_to_device(run_command=runner)
)
self.assertEqual(runner.call_count, 2)
runner_not_running = mock.AsyncMock(
return_value=CommandOutput("", "", 1, 0.1, None)
)
self.assertFalse(
await package_server.is_connected_to_device(
run_command=runner_not_running
)
)
self.assertEqual(runner_not_running.call_count, 1)
runner_bad_json = mock.AsyncMock(
side_effect=[
CommandOutput("ok", "", 0, 0.1, None),
CommandOutput("not json", "", 0, 0.1, None),
]
)
self.assertFalse(
await package_server.is_connected_to_device(
run_command=runner_bad_json
)
)
self.assertEqual(runner_bad_json.call_count, 2)
async def test_wait_for_registration(self) -> None:
stale_output = json.dumps(
{
"ok": {
"data": [{"name": "stale-repo", "aliases": ["fuchsia.com"]}]
}
}
)
registered_output = json.dumps(
{
"ok": {
"data": [
{"name": "stale-repo", "aliases": ["fuchsia.com"]},
{"name": "fxtest-1234", "aliases": ["fuchsia.com"]},
]
}
}
)
runner = mock.AsyncMock(
side_effect=[
CommandOutput(stale_output, "", 0, 0.1, None),
CommandOutput(registered_output, "", 0, 0.1, None),
]
)
with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock):
self.assertTrue(
await package_server.wait_for_registration(
repo_name="fxtest-1234", run_command=runner
)
)
self.assertEqual(runner.call_count, 2)
runner_exhausted = mock.AsyncMock(
return_value=CommandOutput(stale_output, "", 0, 0.1, None)
)
with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock):
self.assertFalse(
await package_server.wait_for_registration(
repo_name="fxtest-1234",
retries=3,
run_command=runner_exhausted,
)
)
self.assertEqual(runner_exhausted.call_count, 3)
async def test_serve_lifecycle_and_warnings(self) -> None:
events: list[str] = []
warnings: list[str] = []
serve_abort_signal: asyncio.Event | None = None
deregister_calls = 0
async def fake_runner(
*args: str, **kwargs: typing.Any
) -> CommandOutput | None:
nonlocal serve_abort_signal, deregister_calls
if "deregister" in args:
deregister_calls += 1
events.append(f"deregister_{deregister_calls}")
# Fail on teardown deregistration to exercise warning callback.
rc = 0 if deregister_calls == 1 else 1
return CommandOutput("", "", rc, 0.1, None)
if "serve" in args:
events.append("serve")
serve_abort_signal = kwargs.get("abort_signal")
if serve_abort_signal is not None:
await serve_abort_signal.wait()
return CommandOutput("", "", 0, 0.1, None)
return CommandOutput("", "", 0, 0.1, None)
task, cancel_event = await package_server.serve(
name="fxtest-1234",
run_command=fake_runner,
on_warning=warnings.append,
)
cancel_event.set()
await task
self.assertEqual(events, ["deregister_1", "serve", "deregister_2"])
self.assertIsNotNone(serve_abort_signal)
assert serve_abort_signal is not None
self.assertTrue(serve_abort_signal.is_set())
self.assertEqual(len(warnings), 1)
self.assertIn(
"Failed to deregister temporary package repository fxtest-1234",
warnings[0],
)
@mock.patch("package_server.lib.FxCmd")
async def test_serve_forwards_build_directory_to_default_runner(
self, mock_fx_cmd: mock.Mock
) -> None:
cmd_mock = mock.Mock()
cmd_mock.terminate = mock.Mock()
cmd_mock.kill = mock.Mock()
cmd_mock.run_to_completion = mock.AsyncMock(
return_value=CommandOutput("", "", 0, 0.1, None)
)
mock_fx_cmd.return_value.start = mock.AsyncMock(return_value=cmd_mock)
task, cancel_event = await package_server.serve(
prefix="fxtest",
build_directory=Path("/custom/out/dir"),
)
cancel_event.set()
await task
for call in mock_fx_cmd.call_args_list:
self.assertEqual(
call.kwargs.get("build_directory"), "/custom/out/dir"
)
async def test_serve_stop_timeout_emits_warning(self) -> None:
warnings: list[str] = []
serve_cancelled = False
async def hanging_runner(
*args: str, **kwargs: typing.Any
) -> CommandOutput | None:
nonlocal serve_cancelled
if "serve" in args:
try:
await asyncio.Future()
except asyncio.CancelledError:
serve_cancelled = True
raise
return CommandOutput("", "", 0, 0.1, None)
with mock.patch(
"package_server.lib._DEFAULT_SERVER_STOP_TIMEOUT", 0.01
):
task, cancel_event = await package_server.serve(
name="fxtest-1234",
run_command=hanging_runner,
on_warning=warnings.append,
)
cancel_event.set()
await task
self.assertTrue(serve_cancelled)
self.assertEqual(len(warnings), 1)
self.assertIn(
"Timed out waiting for temporary package server (fxtest-1234) to stop.",
warnings[0],
)
@mock.patch("package_server.lib.FxCmd")
async def test_default_command_runner_abort_signal_terminates_and_kills(
self, mock_fx_cmd: mock.Mock
) -> None:
runner_done = asyncio.Event()
cmd_mock = mock.Mock()
async def wait_until_killed() -> CommandOutput:
await runner_done.wait()
return CommandOutput("", "", -9, 0.1, None)
cmd_mock.terminate = mock.Mock()
cmd_mock.kill = mock.Mock(side_effect=runner_done.set)
cmd_mock.run_to_completion = mock.AsyncMock(
side_effect=wait_until_killed
)
mock_fx_cmd.return_value.start = mock.AsyncMock(return_value=cmd_mock)
abort_signal = asyncio.Event()
runner = package_server.lib._default_command_runner()
with mock.patch("package_server.lib._DEFAULT_ABORT_GRACE_PERIOD", 0.01):
run_task = asyncio.create_task(
runner("serve", "-l", "0", abort_signal=abort_signal)
)
await asyncio.sleep(0)
abort_signal.set()
await run_task
mock_fx_cmd.return_value.start.assert_called_once_with(
"serve", "-l", "0"
)
cmd_mock.terminate.assert_called_once()
cmd_mock.kill.assert_called_once()
@mock.patch("package_server.lib.FxCmd")
async def test_default_command_runner_cancellation_kills_process(
self, mock_fx_cmd: mock.Mock
) -> None:
async def never_finishes() -> CommandOutput:
await asyncio.Future()
return CommandOutput("", "", 0, 0.1, None)
cmd_mock = mock.Mock()
cmd_mock.kill = mock.Mock()
cmd_mock.run_to_completion = mock.AsyncMock(side_effect=never_finishes)
mock_fx_cmd.return_value.start = mock.AsyncMock(return_value=cmd_mock)
runner = package_server.lib._default_command_runner()
run_task = asyncio.create_task(runner("serve", "-l", "0"))
await asyncio.sleep(0)
run_task.cancel()
with self.assertRaises(asyncio.CancelledError):
await run_task
cmd_mock.kill.assert_called_once()
@mock.patch("package_server.lib.FxCmd")
async def test_default_command_runner_handles_async_command_error(
self, mock_fx_cmd: mock.Mock
) -> None:
mock_fx_cmd.return_value.start = mock.AsyncMock(
side_effect=AsyncCommandError("failed")
)
runner = package_server.lib._default_command_runner()
self.assertIsNone(await runner("is-package-server-running"))