228 lines
13 KiB
C#
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
|