fix(engine): enforce whole-job safety invariants

Task 5 of the whole-job engine API: add a geometry safety gate that validates every candidate trial before the runner commits accounting. - NestJobPlacementValidator: closed-contour validity, rotation-policy compliance, work-area containment per quadrant, hole-aware material overlap, and required part spacing. Overlap is interior-only, so zero-clearance edge/corner contact remains a valid placement. - NestJobValidator: route candidate validation through the geometry gate; reject unusable/unclosed/degenerate contours up front. - NestJobRunner: wrap candidate evaluation in a progress bridge that tags legacy engine detail with the current candidate context. - LegacyPlateNesterAdapter: forward IProgress to the legacy engine so its progress surfaces under the active candidate. - Tests: geometry (quadrants, rotations, touching, containment, holes, empty stock, real Default/Strip smoke), validation, and cancellation suites; repaired test fakes that emitted out-of-bounds or overlapping placements the gate now correctly rejects. Engine.Tests: 70 passed, 0 failed, 0 skipped in Debug and Release. Windows-only OpenNest.Tests not run on Linux.
2026-09-18 05:56:37 -04:00
parent 75c8adc76c
commit 2b0b962c8f
12 changed files with 760 additions and 29 deletions
@@ -0,0 +1,114 @@
+using OpenNest.CNC;
+using OpenNest.Geometry;
+
+namespace OpenNest.Engine.Tests.Jobs;
+
+public class NestJobCancellationTests
+{
+    [Fact]
+    public void PreTrialCancellationSkipsCandidateWorkAndPreservesInput()
+    {
+        using var cancellation = new CancellationTokenSource();
+        cancellation.Cancel();
+        var nester = new CancellableNester(_ => new PlateCandidate(Array.Empty<NestJobPlacement>()));
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 3)), 1);
+        var sourceGeometry = part.Geometry.Motions.ToArray();
+        var stock = new NestPlateStock("stock", new Size(20, 30), 1);
+        var job = new NestJob(new[] { part }, new[] { stock });
+
+        Assert.Throws<OperationCanceledException>(() => new NestJobRunner(_ => nester).Solve(job, token: cancellation.Token));
+
+        Assert.Equal(0, nester.Calls);
+        Assert.Equal(sourceGeometry, job.Parts[0].Geometry.Motions);
+        Assert.Equal(1, job.Parts[0].Quantity);
+        Assert.Equal(1, job.Plates[0].Quantity);
+    }
+
+    [Fact]
+    public void CancellationDuringCandidateThrowsWithoutCommitOrInputMutation()
+    {
+        using var cancellation = new CancellationTokenSource();
+        var reports = new List<NestJobProgress>();
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 3)), 1);
+        var sourceGeometry = part.Geometry.Motions.ToArray();
+        var stock = new NestPlateStock("stock", new Size(20, 30), 1);
+        var job = new NestJob(new[] { part }, new[] { stock });
+        var nester = new CancellableNester((_, token) =>
+        {
+            cancellation.Cancel();
+            token.ThrowIfCancellationRequested();
+            return new PlateCandidate(Array.Empty<NestJobPlacement>());
+        });
+
+        Assert.Throws<OperationCanceledException>(() => new NestJobRunner(_ => nester)
+            .Solve(job, new InlineProgress(reports.Add), cancellation.Token));
+
+        Assert.Equal(1, nester.Calls);
+        Assert.DoesNotContain(reports, report => report.Stage == NestJobStage.PlateCommitted);
+        Assert.Equal(sourceGeometry, job.Parts[0].Geometry.Motions);
+        Assert.Equal(1, job.Parts[0].Quantity);
+        Assert.Equal(1, job.Plates[0].Quantity);
+    }
+
+    [Fact]
+    public void LegacyProgressIsWrappedWithCurrentCandidateContext()
+    {
+        var reports = new List<NestJobProgress>();
+        var part = new NestJobPart("part", PartGeometrySnapshot.FromProgram(TestDrawingFactory.Rectangle(4, 3)), 1);
+        var job = new NestJob(new[] { part }, new[] { new NestPlateStock("stock", new Size(20, 30), 1) });
+        var runner = new NestJobRunner(_ => new LegacyPlateNesterAdapter(plate => new ReportingEngine(plate)));
+
+        var result = runner.Solve(job, new InlineProgress(reports.Add));
+
+        Assert.Equal(NestJobStopReason.NoPlacementFound, result.StopReason);
+        var legacy = Assert.Single(reports.Where(report => report.LegacyProgress != null));
+        Assert.Equal(NestJobStage.EvaluatingCandidate, legacy.Stage);
+        Assert.Equal("stock", legacy.StockId);
+        Assert.Equal(0, legacy.PlateIndex);
+        Assert.Equal(0, legacy.CommittedPlates);
+        Assert.Equal(0, legacy.CommittedParts);
+        Assert.Equal("legacy detail", legacy.LegacyProgress!.Description);
+    }
+
+    private sealed class InlineProgress(Action<NestJobProgress> report) : IProgress<NestJobProgress>
+    {
+        public void Report(NestJobProgress value) => report(value);
+    }
+
+    private sealed class CancellableNester : IPlateNester
+    {
+        private readonly Func<PlatePlacementRequest, CancellationToken, PlateCandidate> place;
+
+        public CancellableNester(Func<PlatePlacementRequest, PlateCandidate> place)
+        {
+            this.place = (request, _) => place(request);
+        }
+
+        public CancellableNester(Func<PlatePlacementRequest, CancellationToken, PlateCandidate> place)
+        {
+            this.place = place;
+        }
+
+        public int Calls { get; private set; }
+
+        public PlateCandidate Place(PlatePlacementRequest request, IProgress<NestJobProgress>? progress = null,
+            CancellationToken token = default)
+        {
+            Calls++;
+            return place(request, token);
+        }
+    }
+
+    private sealed class ReportingEngine(Plate plate) : NestEngineBase(plate)
+    {
+        public override string Name => "reporting";
+        public override string Description => "reports progress";
+
+        public override List<Part> Nest(List<NestItem> items, IProgress<NestProgress>? progress,
+            CancellationToken token)
+        {
+            progress?.Report(new NestProgress { Description = "legacy detail" });
+            return new List<Part>();
+        }
+    }
+}