"""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()