You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/engine/tests/test_console.py

200 lines
7.3 KiB
Python

"""Focused tests for the SSH backed browser console stream."""
from __future__ import annotations
import asyncio
import unittest
from unittest.mock import AsyncMock, patch
from virsh_panel.console import ConsoleRelayError, WebSocketDisconnect, relay_console
class FakeStdin:
def __init__(self) -> None:
self.data = bytearray()
self.written = asyncio.Event()
self.closed = False
def write(self, data: bytes) -> None:
self.data.extend(data)
self.written.set()
async def drain(self) -> None:
await asyncio.sleep(0)
def close(self) -> None:
self.closed = True
class FakeProcess:
def __init__(self) -> None:
self.stdin = FakeStdin()
self.stdout = asyncio.StreamReader()
self.returncode: int | None = None
self.exited = asyncio.Event()
self.terminated = False
self.killed = False
async def wait(self) -> int:
await self.exited.wait()
assert self.returncode is not None
return self.returncode
def finish(self, code: int) -> None:
self.returncode = code
self.exited.set()
self.stdout.feed_eof()
def terminate(self) -> None:
self.terminated = True
self.finish(-15)
def kill(self) -> None:
self.killed = True
self.finish(-9)
class FakeWebSocket:
def __init__(self) -> None:
self.incoming: asyncio.Queue[dict[str, object]] = asyncio.Queue()
self.sent: list[bytes] = []
self.sent_event = asyncio.Event()
async def receive(self) -> dict[str, object]:
return await self.incoming.get()
async def send_bytes(self, data: bytes) -> None:
self.sent.append(data)
self.sent_event.set()
class RelayConsoleTests(unittest.IsolatedAsyncioTestCase):
async def test_relay_binary_frames_and_disconnect_cleans_up(self) -> None:
process = FakeProcess()
websocket = FakeWebSocket()
spawn = AsyncMock(return_value=process)
with patch("virsh_panel.console.asyncio.create_subprocess_exec", spawn):
running = asyncio.create_task(
relay_console(
websocket,
port=5901,
ssh_target="operator@hypervisor.example",
known_hosts_file="/home/virsh-panel/data/current/known_hosts",
ssh_config_file="/home/virsh-panel/data/current/config",
)
)
process.stdout.feed_data(b"RFB 003.008\n")
await asyncio.wait_for(websocket.sent_event.wait(), 1)
await websocket.incoming.put(
{"type": "websocket.receive", "bytes": b"client bytes"}
)
await asyncio.wait_for(process.stdin.written.wait(), 1)
await websocket.incoming.put({"type": "websocket.disconnect"})
await asyncio.wait_for(running, 1)
self.assertEqual(websocket.sent, [b"RFB 003.008\n"])
self.assertEqual(bytes(process.stdin.data), b"client bytes")
self.assertTrue(process.stdin.closed)
self.assertTrue(process.terminated)
command = spawn.await_args.args
self.assertEqual(command[0], "ssh")
self.assertEqual(command[1:3], ("-F", "/home/virsh-panel/data/current/config"))
self.assertIn("BatchMode=yes", command)
self.assertIn("StrictHostKeyChecking=yes", command)
self.assertIn("UserKnownHostsFile=/home/virsh-panel/data/current/known_hosts", command)
self.assertEqual(command[-3:], ("-W", "127.0.0.1:5901", "operator@hypervisor.example"))
self.assertEqual(spawn.await_args.kwargs["stderr"], asyncio.subprocess.DEVNULL)
async def test_ssh_failure_is_reported(self) -> None:
process = FakeProcess()
process.finish(255)
websocket = FakeWebSocket()
with patch(
"virsh_panel.console.asyncio.create_subprocess_exec",
AsyncMock(return_value=process),
):
with self.assertRaisesRegex(ConsoleRelayError, "status 255"):
await relay_console(websocket, port=5900, ssh_target="host.example")
self.assertTrue(process.stdin.closed)
self.assertFalse(process.terminated)
async def test_cancellation_terminates_ssh(self) -> None:
process = FakeProcess()
websocket = FakeWebSocket()
spawn = AsyncMock(return_value=process)
with patch("virsh_panel.console.asyncio.create_subprocess_exec", spawn):
running = asyncio.create_task(
relay_console(websocket, port=5900, ssh_target="host.example")
)
for _ in range(10):
if spawn.await_count:
break
await asyncio.sleep(0)
running.cancel()
with self.assertRaises(asyncio.CancelledError):
await running
self.assertTrue(process.stdin.closed)
self.assertTrue(process.terminated)
async def test_rejects_text_frames(self) -> None:
process = FakeProcess()
websocket = FakeWebSocket()
await websocket.incoming.put({"type": "websocket.receive", "text": "hello"})
with patch(
"virsh_panel.console.asyncio.create_subprocess_exec",
AsyncMock(return_value=process),
):
with self.assertRaisesRegex(ConsoleRelayError, "binary"):
await relay_console(websocket, port=5900, ssh_target="host.example")
self.assertTrue(process.terminated)
async def test_send_disconnect_terminates_ssh(self) -> None:
class DisconnectingWebSocket(FakeWebSocket):
async def send_bytes(self, data: bytes) -> None:
raise WebSocketDisconnect(1006)
process = FakeProcess()
process.stdout.feed_data(b"VNC")
with patch(
"virsh_panel.console.asyncio.create_subprocess_exec",
AsyncMock(return_value=process),
):
await relay_console(
DisconnectingWebSocket(), port=5900, ssh_target="host.example"
)
self.assertTrue(process.terminated)
async def test_invalid_endpoint_never_spawns_ssh(self) -> None:
spawn = AsyncMock()
with patch("virsh_panel.console.asyncio.create_subprocess_exec", spawn):
for port, target in (
(0, "host.example"),
(65536, "host.example"),
(True, "host.example"),
(5900, "-oProxyCommand=evil"),
(5900, "host.example ; evil"),
(5900, "ssh://host.example"),
):
with self.subTest(port=port, target=target):
with self.assertRaises(ValueError):
await relay_console(FakeWebSocket(), port=port, ssh_target=target)
with self.assertRaises(ValueError):
await relay_console(
FakeWebSocket(),
port=5900,
ssh_target="host.example",
known_hosts_file="relative/known_hosts",
)
with self.assertRaises(ValueError):
await relay_console(
FakeWebSocket(),
port=5900,
ssh_target="host.example",
ssh_config_file="relative/config",
)
spawn.assert_not_awaited()
if __name__ == "__main__":
unittest.main()