667 lines
33 KiB
C#
667 lines
33 KiB
C#
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Nodes;
|
|
using System.Threading.Channels;
|
|
using AutoForge.Application.Features.DisplayUnits;
|
|
using AutoForge.Application.Features.Vehicles.Diagnostics;
|
|
using AutoForge.Application.Features.Vehicles.Profiles;
|
|
using AutoForge.Application.Features.Vehicles.Simulation;
|
|
using AutoForge.Application.Features.Vehicles.Telemetry.LiveDashboard;
|
|
using AutoForge.Application.Features.Vehicles.Telemetry.Recording;
|
|
using AutoForge.Application.Features.Vehicles.Telemetry.Replay;
|
|
using AutoForge.Core.ExecutionTargets;
|
|
using AutoForge.Diagnostics;
|
|
using AutoForge.Simulation;
|
|
using AutoForge.UI;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
|
|
namespace AutoForge.IntegrationTests;
|
|
|
|
public sealed partial class TelemetryReplayTests
|
|
{
|
|
private const string ProfileId = "autoforge.synthetic.test-truck";
|
|
private const string ModuleA = "module.engine.primary";
|
|
private const string ModuleB = "module.cabin.body";
|
|
private const string SignalId = "recorded.measurement";
|
|
private static readonly TimeSpan Deadline = TimeSpan.FromSeconds(10);
|
|
|
|
[Fact]
|
|
public async Task OfflineLoad_PreindexesOnlyMetadataAndReconstructsTheExactFourRecordPrefix()
|
|
{
|
|
using var fixture = await ReplayFixture.CreateAsync();
|
|
await using var player = fixture.CreatePlayer();
|
|
await player.LoadAsync(fixture.CaptureId);
|
|
var source = player.Snapshot.Archive!;
|
|
var context = player.Snapshot.Context!;
|
|
Assert.Equal(ExecutionTargetKind.RecordedReplay, context.Kind);
|
|
Assert.Equal(fixture.CaptureId, context.CaptureId);
|
|
Assert.Equal(ExecutionTargetKind.Simulation, source.Header.TargetKind);
|
|
Assert.Equal(ReplayState.Stopped, player.Snapshot.State);
|
|
Assert.Equal(0, player.Snapshot.AppliedCount);
|
|
Assert.Equal(0, player.Snapshot.PositionTicks);
|
|
Assert.Equal(4 * TimeSpan.TicksPerSecond, player.Snapshot.DurationTicks);
|
|
Assert.Equal(2, player.Snapshot.AvailableSignals.Count);
|
|
Configure(player);
|
|
Assert.All(player.Snapshot.Values, value => Assert.Null(value.Signal));
|
|
|
|
player.SeekTime(TimeSpan.FromSeconds(1.5).Ticks);
|
|
AssertPrefix(player, 1, 1.5, 850, DashboardReadingState.Good, null);
|
|
player.SeekTime(TimeSpan.FromSeconds(2).Ticks);
|
|
AssertPrefix(player, 3, 2, 1000, DashboardReadingState.Uncertain, 12.6);
|
|
Assert.Equal(DashboardReadingState.OutOfRangeHigh, player.Snapshot.Values[0].RangeState);
|
|
Assert.Equal(100, player.Snapshot.Values[0].BarPercent);
|
|
player.SeekTime(TimeSpan.FromSeconds(4).Ticks);
|
|
AssertPrefix(player, 4, 4, 850, DashboardReadingState.Stale, 12.6);
|
|
var stale = player.Snapshot.Values[0];
|
|
Assert.Equal(source.Observations[0].SignalSnapshot!.Signals[0].LogicalTimeTicks, stale.Signal!.LogicalTimeTicks);
|
|
Assert.Equal(1, player.Snapshot.SampleContexts[stale.Definition.GaugeIdentifier].Sequence);
|
|
Assert.Equal(TimeSpan.TicksPerSecond, player.Snapshot.SampleContexts[stale.Definition.GaugeIdentifier].CaptureElapsedTicks);
|
|
Assert.Contains("Timeout", stale.Reason);
|
|
Assert.Equal(ReplayState.Completed, player.Snapshot.State);
|
|
Assert.Equal(850d / 900 * 100, player.Snapshot.Values[0].BarPercent);
|
|
|
|
player.Previous();
|
|
AssertPrefix(player, 3, 2, 1000, DashboardReadingState.Uncertain, 12.6);
|
|
player.SeekOrdinal(1);
|
|
AssertPrefix(player, 1, 1, 850, DashboardReadingState.Good, null);
|
|
Assert.DoesNotContain(player.Snapshot.Modules, status => status.ModuleIdentifier == ModuleB);
|
|
player.First();
|
|
Assert.Equal(0, player.Snapshot.AppliedCount);
|
|
Assert.All(player.Snapshot.Values, value => Assert.Null(value.NumericValue));
|
|
Assert.Empty(player.Snapshot.Modules);
|
|
Assert.Equal(2, player.Snapshot.Definitions.Count);
|
|
Assert.Same(context, player.Snapshot.Context);
|
|
Assert.Equal(0, fixture.Store.SaveCalls);
|
|
Assert.Equal(fixture.Bytes, await File.ReadAllBytesAsync(fixture.ArchivePath));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task EqualAndZeroTimes_ManualNextIsOneButTimeSeekAndPlayApplyCompleteGroups()
|
|
{
|
|
using var fixture = await ReplayFixture.CreateAsync(allZero: true);
|
|
await using var player = fixture.CreatePlayer();
|
|
await player.LoadAsync(fixture.CaptureId);
|
|
Configure(player);
|
|
Assert.Equal(0, player.Snapshot.DurationTicks);
|
|
player.Next();
|
|
Assert.Equal(1, player.Snapshot.AppliedCount);
|
|
Assert.Equal(ReplayState.Paused, player.Snapshot.State);
|
|
player.Next();
|
|
Assert.Equal(2, player.Snapshot.AppliedCount);
|
|
player.SeekTime(0);
|
|
Assert.Equal(4, player.Snapshot.AppliedCount);
|
|
Assert.Equal(ReplayState.Completed, player.Snapshot.State);
|
|
player.First();
|
|
await player.PlayAsync();
|
|
Assert.Equal(4, player.Snapshot.AppliedCount);
|
|
Assert.Equal(ReplayState.Completed, player.Snapshot.State);
|
|
Assert.Equal(0, fixture.Waiter.WaitCount);
|
|
await player.StopAsync();
|
|
Assert.Equal(0, player.Snapshot.AppliedCount);
|
|
Assert.All(player.Snapshot.Values, value => Assert.Null(value.Signal));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task EmptyAndNonSignalArchives_NeverFabricateMeasurementsOrUseUtcDuration()
|
|
{
|
|
using var fixture = await ReplayFixture.CreateAsync(empty: true);
|
|
await using var player = fixture.CreatePlayer();
|
|
await player.LoadAsync(fixture.CaptureId);
|
|
Assert.Empty(player.Snapshot.AvailableSignals);
|
|
Assert.Equal(0, player.Snapshot.DurationTicks);
|
|
await player.PlayAsync();
|
|
Assert.Equal(ReplayState.Completed, player.Snapshot.State);
|
|
Assert.Equal(0, fixture.Waiter.WaitCount);
|
|
player.SeekTime(0);
|
|
Assert.Equal(ReplayState.Stopped, player.Snapshot.State);
|
|
AssertRejected(player, () => player.Next(), ReplayFailure.NoRecords);
|
|
AssertRejected(player, () => player.Previous(), ReplayFailure.NoRecords);
|
|
await player.RestartAsync();
|
|
Assert.Equal(ReplayState.Completed, player.Snapshot.State);
|
|
|
|
using var nonSignal = await ReplayFixture.CreateAsync(nonSignal: true);
|
|
await using var other = nonSignal.CreatePlayer();
|
|
await other.LoadAsync(nonSignal.CaptureId);
|
|
other.Next();
|
|
Assert.Equal(DiagnosticServices.ReadTroubleCodes, other.Snapshot.CurrentObservation!.Service);
|
|
Assert.Empty(other.Snapshot.Values);
|
|
Assert.Empty(other.Snapshot.Modules);
|
|
Assert.Equal(1, other.Snapshot.AppliedCount);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0.25)]
|
|
[InlineData(1)]
|
|
[InlineData(1000)]
|
|
public async Task ControlledPacing_ScalesCaptureIntervalsWithoutChangingRecordedResults(double rate)
|
|
{
|
|
using var fixture = await ReplayFixture.CreateAsync();
|
|
await using var player = fixture.CreatePlayer();
|
|
await player.LoadAsync(fixture.CaptureId);
|
|
Configure(player);
|
|
player.SetRate(rate);
|
|
await player.PlayAsync();
|
|
var firstWait = await fixture.Waiter.TakeAsync();
|
|
try
|
|
{
|
|
Assert.Equal(TimeSpan.FromSeconds(1 / rate), firstWait.Interval);
|
|
fixture.Clock.Advance(firstWait.Interval);
|
|
firstWait.Release();
|
|
var secondWait = await fixture.Waiter.TakeAsync();
|
|
Assert.Equal(1, player.Snapshot.AppliedCount);
|
|
Assert.Equal(TimeSpan.FromSeconds(1 / rate), secondWait.Interval);
|
|
fixture.Clock.Advance(secondWait.Interval);
|
|
secondWait.Release();
|
|
var thirdWait = await fixture.Waiter.TakeAsync();
|
|
AssertPrefix(player, 3, 2, 1000, DashboardReadingState.Uncertain, 12.6);
|
|
Assert.Equal(TimeSpan.FromSeconds(2 / rate), thirdWait.Interval);
|
|
fixture.Clock.Advance(thirdWait.Interval);
|
|
thirdWait.Release();
|
|
await WaitForStateAsync(player, ReplayState.Completed);
|
|
AssertPrefix(player, 4, 4, 850, DashboardReadingState.Stale, 12.6);
|
|
}
|
|
finally
|
|
{
|
|
fixture.Waiter.ReleaseAll();
|
|
await player.StopAsync();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task MidGapPause_DrainsOneOwnerAndResumeWaitsOnlyTheRemainingInterval()
|
|
{
|
|
using var fixture = await ReplayFixture.CreateAsync();
|
|
await using var player = fixture.CreatePlayer();
|
|
await player.LoadAsync(fixture.CaptureId);
|
|
Configure(player);
|
|
player.SeekTime(TimeSpan.FromSeconds(1.5).Ticks);
|
|
player.SetRate(2);
|
|
await player.PlayAsync();
|
|
var wait = await fixture.Waiter.TakeAsync();
|
|
try
|
|
{
|
|
Assert.Equal(TimeSpan.FromSeconds(0.25), wait.Interval);
|
|
await player.PlayAsync();
|
|
Assert.Equal(1, fixture.Waiter.WaitCount);
|
|
fixture.Clock.Advance(TimeSpan.FromSeconds(0.10));
|
|
var pause = player.PauseAsync();
|
|
Assert.False(pause.IsCompleted);
|
|
Assert.True(player.Snapshot.IsDraining);
|
|
Assert.Equal(TimeSpan.FromSeconds(1.7).Ticks, player.Snapshot.PositionTicks);
|
|
Assert.Equal(1, player.Snapshot.AppliedCount);
|
|
var state = player.Snapshot;
|
|
AssertRejected(player, () => player.Next(), ReplayFailure.Busy);
|
|
AssertRejected(player, () => player.SetRate(10), ReplayFailure.Busy);
|
|
await Assert.ThrowsAsync<TelemetryReplayException>(() => player.PlayAsync());
|
|
await Assert.ThrowsAsync<TelemetryReplayException>(() => player.LoadAsync(fixture.CaptureId));
|
|
Assert.Equal(state.Context, player.Snapshot.Context);
|
|
fixture.Clock.Advance(TimeSpan.FromSeconds(3));
|
|
wait.Release();
|
|
await pause.WaitAsync(Deadline);
|
|
Assert.Equal(TimeSpan.FromSeconds(1.7).Ticks, player.Snapshot.PositionTicks);
|
|
Assert.False(player.Snapshot.IsDraining);
|
|
await player.PlayAsync();
|
|
var resumed = await fixture.Waiter.TakeAsync();
|
|
Assert.Equal(TimeSpan.FromSeconds(0.15), resumed.Interval);
|
|
fixture.Clock.Advance(resumed.Interval);
|
|
resumed.Release();
|
|
var next = await fixture.Waiter.TakeAsync();
|
|
AssertPrefix(player, 3, 2, 1000, DashboardReadingState.Uncertain, 12.6);
|
|
var stop = player.StopAsync();
|
|
Assert.Same(stop, player.StopAsync());
|
|
Assert.False(stop.IsCompleted);
|
|
AssertRejected(player, () => player.First(), ReplayFailure.Busy);
|
|
next.Release();
|
|
await stop.WaitAsync(Deadline);
|
|
Assert.Equal(ReplayState.Stopped, player.Snapshot.State);
|
|
Assert.All(player.Snapshot.Values, value => Assert.Null(value.Signal));
|
|
}
|
|
finally
|
|
{
|
|
fixture.Waiter.ReleaseAll();
|
|
await player.StopAsync();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task WaitFault_IsVisibleAndKeepsCommittedPrefixUntilExplicitRecovery()
|
|
{
|
|
using var fixture = await ReplayFixture.CreateAsync();
|
|
await using var player = fixture.CreatePlayer();
|
|
await player.LoadAsync(fixture.CaptureId);
|
|
Configure(player);
|
|
player.SeekOrdinal(1);
|
|
await player.PlayAsync();
|
|
var wait = await fixture.Waiter.TakeAsync();
|
|
wait.Fail(new IOException("controlled replay wait failure"));
|
|
await WaitForStateAsync(player, ReplayState.Faulted);
|
|
Assert.Equal(1, player.Snapshot.AppliedCount);
|
|
Assert.Equal(850, player.Snapshot.Values[0].NumericValue);
|
|
Assert.Equal(DashboardReadingState.Good, player.Snapshot.Values[0].State);
|
|
Assert.Contains("controlled replay wait failure", player.Snapshot.Error);
|
|
await Assert.ThrowsAsync<TelemetryReplayException>(() => player.PlayAsync());
|
|
AssertRejected(player, () => player.Next(), ReplayFailure.Faulted);
|
|
AssertRejected(player, () => player.SeekTime(0), ReplayFailure.Faulted);
|
|
AssertRejected(player, () => player.SeekOrdinal(0), ReplayFailure.Faulted);
|
|
await Assert.ThrowsAsync<TelemetryReplayException>(() => player.RestartAsync());
|
|
await player.StopAsync();
|
|
Assert.Equal(ReplayState.Stopped, player.Snapshot.State);
|
|
Assert.Equal(0, player.Snapshot.AppliedCount);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task InvalidRequests_AreTypedVisibleAndAtomicIncludingClosedAndUnloadedPlayers()
|
|
{
|
|
using var fixture = await ReplayFixture.CreateAsync();
|
|
await using var player = fixture.CreatePlayer();
|
|
AssertRejected(player, () => player.Next(), ReplayFailure.NotLoaded);
|
|
await player.LoadAsync(fixture.CaptureId);
|
|
Configure(player);
|
|
player.SeekOrdinal(1);
|
|
foreach (var rate in new[] { double.NaN, double.PositiveInfinity, double.NegativeInfinity, 0.249, 1000.001 })
|
|
{
|
|
AssertRejected(player, () => player.SetRate(rate), ReplayFailure.InvalidRate);
|
|
}
|
|
AssertRejected(player, () => player.SeekTime(-1), ReplayFailure.InvalidPosition);
|
|
AssertRejected(player, () => player.SeekTime(player.Snapshot.DurationTicks + 1), ReplayFailure.InvalidPosition);
|
|
AssertRejected(player, () => player.SeekOrdinal(5), ReplayFailure.InvalidPosition);
|
|
AssertRejected(player, () => player.SeekOrdinal(-1), ReplayFailure.InvalidPosition);
|
|
var original = player.Snapshot.Definitions;
|
|
var invalid = original[0] with { Unit = "RPM" };
|
|
Assert.Throws<DashboardConfigurationException>(() => player.ReplaceDefinitions([invalid]));
|
|
Assert.Equal(original, player.Snapshot.Definitions);
|
|
Assert.Throws<DashboardConfigurationException>(() => player.ReplaceDefinitions(
|
|
Enumerable.Range(0, 9).Select(index => original[0] with { GaugeIdentifier = $"g{index}" })));
|
|
Assert.Equal(original, player.Snapshot.Definitions);
|
|
foreach (var definition in new[]
|
|
{
|
|
original[0] with { Label = " " },
|
|
original[0] with { Kind = (DashboardGaugeKind)99 },
|
|
original[0] with { Minimum = double.NaN },
|
|
original[0] with { Minimum = -double.MaxValue, Maximum = double.MaxValue },
|
|
original[0] with { Minimum = 1, Maximum = 1 },
|
|
original[0] with { DecimalPrecision = 4 }
|
|
})
|
|
{
|
|
var before = player.Snapshot;
|
|
Assert.Throws<DashboardConfigurationException>(() => player.ReplaceDefinitions([definition]));
|
|
AssertUnchanged(before, player.Snapshot);
|
|
}
|
|
Assert.Throws<DashboardConfigurationException>(() => player.ReplaceDefinitions([original[0], original[0] with { GaugeIdentifier = "A" }]));
|
|
player.ReplaceDefinitions(Enumerable.Range(0, 8).Select(index => original[0] with { GaugeIdentifier = $"g{index}" }));
|
|
Assert.Equal(8, player.Snapshot.Values.Count);
|
|
player.ReplaceDefinitions([]);
|
|
Assert.Empty(player.Snapshot.Values);
|
|
Assert.Equal(1, player.Snapshot.AppliedCount);
|
|
await player.DisposeAsync();
|
|
AssertRejected(player, () => player.Next(), ReplayFailure.Closed);
|
|
Assert.Equal(0, fixture.Store.SaveCalls);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(TelemetryCaptureState.Incomplete)]
|
|
[InlineData(TelemetryCaptureState.Error)]
|
|
public async Task PartialAcknowledgement_IsPerLoadAndEndNeverRewritesOriginalCompletion(TelemetryCaptureState sourceState)
|
|
{
|
|
using var fixture = await ReplayFixture.CreateAsync(partial: sourceState);
|
|
await using var player = fixture.CreatePlayer();
|
|
await player.LoadAsync(fixture.CaptureId);
|
|
AssertRejected(player, () => player.Next(), ReplayFailure.AcknowledgementRequired);
|
|
AssertRejected(player, () => player.SeekTime(0), ReplayFailure.AcknowledgementRequired);
|
|
AssertRejected(player, () => player.SeekOrdinal(0), ReplayFailure.AcknowledgementRequired);
|
|
await Assert.ThrowsAsync<TelemetryReplayException>(() => player.PlayAsync());
|
|
player.First();
|
|
await player.StopAsync();
|
|
player.AcknowledgePartial();
|
|
player.SeekOrdinal(4);
|
|
Assert.Equal(sourceState, player.Snapshot.Archive!.Completion!.State);
|
|
Assert.Equal(ReplayState.Completed, player.Snapshot.State);
|
|
await player.StopAsync();
|
|
Assert.True(player.Snapshot.PartialAcknowledged);
|
|
player.SetRate(0.25);
|
|
var identity = player.Snapshot.Context;
|
|
await player.LoadAsync(fixture.CaptureId);
|
|
Assert.NotEqual(identity, player.Snapshot.Context);
|
|
Assert.False(player.Snapshot.PartialAcknowledged);
|
|
Assert.Equal(0.25, player.Snapshot.Rate);
|
|
Assert.Empty(player.Snapshot.Definitions);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task FailedCancelledAndLateLoads_PreserveValidatedContextAndCloseDrainsWithoutStalePublication()
|
|
{
|
|
using var fixture = await ReplayFixture.CreateAsync();
|
|
await using var player = fixture.CreatePlayer();
|
|
await player.LoadAsync(fixture.CaptureId);
|
|
Configure(player);
|
|
player.SeekOrdinal(1);
|
|
var before = player.Snapshot;
|
|
await Assert.ThrowsAsync<TelemetryArchiveException>(() => player.LoadAsync(new string('f', 32)));
|
|
AssertUnchanged(before, player.Snapshot);
|
|
Assert.NotNull(player.Snapshot.Error);
|
|
using var cancellation = new CancellationTokenSource();
|
|
fixture.Store.HoldLoads = true;
|
|
var load = player.LoadAsync(fixture.CaptureId, cancellation.Token);
|
|
await fixture.Store.LoadEntered.Task.WaitAsync(Deadline);
|
|
AssertRejected(player, () => player.Next(), ReplayFailure.Busy);
|
|
cancellation.Cancel();
|
|
fixture.Store.ReleaseLoad();
|
|
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => load);
|
|
AssertUnchanged(before, player.Snapshot);
|
|
|
|
fixture.Store.ResetLoadBarrier();
|
|
var late = player.LoadAsync(fixture.CaptureId);
|
|
await fixture.Store.LoadEntered.Task.WaitAsync(Deadline);
|
|
var close = player.DisposeAsync().AsTask();
|
|
Assert.Same(close, player.DisposeAsync().AsTask());
|
|
Assert.False(close.IsCompleted);
|
|
fixture.Store.ReleaseLoad();
|
|
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => late);
|
|
await close.WaitAsync(Deadline);
|
|
Assert.Equal(ReplayState.Closed, player.Snapshot.State);
|
|
Assert.Same(before.Context, player.Snapshot.Context);
|
|
Assert.Same(before.Archive, player.Snapshot.Archive);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CloseWithDelayedOldWake_NeverPublishesIntoClosedOrFreshFactorySession()
|
|
{
|
|
using var fixture = await ReplayFixture.CreateAsync();
|
|
await using var player = fixture.CreatePlayer();
|
|
await player.LoadAsync(fixture.CaptureId);
|
|
await player.PlayAsync();
|
|
var wait = await fixture.Waiter.TakeAsync();
|
|
try
|
|
{
|
|
var close = player.DisposeAsync().AsTask();
|
|
Assert.False(close.IsCompleted);
|
|
fixture.Clock.Advance(TimeSpan.FromSeconds(20));
|
|
await using var fresh = fixture.CreatePlayer();
|
|
await fresh.LoadAsync(fixture.CaptureId);
|
|
wait.Release();
|
|
await close.WaitAsync(Deadline);
|
|
Assert.Equal(ReplayState.Closed, player.Snapshot.State);
|
|
Assert.Equal(0, player.Snapshot.AppliedCount);
|
|
Assert.Equal(ReplayState.Stopped, fresh.Snapshot.State);
|
|
Assert.Equal(0, fresh.Snapshot.AppliedCount);
|
|
Assert.NotEqual(player.Snapshot.Context, fresh.Snapshot.Context);
|
|
}
|
|
finally
|
|
{
|
|
fixture.Waiter.ReleaseAll();
|
|
}
|
|
}
|
|
|
|
private static void Configure(TelemetryReplaySession player) => player.ReplaceDefinitions(
|
|
[
|
|
new("a", "Recorded A", DashboardGaugeKind.HorizontalBar, ModuleA, SignalId, "rpm", 0, 900, 0),
|
|
new("b", "Recorded B", DashboardGaugeKind.Numeric, ModuleB, SignalId, "V", 0, 15, 1)
|
|
]);
|
|
|
|
private static void AssertPrefix(TelemetryReplaySession player, int count, double seconds,
|
|
double a, DashboardReadingState state, double? b)
|
|
{
|
|
var snapshot = player.Snapshot;
|
|
Assert.Equal(count, snapshot.AppliedCount);
|
|
Assert.Equal(TimeSpan.FromSeconds(seconds).Ticks, snapshot.PositionTicks);
|
|
Assert.Equal(a, snapshot.Values[0].NumericValue);
|
|
Assert.Equal(state, snapshot.Values[0].State);
|
|
Assert.Equal(b, snapshot.Values[1].NumericValue);
|
|
if (b is null)
|
|
{
|
|
Assert.Null(snapshot.Values[1].Signal);
|
|
}
|
|
}
|
|
|
|
private static void AssertRejected(TelemetryReplaySession player, Action command, ReplayFailure failure)
|
|
{
|
|
var previous = player.Snapshot;
|
|
var exception = Assert.Throws<TelemetryReplayException>(command);
|
|
Assert.Equal(failure, exception.Failure);
|
|
AssertUnchanged(previous, player.Snapshot);
|
|
Assert.Equal(exception.Message, player.Snapshot.Error);
|
|
}
|
|
|
|
private static void AssertUnchanged(TelemetryReplaySnapshot previous, TelemetryReplaySnapshot current)
|
|
{
|
|
Assert.Same(previous.Context, current.Context);
|
|
Assert.Same(previous.Archive, current.Archive);
|
|
Assert.Equal(previous.State, current.State);
|
|
Assert.Equal(previous.PositionTicks, current.PositionTicks);
|
|
Assert.Equal(previous.AppliedCount, current.AppliedCount);
|
|
Assert.Equal(previous.Rate, current.Rate);
|
|
Assert.Equal(previous.Definitions, current.Definitions);
|
|
Assert.Equal(previous.Values, current.Values);
|
|
Assert.Equal(previous.IsDraining, current.IsDraining);
|
|
}
|
|
|
|
private static async Task WaitForStateAsync(TelemetryReplaySession player, ReplayState state)
|
|
{
|
|
var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
void Check()
|
|
{
|
|
if (player.Snapshot.State == state && !player.Snapshot.IsDraining)
|
|
{
|
|
completion.TrySetResult();
|
|
}
|
|
}
|
|
player.Changed += Check;
|
|
try
|
|
{
|
|
Check();
|
|
await completion.Task.WaitAsync(Deadline);
|
|
}
|
|
finally
|
|
{
|
|
player.Changed -= Check;
|
|
}
|
|
}
|
|
|
|
private sealed class ManualReplayClock : TimeProvider
|
|
{
|
|
private long _ticks;
|
|
public Exception? Failure { get; set; }
|
|
public override long TimestampFrequency => TimeSpan.TicksPerSecond;
|
|
public override long GetTimestamp() => Failure is { } failure ? throw failure : Interlocked.Read(ref _ticks);
|
|
public override DateTimeOffset GetUtcNow() => DateTimeOffset.UnixEpoch.AddTicks(GetTimestamp());
|
|
public void Advance(TimeSpan amount) => Interlocked.Add(ref _ticks, amount.Ticks);
|
|
}
|
|
|
|
private sealed class ControlledReplayWaiter : IReplayWaiter
|
|
{
|
|
private readonly Channel<WaitRequest> _requests = Channel.CreateUnbounded<WaitRequest>();
|
|
private readonly List<WaitRequest> _all = [];
|
|
private bool _releasedAll;
|
|
public int WaitCount { get; private set; }
|
|
public async Task WaitAsync(TimeSpan interval, CancellationToken cancellationToken)
|
|
{
|
|
var request = new WaitRequest(interval, cancellationToken);
|
|
lock (_all)
|
|
{
|
|
_all.Add(request);
|
|
WaitCount++;
|
|
if (_releasedAll) request.Release();
|
|
}
|
|
using var registration = cancellationToken.Register(() => request.CancellationRequested.TrySetResult());
|
|
_requests.Writer.TryWrite(request);
|
|
await request.Completion.Task;
|
|
}
|
|
public async Task<WaitRequest> TakeAsync() => await _requests.Reader.ReadAsync().AsTask().WaitAsync(Deadline);
|
|
public void ReleaseAll()
|
|
{
|
|
lock (_all)
|
|
{
|
|
_releasedAll = true;
|
|
foreach (var request in _all)
|
|
{
|
|
request.Release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed record WaitRequest(TimeSpan Interval, CancellationToken Cancellation)
|
|
{
|
|
public TaskCompletionSource Completion { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
public TaskCompletionSource CancellationRequested { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
public void Release() => Completion.TrySetResult();
|
|
public void Fail(Exception exception) => Completion.TrySetException(exception);
|
|
}
|
|
|
|
private sealed class ReadOnlySpyStore(ITelemetryArchiveStore inner) : ITelemetryArchiveStore
|
|
{
|
|
private TaskCompletionSource _release = NewBarrier();
|
|
public TaskCompletionSource LoadEntered { get; private set; } = NewBarrier();
|
|
public bool HoldLoads { get; set; }
|
|
public int SaveCalls { get; private set; }
|
|
public Task SaveAsync(TelemetryCaptureSnapshot capture, CancellationToken cancellationToken = default)
|
|
{
|
|
SaveCalls++;
|
|
throw new InvalidOperationException("Replay attempted an archive write.");
|
|
}
|
|
public Task<IReadOnlyList<TelemetrySavedCapture>> ListAsync(CancellationToken cancellationToken = default) =>
|
|
inner.ListAsync(cancellationToken);
|
|
public async Task<TelemetryCaptureSnapshot> LoadAsync(string captureId, CancellationToken cancellationToken = default)
|
|
{
|
|
if (HoldLoads)
|
|
{
|
|
LoadEntered.TrySetResult();
|
|
await _release.Task;
|
|
}
|
|
return await inner.LoadAsync(captureId, CancellationToken.None);
|
|
}
|
|
public void ReleaseLoad() => _release.TrySetResult();
|
|
public void ResetLoadBarrier()
|
|
{
|
|
_release = NewBarrier();
|
|
LoadEntered = NewBarrier();
|
|
}
|
|
private static TaskCompletionSource NewBarrier() => new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
}
|
|
|
|
private sealed class ReplayFixture : IDisposable
|
|
{
|
|
public string DirectoryPath { get; } = Path.Combine(Path.GetTempPath(), $"autoforge-step08-{Guid.NewGuid():N}");
|
|
public string CaptureId { get; private set; } = string.Empty;
|
|
public string ArchivePath => Path.Combine(DirectoryPath, $"{CaptureId}.json");
|
|
public byte[] Bytes { get; private set; } = [];
|
|
public ManualReplayClock Clock { get; } = new();
|
|
public ControlledReplayWaiter Waiter { get; } = new();
|
|
public ReadOnlySpyStore Store { get; private set; } = null!;
|
|
public TelemetryReplaySession CreatePlayer() => new(Store, Clock, Waiter);
|
|
|
|
public static async Task<ReplayFixture> CreateAsync(bool allZero = false, bool empty = false,
|
|
bool nonSignal = false, TelemetryCaptureState? partial = null, bool dynamic = false, bool resetModel = false)
|
|
{
|
|
var fixture = new ReplayFixture();
|
|
try
|
|
{
|
|
Directory.CreateDirectory(fixture.DirectoryPath);
|
|
var services = new ServiceCollection();
|
|
services.AddAutoForgeVehicleProfiles();
|
|
var call = 0;
|
|
var original = new SimulatedDiagnosticTransportFactory(SyntheticDiagnosticExamples.CreateDefinitions());
|
|
var transport = new RewritingDiagnosticTransportFactory(original, async (inner, request, bytes, token) =>
|
|
{
|
|
if (request.Service != DiagnosticServices.ReadSignals)
|
|
{
|
|
return await inner.SendAsync(bytes, token);
|
|
}
|
|
call++;
|
|
if (call == 4)
|
|
{
|
|
return new TransportReply(TransportOutcome.Timeout, ReadOnlyMemory<byte>.Empty, 1, "Timeout fixture");
|
|
}
|
|
var reply = await inner.SendAsync(bytes, token);
|
|
var node = JsonNode.Parse(reply.Payload.Span)!.AsObject();
|
|
node["data"]!["signals"] = new JsonArray(new JsonObject
|
|
{
|
|
["signalIdentifier"] = SignalId,
|
|
["value"] = call == 2 ? JsonValue.Create(12.6) : JsonValue.Create(call == 3 ? 1000 : 850),
|
|
["unit"] = call == 2 ? "V" : "rpm",
|
|
["quality"] = call == 3 ? "Uncertain" : "Good"
|
|
});
|
|
return new TransportReply(TransportOutcome.Response, Encoding.UTF8.GetBytes(node.ToJsonString()), reply.ElapsedTicks);
|
|
});
|
|
services.AddAutoForgeDiagnostics([transport, new DynamicsDiagnosticTransportFactory(SyntheticDiagnosticExamples.CreateDefinitions())]);
|
|
services.AddAutoForgeDynamicsConfigurations();
|
|
services.AddAutoForgeTelemetryRecording(fixture.DirectoryPath);
|
|
services.AddSingleton<TimeProvider>(fixture.Clock);
|
|
services.AddAutoForgeTelemetryRecordingFallback();
|
|
using (var provider = services.BuildServiceProvider())
|
|
{
|
|
provider.GetRequiredService<IVehicleProfileService>().Import(
|
|
File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "Fixtures", "synthetic-truck-baseline.json")));
|
|
var sessionService = provider.GetRequiredService<IDiagnosticSessionService>();
|
|
var session = dynamic
|
|
? await sessionService.OpenDynamicsAsync(ProfileId, 1, DynamicsDiagnosticTransportFactory.ProviderIdentifier,
|
|
ExecutionTargetKind.Simulation, provider.GetRequiredService<IDynamicsConfigurationService>().CreateExample(ProfileId, 1))
|
|
: await sessionService.OpenAsync(ProfileId, 1, original.Descriptor.Target.ProviderIdentifier, ExecutionTargetKind.Simulation);
|
|
await using (session)
|
|
{
|
|
if (resetModel) await session.DynamicsControl!.StepAsync(3);
|
|
var recording = provider.GetRequiredService<TelemetryRecordingWorkspace>();
|
|
recording.Start(session);
|
|
if (!empty)
|
|
{
|
|
var a = session.ExpectedEndpoints.Single(endpoint => endpoint.ModuleIdentifier == ModuleA);
|
|
var b = session.ExpectedEndpoints.Single(endpoint =>
|
|
endpoint.ModuleIdentifier == (dynamic ? "module.transmission.primary" : ModuleB));
|
|
if (nonSignal)
|
|
{
|
|
fixture.Clock.Advance(TimeSpan.FromSeconds(1));
|
|
Assert.True((await session.ReadTroubleCodesAsync(a)).IsSuccess);
|
|
}
|
|
else
|
|
{
|
|
if (!allZero) fixture.Clock.Advance(TimeSpan.FromSeconds(1));
|
|
Assert.True((await session.ReadSignalsAsync(a)).IsSuccess);
|
|
if (resetModel) await session.DynamicsControl!.ResetAsync();
|
|
if (!allZero) fixture.Clock.Advance(TimeSpan.FromSeconds(1));
|
|
Assert.True((await session.ReadSignalsAsync(b)).IsSuccess);
|
|
Assert.True((await session.ReadSignalsAsync(a)).IsSuccess);
|
|
if (!allZero) fixture.Clock.Advance(TimeSpan.FromSeconds(2));
|
|
var last = await session.ReadSignalsAsync(a);
|
|
Assert.Equal(dynamic ? DiagnosticOutcome.PositiveResponse : DiagnosticOutcome.Timeout, last.Outcome);
|
|
}
|
|
}
|
|
recording.Stop();
|
|
var capture = recording.CurrentCapture!;
|
|
if (partial is { } state)
|
|
{
|
|
capture = new TelemetryCaptureSnapshot(capture.Header, capture.Observations,
|
|
capture.Completion! with
|
|
{
|
|
State = state,
|
|
StopReason = state == TelemetryCaptureState.Incomplete
|
|
? TelemetryCaptureStopReason.LimitExceeded : TelemetryCaptureStopReason.ObservationFailure,
|
|
Error = state == TelemetryCaptureState.Error ? "Recorded source error" : null
|
|
});
|
|
}
|
|
fixture.CaptureId = capture.Header.CaptureId;
|
|
await provider.GetRequiredService<ITelemetryArchiveStore>().SaveAsync(capture);
|
|
}
|
|
}
|
|
fixture.Bytes = await File.ReadAllBytesAsync(fixture.ArchivePath);
|
|
fixture.Store = new ReadOnlySpyStore(new FileTelemetryArchiveStore(fixture.DirectoryPath));
|
|
return fixture;
|
|
}
|
|
catch
|
|
{
|
|
fixture.Dispose();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Waiter.ReleaseAll();
|
|
Store?.ReleaseLoad();
|
|
if (Directory.Exists(DirectoryPath))
|
|
{
|
|
Directory.Delete(DirectoryPath, recursive: true);
|
|
}
|
|
}
|
|
}
|
|
}
|