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.
200 lines
7.3 KiB
Python
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()
|