Pagine aperte da Alberto non sono segnali (regole-1); cookie perso fuori sessione = disconnessione (regole-2); pagina a riposo quando Alberto lascia il browser (regole-6); la lease di «Accedi»/«Usa il browser» finisce da sola dopo 2 minuti senza vista remota né finestra (websec-1); ping con scadenza sulla vista remota (websec-5); aperture della vista remota serializzate (websec-6); orologio virtuale senza fine anticipata (engine-1); la sincronizzazione della coda non duplica il compito in corso (engine-2); raccolte in evidenza programmate (sched-1). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
295 lines
9.0 KiB
C#
295 lines
9.0 KiB
C#
using System.Collections.Concurrent;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Nodes;
|
|
using Febe.App;
|
|
using Febe.Browser.Cdp;
|
|
using Febe.Browser.Hosting;
|
|
using Febe.Core.Abstractions;
|
|
using Febe.Desktop.Core;
|
|
using Febe.Web.Native;
|
|
|
|
namespace Febe.Tests.Desktop.Support;
|
|
|
|
/// <summary>The Windows-only part of the desktop, faked: what the platform asks of it is recorded.</summary>
|
|
internal sealed class FakeDesktopShell : IDesktopShell
|
|
{
|
|
public FakeNativeShell NativeShell { get; } = new();
|
|
|
|
public INativeShell Native => NativeShell;
|
|
|
|
/// <summary>The WebView2 runtime this «Windows» has (null: missing).</summary>
|
|
public string? RuntimeVersion { get; set; } = "141.0.3537.71";
|
|
|
|
/// <summary>Where «Edge» is (null: not installed).</summary>
|
|
public string? EdgePath { get; set; }
|
|
|
|
/// <summary>The browsers created, with the settings the platform gave them.</summary>
|
|
public ConcurrentQueue<(WebView2BrowserSettings Settings, FakeBrowser Browser)> Created { get; } = new();
|
|
|
|
public ConcurrentQueue<string> ProcessWindows { get; } = new();
|
|
|
|
public string? WebView2Version() => RuntimeVersion;
|
|
|
|
public IFebeBrowser CreateWebView2Browser(WebView2BrowserSettings settings, FebePlatformContext context)
|
|
{
|
|
var browser = new FakeBrowser(settings.ProfileDirectory, settings.Width, settings.Height, context);
|
|
Created.Enqueue((settings, browser));
|
|
return browser;
|
|
}
|
|
|
|
public string? FindEdge() => EdgePath;
|
|
|
|
public Task ShowProcessWindowAsync(int processId, CancellationToken ct)
|
|
{
|
|
ProcessWindows.Enqueue("mostra " + processId);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task HideProcessWindowAsync(int processId, CancellationToken ct)
|
|
{
|
|
ProcessWindows.Enqueue("nascondi " + processId);
|
|
return Task.CompletedTask;
|
|
}
|
|
}
|
|
|
|
/// <summary>Folder picker, explorer, default browser, notifications (the Windows alerts) and autostart, faked.</summary>
|
|
internal sealed class FakeNativeShell : INativeShell
|
|
{
|
|
public bool CanPickFolder => true;
|
|
|
|
public bool CanShowInFolder => true;
|
|
|
|
public bool CanOpenUrl => true;
|
|
|
|
public bool CanNotify => true;
|
|
|
|
public bool SupportsAutostart => true;
|
|
|
|
public bool Autostart { get; private set; }
|
|
|
|
public string? FolderToPick { get; set; }
|
|
|
|
public ConcurrentQueue<string> Shown { get; } = new();
|
|
|
|
public ConcurrentQueue<Uri> Opened { get; } = new();
|
|
|
|
public ConcurrentQueue<(string Title, string Message)> Notified { get; } = new();
|
|
|
|
public Task<string?> PickFolderAsync(string title, string? initialFolder, CancellationToken ct) => Task.FromResult(FolderToPick);
|
|
|
|
public Task<bool> ShowInFolderAsync(string fullPath, CancellationToken ct)
|
|
{
|
|
Shown.Enqueue(fullPath);
|
|
return Task.FromResult(true);
|
|
}
|
|
|
|
public Task<bool> OpenUrlAsync(Uri address, CancellationToken ct)
|
|
{
|
|
Opened.Enqueue(address);
|
|
return Task.FromResult(true);
|
|
}
|
|
|
|
public Task NotifyAsync(string title, string message, CancellationToken ct)
|
|
{
|
|
Notified.Enqueue((title, message));
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task<bool> GetAutostartAsync(CancellationToken ct) => Task.FromResult(Autostart);
|
|
|
|
public Task SetAutostartAsync(bool enabled, CancellationToken ct)
|
|
{
|
|
Autostart = enabled;
|
|
return Task.CompletedTask;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The window «Browser di Febe», faked: a CDP session that answers like a browser on a blank page, a session cookie
|
|
/// that exists once «Alberto» has logged in, and a record of every time the window came to the front or went away.
|
|
/// </summary>
|
|
internal sealed class FakeBrowser : IFebeBrowser
|
|
{
|
|
private readonly FebePlatformContext _context;
|
|
private IDisposable? _lease;
|
|
|
|
public FakeBrowser(string profileDirectory, int width, int height, FebePlatformContext context)
|
|
{
|
|
ProfileDirectory = profileDirectory;
|
|
WindowWidth = width;
|
|
WindowHeight = height;
|
|
_context = context;
|
|
}
|
|
|
|
public FakeCdp FakeCdp { get; } = new();
|
|
|
|
public ICdpSession Cdp => FakeCdp;
|
|
|
|
public UserDrivingGate UserDriving { get; } = new();
|
|
|
|
public bool UserIsDriving => UserDriving.IsDriving;
|
|
|
|
public bool IsAvailable { get; private set; }
|
|
|
|
public string? LastError => null;
|
|
|
|
public string ProfileDirectory { get; }
|
|
|
|
public int WindowWidth { get; }
|
|
|
|
public int WindowHeight { get; }
|
|
|
|
public int Shown { get; private set; }
|
|
|
|
public int Hidden { get; private set; }
|
|
|
|
public int EmptiedProfiles { get; private set; }
|
|
|
|
public bool Disposed { get; private set; }
|
|
|
|
public Task RunAsync(CancellationToken ct)
|
|
{
|
|
Directory.CreateDirectory(ProfileDirectory);
|
|
IsAvailable = true;
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task<NavigationResult> RestAsync(CancellationToken ct) => FakeCdp.NavigateAsync(CdpPageExtensions.RestUrl, ct);
|
|
|
|
/// <summary>Like the real window: in front, Alberto is driving.</summary>
|
|
public Task ShowToUserAsync(CancellationToken ct)
|
|
{
|
|
Shown++;
|
|
_lease ??= UserDriving.Begin();
|
|
_context.Tracker.MarkUsed(_context.Clock.Now);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task HideFromUserAsync(CancellationToken ct)
|
|
{
|
|
Hidden++;
|
|
_lease?.Dispose();
|
|
_lease = null;
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
/// <summary>The next «Scollega» finds a file held by another process (Windows) and cannot delete the profile.</summary>
|
|
public bool ProfileLocked { get; set; }
|
|
|
|
public Task RestartWithEmptyProfileAsync(CancellationToken ct)
|
|
{
|
|
if (ProfileLocked)
|
|
{
|
|
throw new IOException("Il file Cookies è in uso da un altro processo.");
|
|
}
|
|
|
|
if (Directory.Exists(ProfileDirectory))
|
|
{
|
|
Directory.Delete(ProfileDirectory, recursive: true);
|
|
}
|
|
|
|
Directory.CreateDirectory(ProfileDirectory);
|
|
FakeCdp.LoggedIn = false;
|
|
EmptiedProfiles++;
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public ValueTask DisposeAsync()
|
|
{
|
|
Disposed = true;
|
|
IsAvailable = false;
|
|
return ValueTask.CompletedTask;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A CDP session answering like a page: frame tree, navigation (with its <c>Page.frameNavigated</c> event, as the
|
|
/// collection pipeline hears it), the session cookie (name only).
|
|
/// </summary>
|
|
internal sealed class FakeCdp : ICdpSession
|
|
{
|
|
private readonly Lock _gate = new();
|
|
private readonly Dictionary<string, List<Action<JsonElement>>> _handlers = new(StringComparer.Ordinal);
|
|
|
|
public bool LoggedIn { get; set; }
|
|
|
|
public string Url { get; private set; } = "about:blank";
|
|
|
|
public ConcurrentQueue<string> Methods { get; } = new();
|
|
|
|
/// <summary>The main frame moved to <paramref name="url"/> by itself (a redirect of the site), not by a command.</summary>
|
|
public void Navigated(string url)
|
|
{
|
|
Url = url;
|
|
Raise("Page.frameNavigated", new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = url } });
|
|
}
|
|
|
|
public Task<JsonElement> SendAsync(string method, object? parameters = null, CancellationToken ct = default)
|
|
{
|
|
CdpCommandPolicy.EnsureAllowed(method);
|
|
Methods.Enqueue(method);
|
|
JsonNode result = method switch
|
|
{
|
|
"Page.getFrameTree" => new JsonObject { ["frameTree"] = new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = Url } } },
|
|
"Page.navigate" => Navigate(parameters),
|
|
"Network.getCookies" => new JsonObject { ["cookies"] = LoggedIn ? new JsonArray(new JsonObject { ["name"] = "sessionid" }) : new JsonArray() },
|
|
_ => new JsonObject(),
|
|
};
|
|
return Task.FromResult(JsonDocument.Parse(result.ToJsonString()).RootElement.Clone());
|
|
}
|
|
|
|
public IDisposable On(string eventName, Action<JsonElement> handler)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (!_handlers.TryGetValue(eventName, out var list))
|
|
{
|
|
_handlers[eventName] = list = [];
|
|
}
|
|
|
|
list.Add(handler);
|
|
}
|
|
|
|
return new Removal(() =>
|
|
{
|
|
lock (_gate)
|
|
{
|
|
_handlers[eventName].Remove(handler);
|
|
}
|
|
});
|
|
}
|
|
|
|
private JsonObject Navigate(object? parameters)
|
|
{
|
|
var url = (parameters as JsonObject)?["url"]?.GetValue<string>();
|
|
if (url is not null)
|
|
{
|
|
Navigated(url);
|
|
}
|
|
|
|
return new JsonObject { ["frameId"] = "F1" };
|
|
}
|
|
|
|
private void Raise(string eventName, JsonObject parameters)
|
|
{
|
|
Action<JsonElement>[] handlers;
|
|
lock (_gate)
|
|
{
|
|
handlers = _handlers.TryGetValue(eventName, out var list) ? [.. list] : [];
|
|
}
|
|
|
|
var element = JsonDocument.Parse(parameters.ToJsonString()).RootElement.Clone();
|
|
foreach (var handler in handlers)
|
|
{
|
|
handler(element);
|
|
}
|
|
}
|
|
|
|
private sealed class Removal(Action remove) : IDisposable
|
|
{
|
|
private Action? _remove = remove;
|
|
|
|
public void Dispose() => Interlocked.Exchange(ref _remove, null)?.Invoke();
|
|
}
|
|
}
|