AutoForge/src/tests/AutoForge.IntegrationTests/CalibrationAuthoringUiTests.cs

228 lines
13 KiB
C#

using System.Globalization;
using AutoForge.Application.Features.DisplayUnits;
using AutoForge.Application.Features.Vehicles.Calibration;
using AutoForge.Core.Calibration;
using AutoForge.UI.Features.Vehicles.Calibration;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Rendering;
using Microsoft.AspNetCore.Components.RenderTree;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.Components.Web;
#pragma warning disable BL0006
namespace AutoForge.IntegrationTests;
public sealed partial class CalibrationAuthoringTests
{
[Fact]
public async Task RealEditor_SaveDiffHistoryAndInvalidInput_UseExactVersionsNotSharedDraftReferences()
{
using var provider = CreateProvider();
var warm = CreateWarm(provider);
var service = provider.GetRequiredService<CalibrationAuthoringService>();
await using var renderer = new CalibrationEventRenderer(provider);
var root = renderer.Attach(typeof(CalibrationPage));
await renderer.Dispatcher.InvokeAsync(async () =>
{
await renderer.RenderAsync(root);
await renderer.ChangeAsync(root, "calibration-config", warm.ConfigurationIdentifier);
await renderer.ClickAsync(root, "calibration-create");
var baseline = service.Snapshot!;
Assert.Contains("Synthetic configuration-derived baseline", renderer.Text(root));
await renderer.ChangeAsync(root, "calibration-scalar", "1250");
Assert.Equal(650, baseline.Head.Values.Scalars[0].Value);
await renderer.ClickAsync(root, "calibration-save");
var first = service.Snapshot!;
Assert.Equal(1250, first.Head.Values.Scalars[0].Value);
await renderer.ChangeAsync(root, "calibration-torque-2", DisplayUnitConverter.Project(
350, "N*m", DisplayUnitSelection.Default).Value!.Value.ToString("R", CultureInfo.InvariantCulture));
await renderer.ClickAsync(root, "calibration-save");
var second = service.Snapshot!;
var editedDisplay = DisplayUnitConverter.Project(350, "N*m", DisplayUnitSelection.Default).Value!.Value;
var expectedCanonical = editedDisplay / ((1 / 4.4482216152605) * (1 / 0.3048));
Assert.Equal(expectedCanonical, second.Head.Values.Tables[0].Cells[2]);
await renderer.ChangeAsync(root, "calibration-diff-from", baseline.Head.Identifier);
await renderer.ChangeAsync(root, "calibration-diff-to", second.Head.Identifier);
await renderer.ClickAsync(root, "calibration-compare");
Assert.Contains("650 -> 1250", renderer.Text(root));
Assert.Contains("360 ->", renderer.Text(root));
Assert.Contains("2000 rpm", renderer.Text(root));
await renderer.ChangeAsync(root, "calibration-inspect", baseline.Head.Identifier);
Assert.Contains(baseline.Head.Identifier, renderer.Text(root));
Assert.Equal(second.Head.Identifier, service.Snapshot!.Head.Identifier);
await renderer.ChangeAsync(root, "calibration-scalar", "not-a-number");
await renderer.ClickAsync(root, "calibration-save");
Assert.Contains("finite", renderer.Text(root));
Assert.Same(second, service.Snapshot);
await renderer.ChangeAsync(root, "calibration-scalar", "600");
await renderer.ClickAsync(root, "calibration-save");
Assert.Contains("650", renderer.Text(root));
Assert.Same(second, service.Snapshot);
});
Assert.Contains(typeof(CalibrationPage).GetCustomAttributes(typeof(RouteAttribute), false).Cast<RouteAttribute>(),
route => route.Template == "/calibration");
}
[Fact]
public async Task TorqueDraft_IsPinnedAndUneditedSavePreservesExactCanonicalDoublesAcrossToggles()
{
using var provider = CreateProvider();
var warm = CreateWarm(provider);
var service = provider.GetRequiredService<CalibrationAuthoringService>();
var before = service.CreateBaseline(warm.ConfigurationIdentifier);
await using var renderer = new CalibrationEventRenderer(provider);
var host = new CalibrationUnitHost();
var root = renderer.Attach(host);
await renderer.Dispatcher.InvokeAsync(async () =>
{
await renderer.RenderAsync(root);
var source = before.Head.Values.Tables[0].Cells.ToArray();
var originalText = renderer.Attribute(root, "calibration-torque-2", "value")!.ToString();
var proposal = DisplayUnitConverter.Project(350, "N*m", DisplayUnitSelection.Default).Value!.Value;
await renderer.ChangeAsync(root, "calibration-torque-2", proposal.ToString("R", CultureInfo.InvariantCulture));
host.SetUnits(new(DisplayUnitSystem.Metric, SpeedDisplayMode.Road));
Assert.Equal(proposal.ToString("R", CultureInfo.InvariantCulture),
renderer.Attribute(root, "calibration-torque-2", "value")!.ToString());
Assert.Contains("Draft input pinned to ImperialUS", renderer.Text(root));
Assert.Equal(source, service.Snapshot!.Head.Values.Tables[0].Cells);
await renderer.ClickAsync(root, "calibration-save");
var committed = service.Snapshot!;
Assert.Equal(proposal / ((1 / 4.4482216152605) * (1 / 0.3048)), committed.Head.Values.Tables[0].Cells[2]);
var canonical = committed.Head.Values.Tables[0].Cells.ToArray();
for (var index = 0; index < 8; index++)
{
host.SetUnits(index % 2 == 0 ? DisplayUnitSelection.Default : new(DisplayUnitSystem.Metric, SpeedDisplayMode.Road));
await renderer.ClickAsync(root, "calibration-save");
Assert.Same(committed.Head, service.Snapshot!.Head);
Assert.Equal(canonical, service.Snapshot.Head.Values.Tables[0].Cells);
}
Assert.NotNull(originalText);
});
}
[Fact]
public async Task TwoActualEditorsAndSourceReplacement_RejectStaleOrUnconfirmedLossWithoutMutation()
{
using var provider = CreateProvider();
var warm = CreateWarm(provider);
var alternate = ImportVariant(provider, json => json["model"]!["warmIdleTargetRpm"] = 700);
var service = provider.GetRequiredService<CalibrationAuthoringService>();
var baseline = service.CreateBaseline(warm.ConfigurationIdentifier);
await using var renderer = new CalibrationEventRenderer(provider);
var first = renderer.Attach(typeof(CalibrationPage));
var second = renderer.Attach(typeof(CalibrationPage));
await renderer.Dispatcher.InvokeAsync(async () =>
{
await renderer.RenderAsync(first);
await renderer.RenderAsync(second);
await renderer.ChangeAsync(first, "calibration-scalar", "1250");
await renderer.ClickAsync(first, "calibration-save");
var committed = service.Snapshot!;
await renderer.ChangeAsync(second, "calibration-scalar", "1300");
await renderer.ClickAsync(second, "calibration-save");
Assert.Contains("head", renderer.Text(second));
Assert.Same(committed, service.Snapshot);
await renderer.ChangeAsync(first, "calibration-config", alternate.ConfigurationIdentifier);
await renderer.ClickAsync(first, "calibration-save");
Assert.Contains("source", renderer.Text(first));
Assert.Same(committed, service.Snapshot);
await renderer.ClickAsync(first, "calibration-replace");
Assert.Contains("confirm", renderer.Text(first));
Assert.Same(committed, service.Snapshot);
await renderer.CheckAsync(first, "calibration-replace-confirm", true);
await renderer.ClickAsync(first, "calibration-replace");
Assert.Single(service.Snapshot!.History);
Assert.Equal(700, service.Snapshot.Head.Values.Scalars[0].Value);
Assert.NotEqual(baseline.Identifier, service.Snapshot.Identifier);
await renderer.ClickAsync(second, "calibration-save");
Assert.Contains("source", renderer.Text(second));
Assert.Single(service.Snapshot.History);
});
}
private sealed class CalibrationUnitHost : ComponentBase
{
private DisplayUnitSelection _selection = DisplayUnitSelection.Default;
public void SetUnits(DisplayUnitSelection selection) { _selection = selection; StateHasChanged(); }
protected override void BuildRenderTree(RenderTreeBuilder builder)
{
builder.OpenComponent<CascadingValue<DisplayUnitSelection>>(0);
builder.AddAttribute(1, "Value", _selection);
builder.AddAttribute(2, "ChildContent", (RenderFragment)(child =>
{
child.OpenComponent<CalibrationPage>(0);
child.CloseComponent();
}));
builder.CloseComponent();
}
}
private sealed class CalibrationEventRenderer(IServiceProvider services)
: Renderer(services, services.GetRequiredService<ILoggerFactory>())
{
public override Dispatcher Dispatcher { get; } = Dispatcher.CreateDefault();
public int Attach(Type type) => AssignRootComponentId(InstantiateComponent(type));
public int Attach(IComponent component) => AssignRootComponentId(component);
public Task RenderAsync(int root) => RenderRootComponentAsync(root, ParameterView.Empty);
public string Text(int root) => string.Concat(ComponentIds(root).SelectMany(id =>
{
var frames = GetCurrentRenderTreeFrames(id);
return frames.Array.Take(frames.Count).Select(frame => frame.FrameType switch
{
RenderTreeFrameType.Text => frame.TextContent,
RenderTreeFrameType.Markup => frame.MarkupContent,
_ => string.Empty
});
}));
public object? Attribute(int root, string elementId, string attribute) =>
Element(root, elementId).Frames.FirstOrDefault(frame =>
frame.FrameType == RenderTreeFrameType.Attribute && frame.AttributeName == attribute).AttributeValue;
public Task ChangeAsync(int root, string elementId, string value) => ChangeCoreAsync(root, elementId, value);
public Task CheckAsync(int root, string elementId, bool value) => ChangeCoreAsync(root, elementId, value);
private Task ChangeCoreAsync(int root, string elementId, object value)
{
var node = Element(root, elementId);
var handler = node.Frames.Single(frame => frame.FrameType == RenderTreeFrameType.Attribute && frame.AttributeName == "onchange");
return DispatchEventAsync(handler.AttributeEventHandlerId,
new EventFieldInfo { ComponentId = node.Id, FieldValue = value }, new ChangeEventArgs { Value = value });
}
public Task ClickAsync(int root, string elementId)
{
var handler = Element(root, elementId).Frames.Single(frame =>
frame.FrameType == RenderTreeFrameType.Attribute && frame.AttributeName == "onclick");
return DispatchEventAsync(handler.AttributeEventHandlerId, null, new MouseEventArgs());
}
private (int Id, RenderTreeFrame[] Frames) Element(int root, string elementId)
{
foreach (var id in ComponentIds(root))
{
var frames = GetCurrentRenderTreeFrames(id);
for (var index = 0; index < frames.Count; index++)
{
if (frames.Array[index].FrameType != RenderTreeFrameType.Element) continue;
var element = frames.Array.Skip(index).Take(frames.Array[index].ElementSubtreeLength).ToArray();
if (element.Skip(1).TakeWhile(frame => frame.FrameType == RenderTreeFrameType.Attribute)
.Any(frame => frame.AttributeName == "id" && frame.AttributeValue?.ToString() == elementId)) return (id, element);
}
}
throw new InvalidOperationException($"Missing rendered calibration control '{elementId}'.");
}
private IEnumerable<int> ComponentIds(int root)
{
yield return root;
var frames = GetCurrentRenderTreeFrames(root);
for (var index = 0; index < frames.Count; index++)
{
if (frames.Array[index].FrameType != RenderTreeFrameType.Component) continue;
foreach (var nested in ComponentIds(frames.Array[index].ComponentId)) yield return nested;
}
}
protected override void HandleException(Exception exception) => throw new InvalidOperationException("Calibration UI failed.", exception);
protected override Task UpdateDisplayAsync(in RenderBatch renderBatch) => Task.CompletedTask;
}
}
#pragma warning restore BL0006