using System.Net;
using System.Net.WebSockets;
using System.Text;
using Febe.Server;
using Febe.Tests.Server.Support;
using Febe.Tests.Web.Support;
using Febe.Web;
using Febe.Web.Connection;
using Microsoft.Extensions.DependencyInjection;
namespace Febe.Tests.Server;
///
/// /api/vista (PROTOCOLLO.md, spec §13.1) without a browser: session and Origin checks, frames as binary
/// messages, meta as text, input parsed and forwarded, limits, and the reasons a view ends.
///
[TestClass]
public sealed class RemoteViewSocketTests
{
private const string Password = "la password della vista";
public TestContext TestContext { get; set; } = null!;
[TestMethod]
public async Task TheViewNeedsTheSessionAndTheOriginOfTheInterface()
{
var host = new FakeRemoteViewHost();
await using var server = await StartAsync(host);
var cookies = await LoginAsync(server);
// No session: refused before the WebSocket opens.
Assert.AreEqual(HttpStatusCode.Unauthorized, await RefusedAsync(server, null, server.Origin));
// Another page (another origin) cannot open it, even with the session cookie of Alberto's browser.
Assert.AreEqual(HttpStatusCode.Forbidden, await RefusedAsync(server, cookies, "http://pagina-di-altri.example"));
Assert.IsEmpty(host.Opened);
// The interface itself can.
using var socket = await ConnectAsync(server, cookies);
Assert.AreEqual(WebSocketState.Open, socket.State);
Assert.HasCount(1, host.Opened);
}
[TestMethod]
public async Task FramesAreBinaryMetaIsTextAndGesturesComeBack()
{
var host = new FakeRemoteViewHost();
await using var server = await StartAsync(host);
var cookies = await LoginAsync(server);
using var socket = await ConnectAsync(server, cookies);
var view = host.Opened.Single();
view.Write(new RemoteViewMeta(1279, 760, "http://127.0.0.1:8481/benvenuto"));
view.Write(new RemoteViewFrame(new byte[] { 0xFF, 0xD8, 1, 2, 3, 0xFF, 0xD9 }));
var (metaType, meta) = await ReceiveAsync(socket);
Assert.AreEqual(WebSocketMessageType.Text, metaType);
Assert.AreEqual("""{"type":"meta","width":1279,"height":760,"url":"http://127.0.0.1:8481/benvenuto"}""", Encoding.UTF8.GetString(meta));
var (frameType, frame) = await ReceiveAsync(socket);
Assert.AreEqual(WebSocketMessageType.Binary, frameType);
CollectionAssert.AreEqual(new byte[] { 0xFF, 0xD8, 1, 2, 3, 0xFF, 0xD9 }, frame);
foreach (var message in new[]
{
"""{"type":"mouse","action":"down","x":0.25,"y":0.5,"button":"left","clickCount":1}""",
"""{"type":"key","action":"down","key":"a","code":"KeyA","text":"a","modifiers":0}""",
"""{"type":"key","action":"char","text":"è"}""",
"""{"type":"navigate","action":"back"}""",
"""{"type":"mouse","action":"move","x":1.5,"y":0.5}""",
"""{"type":"navigate","action":"vai","url":"https://altrove.example/"}""",
"""{"type":"script","code":"alert(1)"}""",
"non è JSON",
})
{
await socket.SendAsync(Encoding.UTF8.GetBytes(message), WebSocketMessageType.Text, true, TestContext.CancellationToken);
}
await ServerTestBed.WaitUntilAsync(() => Task.FromResult(view.Inputs.Count >= 4), TimeSpan.FromSeconds(10), "quattro gesti inoltrati");
await Task.Delay(200);
var inputs = view.Inputs.ToArray();
Assert.HasCount(4, inputs, "out-of-range, unknown and malformed messages are dropped");
var mouse = (RemoteViewMouse)inputs[0];
Assert.AreEqual(RemoteViewMouseAction.Down, mouse.Action);
Assert.AreEqual(0.25, mouse.X);
Assert.AreEqual(RemoteViewButton.Left, mouse.Button);
var key = (RemoteViewKey)inputs[1];
Assert.AreEqual(RemoteViewKeyAction.Down, key.Action);
Assert.AreEqual("a", key.Text);
Assert.AreEqual("RemoteViewKey(…)", key.ToString(), "a key never shows in a log line");
Assert.AreEqual(RemoteViewKeyAction.Char, ((RemoteViewKey)inputs[2]).Action);
Assert.AreEqual(RemoteViewNavigation.Back, inputs[3]);
await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "fine", TestContext.CancellationToken);
await ServerTestBed.WaitUntilAsync(() => Task.FromResult(view.Disposed), TimeSpan.FromSeconds(10), "la vista chiusa dal server");
}
[TestMethod]
public async Task AViewOpenedElsewhereReplacesTheOldOneAndATooLongMessageClosesIt()
{
var host = new FakeRemoteViewHost();
await using var server = await StartAsync(host);
var cookies = await LoginAsync(server);
using var first = await ConnectAsync(server, cookies);
using var second = await ConnectAsync(server, cookies);
await ExpectCloseAsync(first, (WebSocketCloseStatus)RemoteViewSocket.CloseReplaced);
Assert.AreEqual(RemoteViewEnd.Replaced, host.Opened[0].Ended);
await second.SendAsync(new byte[RemoteViewSocket.MaxMessageBytes + 10], WebSocketMessageType.Text, true, TestContext.CancellationToken);
await ExpectCloseAsync(second, WebSocketCloseStatus.MessageTooBig);
await ServerTestBed.WaitUntilAsync(() => Task.FromResult(host.Opened[1].Disposed), TimeSpan.FromSeconds(10), "la vista chiusa");
}
[TestMethod]
public async Task WithoutBrowserOrOnTheDesktopThereIsNoView()
{
var host = new FakeRemoteViewHost { Unavailable = true };
await using var server = await StartAsync(host);
var cookies = await LoginAsync(server);
Assert.AreEqual(HttpStatusCode.ServiceUnavailable, await RefusedAsync(server, cookies, server.Origin));
// A plain request is not a WebSocket.
using var client = new HttpClient(new HttpClientHandler { CookieContainer = cookies }) { BaseAddress = server.Address };
using (var plain = await client.GetAsync("/api/vista", TestContext.CancellationToken))
{
Assert.AreEqual(HttpStatusCode.BadRequest, plain.StatusCode);
}
await using var desktop = await WebTestServer.StartAsync(new FebeWebOptions { Edition = FebeEdition.Desktop, Access = AccessMode.None }, s => s.AddSingleton(new FakeRemoteViewHost()));
using var response = await desktop.Client.GetAsync("/api/vista", TestContext.CancellationToken);
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
}
[TestMethod]
public void TheServerPingsThePageAndGivesUpOnOneThatStopsAnswering()
{
// With an interval alone ASP.NET Core sends unsolicited pongs and never notices a page that vanished.
var accept = RemoteViewSocket.AcceptContext();
Assert.AreEqual(RemoteViewSocket.KeepAliveInterval, accept.KeepAliveInterval);
Assert.IsNotNull(accept.KeepAliveTimeout, "a ping must have a deadline");
Assert.IsTrue(accept.KeepAliveTimeout > TimeSpan.Zero && accept.KeepAliveTimeout <= TimeSpan.FromMinutes(1), $"{accept.KeepAliveTimeout}");
Assert.IsFalse(accept.DangerousEnableCompression);
}
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task AViewWhosePageVanishedEndsWhenItsPingGoesUnanswered()
{
// The same keep-alive as the server, with short times: the page's machine went to sleep (it never answers).
using var listener = new System.Net.Sockets.TcpListener(IPAddress.Loopback, 0);
listener.Start();
using var page = new System.Net.Sockets.TcpClient();
await page.ConnectAsync(IPAddress.Loopback, ((IPEndPoint)listener.LocalEndpoint).Port, TestContext.CancellationToken);
using var accepted = await listener.AcceptTcpClientAsync(TestContext.CancellationToken);
using var socket = WebSocket.CreateFromStream(accepted.GetStream(), new WebSocketCreationOptions
{
IsServer = true,
KeepAliveInterval = TimeSpan.FromMilliseconds(200),
KeepAliveTimeout = TimeSpan.FromMilliseconds(300),
});
var view = new FakeRemoteViewConnection();
var run = RemoteViewSocket.RunAsync(socket, view, CancellationToken.None);
Assert.AreSame(run, await Task.WhenAny(run, Task.Delay(TimeSpan.FromSeconds(10), TestContext.CancellationToken)), "the view ends by itself");
await run;
}
[TestMethod]
public void KeysGetTheVirtualCodesChromiumNeeds()
{
Assert.AreEqual(65, RemoteKeys.ToStroke(new RemoteViewKey(RemoteViewKeyAction.Down, "a", "KeyA", "a", 0)).KeyCode);
Assert.AreEqual(8, RemoteKeys.ToStroke(new RemoteViewKey(RemoteViewKeyAction.Down, "Backspace", "Backspace", null, 0)).KeyCode);
var enter = RemoteKeys.ToStroke(new RemoteViewKey(RemoteViewKeyAction.Down, "Enter", "Enter", null, 0));
Assert.AreEqual(13, enter.KeyCode);
Assert.AreEqual("\r", enter.Text, "Enter submits forms only with its text");
Assert.AreEqual(50, RemoteKeys.ToStroke(new RemoteViewKey(RemoteViewKeyAction.Down, "\"", "Digit2", "\"", 8)).KeyCode, "Italian layout: Shift+2");
Assert.AreEqual(219, RemoteKeys.ToStroke(new RemoteViewKey(RemoteViewKeyAction.Down, "è", "BracketLeft", "è", 0)).KeyCode, "Italian layout: è");
Assert.AreEqual("KeyStroke(…)", RemoteKeys.ToStroke(new RemoteViewKey(RemoteViewKeyAction.Down, "x", "KeyX", "x", 0)).ToString());
Assert.AreEqual("http://127.0.0.1:8481/profilo/marta.prova/", BrowserRemoteViewConnection.WithoutQuery("http://127.0.0.1:8481/profilo/marta.prova/?gettone=segreto#x"));
Assert.AreEqual("about:blank", BrowserRemoteViewConnection.WithoutQuery("about:blank"));
}
private static Task StartAsync(FakeRemoteViewHost host) =>
WebTestServer.StartAsync(
new FebeWebOptions { Edition = FebeEdition.Docker, Access = AccessMode.Password, Password = Password },
s => s.AddSingleton(host));
private async Task LoginAsync(WebTestServer server)
{
var cookies = new CookieContainer();
using var client = new HttpClient(new HttpClientHandler { CookieContainer = cookies, UseCookies = true }) { BaseAddress = server.Address };
using var request = server.Request(HttpMethod.Post, "/api/accesso", $$"""{"password":"{{Password}}"}""");
using var response = await client.SendAsync(request, TestContext.CancellationToken);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
return cookies;
}
private async Task ConnectAsync(WebTestServer server, CookieContainer cookies)
{
var socket = new ClientWebSocket();
socket.Options.Cookies = cookies;
socket.Options.SetRequestHeader("Origin", server.Origin);
await socket.ConnectAsync(new UriBuilder(server.Address) { Scheme = "ws", Path = RemoteViewSocket.Path }.Uri, TestContext.CancellationToken);
return socket;
}
private async Task RefusedAsync(WebTestServer server, CookieContainer? cookies, string origin)
{
using var socket = new ClientWebSocket();
socket.Options.CollectHttpResponseDetails = true;
socket.Options.SetRequestHeader("Origin", origin);
if (cookies is not null)
{
socket.Options.Cookies = cookies;
}
await Assert.ThrowsAsync(() => socket.ConnectAsync(new UriBuilder(server.Address) { Scheme = "ws", Path = RemoteViewSocket.Path }.Uri, TestContext.CancellationToken));
return socket.HttpStatusCode;
}
private async Task<(WebSocketMessageType Type, byte[] Data)> ReceiveAsync(ClientWebSocket socket)
{
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(TestContext.CancellationToken);
timeout.CancelAfter(TimeSpan.FromSeconds(10));
var buffer = new byte[8192];
using var data = new MemoryStream();
WebSocketReceiveResult result;
do
{
result = await socket.ReceiveAsync(buffer, timeout.Token);
data.Write(buffer, 0, result.Count);
}
while (!result.EndOfMessage);
return (result.MessageType, data.ToArray());
}
private async Task ExpectCloseAsync(ClientWebSocket socket, WebSocketCloseStatus status)
{
var (type, _) = await ReceiveAsync(socket);
Assert.AreEqual(WebSocketMessageType.Close, type);
Assert.AreEqual(status, socket.CloseStatus);
}
}