位置节点增加保存图像到本地的功能；支持输入图像
This commit is contained in:
zhengxuan.zhang
@@ -0,0 +1,143 @@
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
using System.Linq;
|
||||
using XplorePlane.Helpers;
|
||||
|
||||
namespace XplorePlane.Tests.Helpers
|
||||
{
|
||||
/// <summary>
|
||||
/// FsCheck property-based tests for FileNameSanitizer.
|
||||
/// Property 1: 文件名非法字符清理
|
||||
/// Validates: Requirements 1.2
|
||||
/// </summary>
|
||||
public class FileNameSanitizerPropertyTests
|
||||
{
|
||||
private static readonly char[] InvalidChars =
|
||||
new[] { '\\', '/', ':', '*', '?', '"', '<', '>', '|' };
|
||||
|
||||
/// <summary>
|
||||
/// 生成包含各种字符（含非法字符）的文件名字符串
|
||||
/// </summary>
|
||||
private static Arbitrary<string> FileNameArb()
|
||||
{
|
||||
// Mix of normal chars, unicode chars, and illegal file system chars
|
||||
var charGen = Gen.Frequency(
|
||||
(5, Gen.Choose(0x20, 0x7E).Select(i => (char)i)), // printable ASCII
|
||||
(2, Gen.Elements(InvalidChars)), // illegal chars
|
||||
(2, Gen.Choose(0x4E00, 0x9FFF).Select(i => (char)i)), // CJK characters
|
||||
(1, Gen.Elements('_', '-', '.', ' ')) // common filename chars
|
||||
);
|
||||
|
||||
var gen = from len in Gen.Choose(1, 50)
|
||||
from chars in Gen.ListOf<char>(charGen, len)
|
||||
select new string(chars.ToArray());
|
||||
|
||||
return gen.ToArbitrary();
|
||||
}
|
||||
|
||||
// ── Property 1: Output never contains any illegal characters ─────────
|
||||
|
||||
/// <summary>
|
||||
/// **Validates: Requirements 1.2**
|
||||
/// For any input string, the sanitized output must not contain any of the 9 illegal characters.
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property SanitizedOutput_NeverContainsIllegalCharacters()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
FileNameArb(),
|
||||
input =>
|
||||
{
|
||||
var result = FileNameSanitizer.Sanitize(input);
|
||||
return !result.Any(c => InvalidChars.Contains(c));
|
||||
});
|
||||
}
|
||||
|
||||
// ── Property 1 (cont): Legal characters are preserved unchanged ──────
|
||||
|
||||
/// <summary>
|
||||
/// **Validates: Requirements 1.2**
|
||||
/// For any input string, characters that are NOT illegal must appear unchanged
|
||||
/// at the same position in the output.
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property SanitizedOutput_PreservesLegalCharacters()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
FileNameArb(),
|
||||
input =>
|
||||
{
|
||||
var result = FileNameSanitizer.Sanitize(input);
|
||||
|
||||
for (int i = 0; i < input.Length; i++)
|
||||
{
|
||||
if (!InvalidChars.Contains(input[i]))
|
||||
{
|
||||
if (result[i] != input[i])
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
// ── Property 1 (cont): Output length equals input length ─────────────
|
||||
|
||||
/// <summary>
|
||||
/// **Validates: Requirements 1.2**
|
||||
/// For any non-null, non-empty input, the output length equals the input length.
|
||||
/// For null or empty input, the output is "_".
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property SanitizedOutput_LengthEqualsInputLength()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
FileNameArb(),
|
||||
input =>
|
||||
{
|
||||
var result = FileNameSanitizer.Sanitize(input);
|
||||
return result.Length == input.Length;
|
||||
});
|
||||
}
|
||||
|
||||
// ── Property 1 (cont): Sanitize is idempotent ────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// **Validates: Requirements 1.2**
|
||||
/// Sanitizing the output a second time produces the same result (idempotent).
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property SanitizedOutput_IsIdempotent()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
FileNameArb(),
|
||||
input =>
|
||||
{
|
||||
var once = FileNameSanitizer.Sanitize(input);
|
||||
var twice = FileNameSanitizer.Sanitize(once);
|
||||
return once == twice;
|
||||
});
|
||||
}
|
||||
|
||||
// ── Edge case: null and empty input ──────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// **Validates: Requirements 1.2**
|
||||
/// Null or empty input always returns "_".
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property NullOrEmptyInput_ReturnsUnderscore()
|
||||
{
|
||||
var gen = Gen.Elements<string>(null, "", null, "");
|
||||
|
||||
return Prop.ForAll(
|
||||
gen.ToArbitrary(),
|
||||
input =>
|
||||
{
|
||||
var result = FileNameSanitizer.Sanitize(input);
|
||||
return result == "_";
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,213 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
using XplorePlane.Helpers;
|
||||
|
||||
namespace XplorePlane.Tests.Helpers
|
||||
{
|
||||
/// <summary>
|
||||
/// FsCheck property-based tests for ManualImageValidator.
|
||||
/// Property 4: ManualImagePath 验证正确性
|
||||
/// **Validates: Requirements 2.1, 2.3**
|
||||
/// </summary>
|
||||
public class ManualImageValidatorPropertyTests
|
||||
{
|
||||
// ── Generators ──────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Generates null, empty, or whitespace-only strings.
|
||||
/// </summary>
|
||||
private static Gen<string> NullOrWhitespaceGen()
|
||||
{
|
||||
return Gen.OneOf(
|
||||
Gen.Constant((string)null),
|
||||
Gen.Constant(string.Empty),
|
||||
Gen.Constant(" "),
|
||||
Gen.Constant(" "),
|
||||
Gen.Constant("\t"),
|
||||
Gen.Constant("\t \n"),
|
||||
Gen.Constant(" \r\n "));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generates paths longer than 260 characters (non-whitespace).
|
||||
/// </summary>
|
||||
private static Gen<string> PathTooLongGen()
|
||||
{
|
||||
// Generate lengths from 261 to 500
|
||||
return Gen.Choose(261, 500).Select(len =>
|
||||
{
|
||||
// Use a valid-looking path prefix to ensure it's not whitespace
|
||||
var prefix = @"C:\Images\";
|
||||
var remaining = len - prefix.Length;
|
||||
if (remaining <= 0) remaining = 1;
|
||||
return prefix + new string('a', remaining);
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generates non-empty paths with length ≤ 260 that point to non-existent files.
|
||||
/// Uses random alphanumeric characters to ensure the file won't exist.
|
||||
/// </summary>
|
||||
private static Gen<string> NonExistentPathGen()
|
||||
{
|
||||
// Generate a path that is very unlikely to exist on disk
|
||||
var charGen = Gen.Elements(
|
||||
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
|
||||
'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3');
|
||||
|
||||
return from len in Gen.Choose(5, 50)
|
||||
from chars in Gen.ArrayOf(charGen).Resize(len)
|
||||
select @"C:\NonExistent_" + new string(chars) + ".bmp";
|
||||
}
|
||||
|
||||
// ── Property Tests ──────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Property 4.1: Null/whitespace/empty paths always return Empty.
|
||||
/// For any null, empty, or whitespace-only string, Validate SHALL return Empty.
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property NullOrWhitespacePaths_ReturnEmpty()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
NullOrWhitespaceGen().ToArbitrary(),
|
||||
path =>
|
||||
{
|
||||
var result = ManualImageValidator.Validate(path);
|
||||
return result == ManualImageValidationResult.Empty;
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Property 4.2: Paths longer than 260 characters always return PathTooLong.
|
||||
/// For any non-whitespace path with length > 260, Validate SHALL return PathTooLong.
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property PathsLongerThan260_ReturnPathTooLong()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
PathTooLongGen().ToArbitrary(),
|
||||
path =>
|
||||
{
|
||||
var result = ManualImageValidator.Validate(path);
|
||||
return result == ManualImageValidationResult.PathTooLong;
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Property 4.3: Non-existent file paths (non-empty, ≤260) return FileNotFound.
|
||||
/// For any non-whitespace path with length ≤ 260 that does not exist on disk,
|
||||
/// Validate SHALL return FileNotFound.
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property NonExistentPaths_ReturnFileNotFound()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
NonExistentPathGen().ToArbitrary(),
|
||||
path =>
|
||||
{
|
||||
var result = ManualImageValidator.Validate(path);
|
||||
return result == ManualImageValidationResult.FileNotFound;
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Property 4.4: The result is always one of the defined enum values (exhaustive classification).
|
||||
/// For any arbitrary string, Validate SHALL return a value within the defined enum range.
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property Result_IsAlwaysDefinedEnumValue()
|
||||
{
|
||||
// Generate arbitrary strings including nulls, empty, whitespace, and random paths
|
||||
var charGen = Gen.Frequency(
|
||||
(5, Gen.Choose(0x20, 0x7E).Select(i => (char)i)), // printable ASCII
|
||||
(2, Gen.Choose(0x4E00, 0x9FFF).Select(i => (char)i)), // CJK characters
|
||||
(1, Gen.Elements('\\', '/', ':', '*', '?', '"', '<', '>', '|')),
|
||||
(1, Gen.Elements(' ', '\t', '\n', '\r'))
|
||||
);
|
||||
|
||||
var randomStringGen = from len in Gen.Choose(0, 300)
|
||||
from chars in Gen.ArrayOf(charGen).Resize(len)
|
||||
select new string(chars);
|
||||
|
||||
var anyStringGen = Gen.OneOf(
|
||||
Gen.Constant((string)null),
|
||||
Gen.Constant(string.Empty),
|
||||
Gen.Constant(" "),
|
||||
randomStringGen);
|
||||
|
||||
return Prop.ForAll(
|
||||
anyStringGen.ToArbitrary(),
|
||||
path =>
|
||||
{
|
||||
var result = ManualImageValidator.Validate(path);
|
||||
return Enum.IsDefined(typeof(ManualImageValidationResult), result);
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Property 4.5: Existing files with supported extensions return Valid.
|
||||
/// Creates temporary files with supported extensions and verifies Validate returns Valid.
|
||||
/// </summary>
|
||||
[Property(MaxTest = 20)]
|
||||
public Property ExistingFilesWithSupportedExtension_ReturnValid()
|
||||
{
|
||||
var supportedExtGen = Gen.Elements(".bmp", ".png", ".tiff", ".tif");
|
||||
|
||||
return Prop.ForAll(
|
||||
supportedExtGen.ToArbitrary(),
|
||||
ext =>
|
||||
{
|
||||
var tempDir = Path.Combine(Path.GetTempPath(), "ManualImageValidatorTests");
|
||||
Directory.CreateDirectory(tempDir);
|
||||
var tempFile = Path.Combine(tempDir, $"test_{Guid.NewGuid():N}{ext}");
|
||||
|
||||
try
|
||||
{
|
||||
File.WriteAllBytes(tempFile, new byte[] { 0x00 });
|
||||
var result = ManualImageValidator.Validate(tempFile);
|
||||
return result == ManualImageValidationResult.Valid;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (File.Exists(tempFile))
|
||||
File.Delete(tempFile);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Property 4.6: Existing files with unsupported extensions return UnsupportedFormat.
|
||||
/// Creates temporary files with unsupported extensions and verifies Validate returns UnsupportedFormat.
|
||||
/// </summary>
|
||||
[Property(MaxTest = 20)]
|
||||
public Property ExistingFilesWithUnsupportedExtension_ReturnUnsupportedFormat()
|
||||
{
|
||||
var unsupportedExtGen = Gen.Elements(".jpg", ".jpeg", ".gif", ".svg", ".webp", ".txt", ".dat");
|
||||
|
||||
return Prop.ForAll(
|
||||
unsupportedExtGen.ToArbitrary(),
|
||||
ext =>
|
||||
{
|
||||
var tempDir = Path.Combine(Path.GetTempPath(), "ManualImageValidatorTests");
|
||||
Directory.CreateDirectory(tempDir);
|
||||
var tempFile = Path.Combine(tempDir, $"test_{Guid.NewGuid():N}{ext}");
|
||||
|
||||
try
|
||||
{
|
||||
File.WriteAllBytes(tempFile, new byte[] { 0x00 });
|
||||
var result = ManualImageValidator.Validate(tempFile);
|
||||
return result == ManualImageValidationResult.UnsupportedFormat;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (File.Exists(tempFile))
|
||||
File.Delete(tempFile);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text.Json;
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
using XplorePlane.Models;
|
||||
|
||||
namespace XplorePlane.Tests.Models
|
||||
{
|
||||
/// <summary>
|
||||
/// FsCheck property-based tests for BatchCaptureResult JSON serialization round-trip.
|
||||
/// Property 10: 摘要 JSON 序列化往返
|
||||
/// </summary>
|
||||
public class SummarySerializationPropertyTests
|
||||
{
|
||||
// ── Generators ───────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Generates a non-null string (FsCheck may generate nulls by default).
|
||||
/// </summary>
|
||||
private static Gen<string> NonNullStringGen =>
|
||||
ArbMap.Default.GeneratorFor<NonEmptyString>()
|
||||
.Select(s => s.Get)
|
||||
.Or(Gen.Constant(string.Empty));
|
||||
|
||||
/// <summary>
|
||||
/// Generates a nullable string (either null or a non-empty string).
|
||||
/// </summary>
|
||||
private static Gen<string> NullableStringGen =>
|
||||
Gen.OneOf(
|
||||
Gen.Constant<string>(null),
|
||||
ArbMap.Default.GeneratorFor<NonEmptyString>().Select(s => s.Get));
|
||||
|
||||
/// <summary>
|
||||
/// Generates a random PositionResult with valid field values.
|
||||
/// </summary>
|
||||
private static Gen<PositionResult> PositionResultGen =>
|
||||
from nodeName in NonNullStringGen
|
||||
from nodeIndex in Gen.Choose(0, 1000)
|
||||
from status in Gen.Elements("Success", "Failed")
|
||||
from errorMessage in NullableStringGen
|
||||
from imagePath in NullableStringGen
|
||||
select new PositionResult
|
||||
{
|
||||
NodeName = nodeName,
|
||||
NodeIndex = nodeIndex,
|
||||
Status = status,
|
||||
ErrorMessage = errorMessage,
|
||||
ImagePath = imagePath
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Generates a random BatchCaptureResult with valid field values.
|
||||
/// </summary>
|
||||
private static Gen<BatchCaptureResult> BatchCaptureResultGen =>
|
||||
from programName in NonNullStringGen
|
||||
from startTime in NonNullStringGen
|
||||
from durationSeconds in Gen.Choose(0, 100000).Select(i => i / 100.0)
|
||||
from totalPositions in Gen.Choose(0, 50)
|
||||
from succeededPositions in Gen.Choose(0, 50)
|
||||
from failedPositions in Gen.Choose(0, 50)
|
||||
from savedImageCount in Gen.Choose(0, 100)
|
||||
from status in Gen.Elements("Completed", "Cancelled")
|
||||
from completedBeforeCancel in Gen.OneOf(
|
||||
Gen.Constant<int?>(null),
|
||||
Gen.Choose(0, 50).Select(i => (int?)i))
|
||||
from notExecutedAfterCancel in Gen.OneOf(
|
||||
Gen.Constant<int?>(null),
|
||||
Gen.Choose(0, 50).Select(i => (int?)i))
|
||||
from positionCount in Gen.Choose(0, 5)
|
||||
from positions in Gen.ListOf<PositionResult>(PositionResultGen, positionCount)
|
||||
select new BatchCaptureResult
|
||||
{
|
||||
ProgramName = programName,
|
||||
StartTime = startTime,
|
||||
DurationSeconds = durationSeconds,
|
||||
TotalPositions = totalPositions,
|
||||
SucceededPositions = succeededPositions,
|
||||
FailedPositions = failedPositions,
|
||||
SavedImageCount = savedImageCount,
|
||||
Status = status,
|
||||
CompletedBeforeCancel = completedBeforeCancel,
|
||||
NotExecutedAfterCancel = notExecutedAfterCancel,
|
||||
Positions = positions.ToList()
|
||||
};
|
||||
|
||||
// ── Property 10 ─────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// **Validates: Requirements 4.3**
|
||||
///
|
||||
/// For any valid BatchCaptureResult object, serializing to JSON and
|
||||
/// deserializing back produces an object with identical field values.
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property BatchCaptureResult_JsonRoundTrip_PreservesAllFields()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
BatchCaptureResultGen.ToArbitrary(),
|
||||
original =>
|
||||
{
|
||||
// Serialize to JSON
|
||||
var json = JsonSerializer.Serialize(original);
|
||||
|
||||
// Deserialize back
|
||||
var deserialized = JsonSerializer.Deserialize<BatchCaptureResult>(json);
|
||||
|
||||
// Verify all scalar properties
|
||||
bool scalarFieldsMatch =
|
||||
deserialized.ProgramName == original.ProgramName &&
|
||||
deserialized.StartTime == original.StartTime &&
|
||||
deserialized.DurationSeconds == original.DurationSeconds &&
|
||||
deserialized.TotalPositions == original.TotalPositions &&
|
||||
deserialized.SucceededPositions == original.SucceededPositions &&
|
||||
deserialized.FailedPositions == original.FailedPositions &&
|
||||
deserialized.SavedImageCount == original.SavedImageCount &&
|
||||
deserialized.Status == original.Status;
|
||||
|
||||
// Verify nullable int properties
|
||||
bool nullableFieldsMatch =
|
||||
deserialized.CompletedBeforeCancel == original.CompletedBeforeCancel &&
|
||||
deserialized.NotExecutedAfterCancel == original.NotExecutedAfterCancel;
|
||||
|
||||
// Verify list property count
|
||||
bool listCountMatch =
|
||||
deserialized.Positions.Count == original.Positions.Count;
|
||||
|
||||
// Verify each position in the list
|
||||
bool positionsMatch = true;
|
||||
for (int i = 0; i < original.Positions.Count; i++)
|
||||
{
|
||||
var orig = original.Positions[i];
|
||||
var deser = deserialized.Positions[i];
|
||||
if (deser.NodeName != orig.NodeName ||
|
||||
deser.NodeIndex != orig.NodeIndex ||
|
||||
deser.Status != orig.Status ||
|
||||
deser.ErrorMessage != orig.ErrorMessage ||
|
||||
deser.ImagePath != orig.ImagePath)
|
||||
{
|
||||
positionsMatch = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return scalarFieldsMatch && nullableFieldsMatch &&
|
||||
listCountMatch && positionsMatch;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,225 @@
|
||||
#pragma warning disable xUnit1031 // FsCheck property tests require synchronous execution via GetAwaiter().GetResult()
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using System.Windows.Media;
|
||||
using System.Windows.Media.Imaging;
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
using Moq;
|
||||
using Prism.Events;
|
||||
using XP.Common.Logging.Interfaces;
|
||||
using XplorePlane.Events;
|
||||
using XplorePlane.Models;
|
||||
using XplorePlane.Services;
|
||||
using XplorePlane.Services.AppState;
|
||||
using XplorePlane.Services.Cnc;
|
||||
using XplorePlane.Services.InspectionResults;
|
||||
using XplorePlane.Services.MainViewport;
|
||||
using Xunit;
|
||||
|
||||
namespace XplorePlane.Tests.Services
|
||||
{
|
||||
/// <summary>
|
||||
/// Property 8: 取消令牌中止后续位置执行
|
||||
/// **Validates: Requirements 3.5**
|
||||
///
|
||||
/// For any CNC program being executed, when a CancellationToken is triggered,
|
||||
/// no SavePositionNode with Index greater than the currently executing node SHALL be processed.
|
||||
/// </summary>
|
||||
public class CancellationPropertyTests
|
||||
{
|
||||
/// <summary>
|
||||
/// Creates a CncExecutionService with all dependencies mocked.
|
||||
/// The SaveImageAsync mock triggers cancellation after K positions have been processed.
|
||||
/// </summary>
|
||||
private static (CncExecutionService Service, Mock<IImagePersistenceService> ImagePersistence, List<string> ExecutedNodeNames)
|
||||
CreateServiceWithCancellation(CancellationTokenSource cts, int cancelAfterK)
|
||||
{
|
||||
var mockStore = new Mock<IInspectionResultStore>();
|
||||
var mockLogger = new Mock<ILoggerService>();
|
||||
var mockMainViewportService = new Mock<IMainViewportService>();
|
||||
var mockAppStateService = new Mock<IAppStateService>();
|
||||
var mockPipelineExecutionService = new Mock<IPipelineExecutionService>();
|
||||
var mockImageProcessingService = new Mock<IImageProcessingService>();
|
||||
var mockEventAggregator = new Mock<IEventAggregator>();
|
||||
var mockImagePersistenceService = new Mock<IImagePersistenceService>();
|
||||
|
||||
// Logger setup
|
||||
mockLogger.Setup(l => l.ForModule<CncExecutionService>()).Returns(mockLogger.Object);
|
||||
|
||||
// EventAggregator setup - prevent NRE on constructor subscription
|
||||
mockEventAggregator
|
||||
.Setup(ea => ea.GetEvent<DetectorDisconnectedEvent>())
|
||||
.Returns(new DetectorDisconnectedEvent());
|
||||
|
||||
// InspectionResultStore setup
|
||||
mockStore.Setup(s => s.BeginRunAsync(
|
||||
It.IsAny<InspectionRunRecord>(),
|
||||
It.IsAny<InspectionAssetWriteRequest>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.AppendNodeResultAsync(
|
||||
It.IsAny<InspectionNodeResult>(),
|
||||
It.IsAny<IEnumerable<InspectionMetricResult>>(),
|
||||
It.IsAny<PipelineExecutionSnapshot>(),
|
||||
It.IsAny<IEnumerable<InspectionAssetWriteRequest>>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.CompleteRunAsync(
|
||||
It.IsAny<Guid>(),
|
||||
It.IsAny<bool?>(),
|
||||
It.IsAny<DateTime?>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
// Provide a valid BitmapSource from the viewport so image acquisition succeeds
|
||||
var dummyBitmap = BitmapSource.Create(
|
||||
1, 1, 96, 96, PixelFormats.Gray8, null, new byte[] { 128 }, 1);
|
||||
dummyBitmap.Freeze();
|
||||
mockMainViewportService
|
||||
.Setup(m => m.LatestManualImage)
|
||||
.Returns(dummyBitmap);
|
||||
|
||||
// Track which nodes have their images saved (i.e., which positions were executed)
|
||||
var executedNodeNames = new List<string>();
|
||||
int saveCallCount = 0;
|
||||
|
||||
// ImagePersistenceService - cancel after K positions have been saved
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.SaveImageAsync(
|
||||
It.IsAny<byte[]>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.Returns<byte[], string, string, CancellationToken>((_, nodeName, __, ___) =>
|
||||
{
|
||||
executedNodeNames.Add(nodeName);
|
||||
int currentCount = Interlocked.Increment(ref saveCallCount);
|
||||
// Cancel after K positions have been processed
|
||||
if (currentCount >= cancelAfterK)
|
||||
{
|
||||
cts.Cancel();
|
||||
}
|
||||
return Task.FromResult(new ImageSaveResult(true, $"C:\\test\\{nodeName}.bmp", 1024));
|
||||
});
|
||||
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.WriteSummaryAsync(
|
||||
It.IsAny<BatchCaptureResult>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(true);
|
||||
|
||||
var service = new CncExecutionService(
|
||||
mockStore.Object,
|
||||
mockLogger.Object,
|
||||
mockMainViewportService.Object,
|
||||
mockAppStateService.Object,
|
||||
mockPipelineExecutionService.Object,
|
||||
mockImageProcessingService.Object,
|
||||
mockEventAggregator.Object,
|
||||
mockImagePersistenceService.Object);
|
||||
|
||||
return (service, mockImagePersistenceService, executedNodeNames);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// FsCheck generator for a cancellation test scenario:
|
||||
/// - N SavePositionNodes (N between 2 and 10)
|
||||
/// - A cancellation point K (1 <= K < N), meaning cancel after K positions are processed
|
||||
/// </summary>
|
||||
private static Arbitrary<(List<SavePositionNode> Nodes, int CancelAfterK)> CancellationScenarioArb()
|
||||
{
|
||||
var gen =
|
||||
from count in Gen.Choose(2, 10)
|
||||
from cancelAfterK in Gen.Choose(1, count - 1)
|
||||
from indices in Gen.Shuffle(Enumerable.Range(0, count).ToArray())
|
||||
.Select(arr => arr.ToList())
|
||||
select (
|
||||
Nodes: indices.Select(idx =>
|
||||
new SavePositionNode(
|
||||
Guid.NewGuid(),
|
||||
idx,
|
||||
$"Position_{idx}",
|
||||
MotionState.Default,
|
||||
SaveImage: true,
|
||||
ManualImagePath: ""))
|
||||
.ToList(),
|
||||
CancelAfterK: cancelAfterK
|
||||
);
|
||||
|
||||
return gen.ToArbitrary();
|
||||
}
|
||||
|
||||
// Feature: cnc-multi-position-image-capture, Property 8: 取消令牌中止后续位置执行
|
||||
// **Validates: Requirements 3.5**
|
||||
[Property(MaxTest = 100)]
|
||||
public Property Cancellation_StopsSubsequentPositionExecution()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
CancellationScenarioArb(),
|
||||
scenario =>
|
||||
{
|
||||
var (nodes, cancelAfterK) = scenario;
|
||||
|
||||
using var cts = new CancellationTokenSource();
|
||||
var (service, _, executedNodeNames) = CreateServiceWithCancellation(cts, cancelAfterK);
|
||||
|
||||
// Build a CncProgram containing the SavePositionNodes
|
||||
// (in their original random order - the service sorts by Index)
|
||||
var program = new CncProgram(
|
||||
Guid.NewGuid(),
|
||||
"TestProgram",
|
||||
DateTime.UtcNow,
|
||||
DateTime.UtcNow,
|
||||
nodes.Cast<CncNode>().ToList().AsReadOnly());
|
||||
|
||||
// Track progress reports to verify which positions were executed
|
||||
var executedPositionIndices = new List<int>();
|
||||
var progress = new SynchronousProgress<CncNodeExecutionProgress>(p =>
|
||||
{
|
||||
if (p.State == NodeExecutionState.Running && p.PositionIndex.HasValue)
|
||||
{
|
||||
executedPositionIndices.Add(p.PositionIndex.Value);
|
||||
}
|
||||
});
|
||||
|
||||
service.ExecuteAsync(program, progress, cts.Token)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
// The expected sorted order of nodes by Index
|
||||
var sortedNodes = nodes.OrderBy(n => n.Index).ToList();
|
||||
|
||||
// Verify: No more than cancelAfterK positions should have been executed.
|
||||
// The cancellation is triggered after K SaveImageAsync calls complete,
|
||||
// so at most K positions should have their images saved.
|
||||
// The (K+1)th position might start (Running reported) but its SaveImageAsync
|
||||
// should not be called because cancellation is checked at loop start.
|
||||
bool noExcessiveSaves = executedNodeNames.Count <= cancelAfterK;
|
||||
|
||||
// Verify: Positions after the cancellation point should NOT be executed.
|
||||
// The service checks cancellation at the start of each loop iteration,
|
||||
// so after K positions complete and cancellation is triggered,
|
||||
// subsequent positions should not receive Running state.
|
||||
bool noSubsequentExecution = executedPositionIndices.Count <= cancelAfterK;
|
||||
|
||||
// Verify: The executed positions should be the first K positions in sorted order
|
||||
bool correctPositionsExecuted = true;
|
||||
for (int i = 0; i < executedNodeNames.Count && i < cancelAfterK; i++)
|
||||
{
|
||||
if (executedNodeNames[i] != sortedNodes[i].Name)
|
||||
{
|
||||
correctPositionsExecuted = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return noExcessiveSaves && noSubsequentExecution && correctPositionsExecuted;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,220 @@
|
||||
#pragma warning disable xUnit1031 // FsCheck property tests require synchronous execution via GetAwaiter().GetResult()
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using System.Windows.Media;
|
||||
using System.Windows.Media.Imaging;
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
using Moq;
|
||||
using Prism.Events;
|
||||
using XP.Common.Logging.Interfaces;
|
||||
using XplorePlane.Events;
|
||||
using XplorePlane.Models;
|
||||
using XplorePlane.Services;
|
||||
using XplorePlane.Services.AppState;
|
||||
using XplorePlane.Services.Cnc;
|
||||
using XplorePlane.Services.InspectionResults;
|
||||
using XplorePlane.Services.MainViewport;
|
||||
using Xunit;
|
||||
|
||||
namespace XplorePlane.Tests.Services
|
||||
{
|
||||
/// <summary>
|
||||
/// FsCheck property-based tests for cancellation summary correctness.
|
||||
/// Property 11: 取消时摘要包含正确的完成/未执行计数
|
||||
/// **Validates: Requirements 4.5**
|
||||
/// </summary>
|
||||
public class CancellationSummaryPropertyTests
|
||||
{
|
||||
// ── Helper: Create a frozen BitmapSource for mocking ──────────────
|
||||
|
||||
private static BitmapSource CreateFrozenBitmap()
|
||||
{
|
||||
var bitmap = BitmapSource.Create(1, 1, 96, 96, PixelFormats.Bgra32, null, new byte[4], 4);
|
||||
bitmap.Freeze();
|
||||
return bitmap;
|
||||
}
|
||||
|
||||
// ── Helper: Create CncExecutionService with mocks ────────────────
|
||||
|
||||
private static (CncExecutionService Service, Mock<IImagePersistenceService> ImagePersistence)
|
||||
CreateServiceWithImagePersistence(BitmapSource sourceImage)
|
||||
{
|
||||
var mockStore = new Mock<IInspectionResultStore>();
|
||||
var mockLogger = new Mock<ILoggerService>();
|
||||
var mockMainViewportService = new Mock<IMainViewportService>();
|
||||
var mockAppStateService = new Mock<IAppStateService>();
|
||||
var mockPipelineExecutionService = new Mock<IPipelineExecutionService>();
|
||||
var mockImageProcessingService = new Mock<IImageProcessingService>();
|
||||
var mockEventAggregator = new Mock<IEventAggregator>();
|
||||
var mockImagePersistenceService = new Mock<IImagePersistenceService>();
|
||||
|
||||
mockLogger.Setup(l => l.ForModule<CncExecutionService>()).Returns(mockLogger.Object);
|
||||
|
||||
mockEventAggregator
|
||||
.Setup(ea => ea.GetEvent<DetectorDisconnectedEvent>())
|
||||
.Returns(new DetectorDisconnectedEvent());
|
||||
|
||||
mockStore.Setup(s => s.BeginRunAsync(
|
||||
It.IsAny<InspectionRunRecord>(),
|
||||
It.IsAny<InspectionAssetWriteRequest>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.AppendNodeResultAsync(
|
||||
It.IsAny<InspectionNodeResult>(),
|
||||
It.IsAny<IEnumerable<InspectionMetricResult>>(),
|
||||
It.IsAny<PipelineExecutionSnapshot>(),
|
||||
It.IsAny<IEnumerable<InspectionAssetWriteRequest>>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.CompleteRunAsync(
|
||||
It.IsAny<Guid>(),
|
||||
It.IsAny<bool?>(),
|
||||
It.IsAny<DateTime?>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
// Provide a source image so positions can succeed
|
||||
mockMainViewportService.SetupGet(m => m.LatestManualImage).Returns(sourceImage);
|
||||
mockMainViewportService.SetupGet(m => m.CurrentDisplayImage).Returns(sourceImage);
|
||||
|
||||
// SaveImageAsync returns success
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.SaveImageAsync(
|
||||
It.IsAny<byte[]>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(new ImageSaveResult(true, "C:\\test\\image.bmp", 1024));
|
||||
|
||||
// WriteSummaryAsync returns success
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.WriteSummaryAsync(
|
||||
It.IsAny<BatchCaptureResult>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(true);
|
||||
|
||||
var service = new CncExecutionService(
|
||||
mockStore.Object,
|
||||
mockLogger.Object,
|
||||
mockMainViewportService.Object,
|
||||
mockAppStateService.Object,
|
||||
mockPipelineExecutionService.Object,
|
||||
mockImageProcessingService.Object,
|
||||
mockEventAggregator.Object,
|
||||
mockImagePersistenceService.Object);
|
||||
|
||||
return (service, mockImagePersistenceService);
|
||||
}
|
||||
|
||||
// ── Generator: N SavePositionNodes with cancellation point K ─────
|
||||
|
||||
private static Gen<(List<SavePositionNode> Nodes, int CancelAfterK)> SavePositionNodesWithCancelGen =>
|
||||
from n in Gen.Choose(2, 10)
|
||||
from k in Gen.Choose(0, n - 1)
|
||||
from nodes in GenSavePositionNodes(n)
|
||||
select (nodes, k);
|
||||
|
||||
private static Gen<List<SavePositionNode>> GenSavePositionNodes(int count)
|
||||
{
|
||||
Gen<List<SavePositionNode>> acc = Gen.Constant(new List<SavePositionNode>());
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
var idx = i;
|
||||
acc = from list in acc
|
||||
let node = new SavePositionNode(
|
||||
Guid.NewGuid(), idx, $"Position_{idx}",
|
||||
MotionState.Default, SaveImage: true)
|
||||
select new List<SavePositionNode>(list) { node };
|
||||
}
|
||||
return acc;
|
||||
}
|
||||
|
||||
// ── Property 11: 取消时摘要包含正确的完成/未执行计数 ─────────────
|
||||
|
||||
/// <summary>
|
||||
/// **Validates: Requirements 4.5**
|
||||
///
|
||||
/// For any CNC program execution that is cancelled at position K (0-based)
|
||||
/// out of N total positions, the summary SHALL have Status="Cancelled",
|
||||
/// CompletedBeforeCancel=K, and NotExecutedAfterCancel=N-K,
|
||||
/// where CompletedBeforeCancel + NotExecutedAfterCancel == TotalPositions.
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property CancellationSummary_HasCorrectCompletedAndNotExecutedCounts()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
SavePositionNodesWithCancelGen.ToArbitrary(),
|
||||
tuple =>
|
||||
{
|
||||
var (nodes, cancelAfterK) = tuple;
|
||||
int totalPositions = nodes.Count;
|
||||
|
||||
var sourceImage = CreateFrozenBitmap();
|
||||
var (service, mockImagePersistence) = CreateServiceWithImagePersistence(sourceImage);
|
||||
|
||||
// Create a CTS that we will cancel after K positions are processed
|
||||
using var cts = new CancellationTokenSource();
|
||||
int processedCount = 0;
|
||||
|
||||
// Use progress callback to trigger cancellation after K positions complete
|
||||
var progress = new SynchronousProgress<CncNodeExecutionProgress>(p =>
|
||||
{
|
||||
// Count positions that have completed (Succeeded or Failed state)
|
||||
if (p.State == NodeExecutionState.Succeeded || p.State == NodeExecutionState.Failed)
|
||||
{
|
||||
if (p.PositionIndex.HasValue)
|
||||
{
|
||||
processedCount++;
|
||||
if (processedCount >= cancelAfterK)
|
||||
{
|
||||
cts.Cancel();
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
var program = new CncProgram(
|
||||
Guid.NewGuid(), "TestProgram",
|
||||
DateTime.UtcNow, DateTime.UtcNow,
|
||||
nodes.Cast<CncNode>().ToList().AsReadOnly());
|
||||
|
||||
service.ExecuteAsync(program, progress, cts.Token)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
// Capture the BatchCaptureResult passed to WriteSummaryAsync
|
||||
BatchCaptureResult capturedResult = null;
|
||||
mockImagePersistence.Verify(
|
||||
s => s.WriteSummaryAsync(
|
||||
It.IsAny<BatchCaptureResult>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()),
|
||||
Times.Once);
|
||||
|
||||
// Extract the captured argument
|
||||
var invocation = mockImagePersistence.Invocations
|
||||
.First(i => i.Method.Name == nameof(IImagePersistenceService.WriteSummaryAsync));
|
||||
capturedResult = (BatchCaptureResult)invocation.Arguments[0];
|
||||
|
||||
// Verify the cancellation summary properties
|
||||
bool statusIsCancelled = capturedResult.Status == "Cancelled";
|
||||
bool completedBeforeCancelIsK = capturedResult.CompletedBeforeCancel == cancelAfterK;
|
||||
bool notExecutedIsCorrect = capturedResult.NotExecutedAfterCancel == totalPositions - cancelAfterK;
|
||||
bool sumEqualsTotal =
|
||||
capturedResult.CompletedBeforeCancel + capturedResult.NotExecutedAfterCancel == totalPositions;
|
||||
bool totalPositionsCorrect = capturedResult.TotalPositions == totalPositions;
|
||||
|
||||
return statusIsCancelled
|
||||
&& completedBeforeCancelIsK
|
||||
&& notExecutedIsCorrect
|
||||
&& sumEqualsTotal
|
||||
&& totalPositionsCorrect;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -190,6 +190,7 @@ internal sealed class SynchronousProgress<T> : IProgress<T>
|
||||
var mockPipelineExecutionService = new Mock<IPipelineExecutionService>();
|
||||
var mockImageProcessingService = new Mock<IImageProcessingService>();
|
||||
var mockEventAggregator = new Mock<IEventAggregator>();
|
||||
var mockImagePersistenceService = new Mock<IImagePersistenceService>();
|
||||
mockLogger.Setup(l => l.ForModule<CncExecutionService>()).Returns(mockLogger.Object);
|
||||
|
||||
// Set up GetEvent<DetectorDisconnectedEvent>() so the constructor subscription doesn't throw
|
||||
@@ -222,7 +223,8 @@ internal sealed class SynchronousProgress<T> : IProgress<T>
|
||||
mockAppStateService.Object,
|
||||
mockPipelineExecutionService.Object,
|
||||
mockImageProcessingService.Object,
|
||||
mockEventAggregator.Object);
|
||||
mockEventAggregator.Object,
|
||||
mockImagePersistenceService.Object);
|
||||
return (service, mockStore, mockLogger, mockMainViewportService, mockAppStateService);
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,204 @@
|
||||
#pragma warning disable xUnit1031 // FsCheck property tests require synchronous execution via GetAwaiter().GetResult()
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using System.Windows.Media;
|
||||
using System.Windows.Media.Imaging;
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
using Moq;
|
||||
using Prism.Events;
|
||||
using XP.Common.Logging.Interfaces;
|
||||
using XplorePlane.Events;
|
||||
using XplorePlane.Models;
|
||||
using XplorePlane.Services;
|
||||
using XplorePlane.Services.AppState;
|
||||
using XplorePlane.Services.Cnc;
|
||||
using XplorePlane.Services.InspectionResults;
|
||||
using XplorePlane.Services.MainViewport;
|
||||
using Xunit;
|
||||
|
||||
namespace XplorePlane.Tests.Services
|
||||
{
|
||||
/// <summary>
|
||||
/// Property 5: 多位置按 Index 升序执行
|
||||
/// **Validates: Requirements 3.1**
|
||||
///
|
||||
/// For any CNC program containing multiple SavePositionNodes with arbitrary Index values,
|
||||
/// the CNC_Execution_Service SHALL process them in strictly ascending Index order,
|
||||
/// and progress reports SHALL reflect this ordering.
|
||||
/// </summary>
|
||||
public class ExecutionOrderPropertyTests
|
||||
{
|
||||
/// <summary>
|
||||
/// Creates a CncExecutionService with all dependencies mocked.
|
||||
/// The MainViewportService returns a valid BitmapSource so execution proceeds.
|
||||
/// </summary>
|
||||
private static (CncExecutionService Service, Mock<IMainViewportService> MainViewport) CreateServiceWithImage()
|
||||
{
|
||||
var mockStore = new Mock<IInspectionResultStore>();
|
||||
var mockLogger = new Mock<ILoggerService>();
|
||||
var mockMainViewportService = new Mock<IMainViewportService>();
|
||||
var mockAppStateService = new Mock<IAppStateService>();
|
||||
var mockPipelineExecutionService = new Mock<IPipelineExecutionService>();
|
||||
var mockImageProcessingService = new Mock<IImageProcessingService>();
|
||||
var mockEventAggregator = new Mock<IEventAggregator>();
|
||||
var mockImagePersistenceService = new Mock<IImagePersistenceService>();
|
||||
|
||||
// Logger setup
|
||||
mockLogger.Setup(l => l.ForModule<CncExecutionService>()).Returns(mockLogger.Object);
|
||||
|
||||
// EventAggregator setup - prevent NRE on constructor subscription
|
||||
mockEventAggregator
|
||||
.Setup(ea => ea.GetEvent<DetectorDisconnectedEvent>())
|
||||
.Returns(new DetectorDisconnectedEvent());
|
||||
|
||||
// InspectionResultStore setup
|
||||
mockStore.Setup(s => s.BeginRunAsync(
|
||||
It.IsAny<InspectionRunRecord>(),
|
||||
It.IsAny<InspectionAssetWriteRequest>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.AppendNodeResultAsync(
|
||||
It.IsAny<InspectionNodeResult>(),
|
||||
It.IsAny<IEnumerable<InspectionMetricResult>>(),
|
||||
It.IsAny<PipelineExecutionSnapshot>(),
|
||||
It.IsAny<IEnumerable<InspectionAssetWriteRequest>>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.CompleteRunAsync(
|
||||
It.IsAny<Guid>(),
|
||||
It.IsAny<bool?>(),
|
||||
It.IsAny<DateTime?>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
// Provide a valid BitmapSource from the viewport so image acquisition succeeds
|
||||
var dummyBitmap = BitmapSource.Create(
|
||||
1, 1, 96, 96, PixelFormats.Gray8, null, new byte[] { 128 }, 1);
|
||||
dummyBitmap.Freeze();
|
||||
mockMainViewportService
|
||||
.Setup(m => m.LatestManualImage)
|
||||
.Returns(dummyBitmap);
|
||||
|
||||
// ImagePersistenceService - return success for SaveImageAsync
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.SaveImageAsync(
|
||||
It.IsAny<byte[]>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(new ImageSaveResult(true, "C:\\test\\image.bmp", 1024));
|
||||
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.WriteSummaryAsync(
|
||||
It.IsAny<BatchCaptureResult>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(true);
|
||||
|
||||
var service = new CncExecutionService(
|
||||
mockStore.Object,
|
||||
mockLogger.Object,
|
||||
mockMainViewportService.Object,
|
||||
mockAppStateService.Object,
|
||||
mockPipelineExecutionService.Object,
|
||||
mockImageProcessingService.Object,
|
||||
mockEventAggregator.Object,
|
||||
mockImagePersistenceService.Object);
|
||||
|
||||
return (service, mockMainViewportService);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// FsCheck generator for a list of SavePositionNodes with random, unique Index values.
|
||||
/// Generates 2-10 nodes with shuffled indices to ensure non-sequential ordering in the input.
|
||||
/// </summary>
|
||||
private static Arbitrary<List<SavePositionNode>> SavePositionNodesArb()
|
||||
{
|
||||
var gen =
|
||||
from count in Gen.Choose(2, 10)
|
||||
from indices in Gen.Shuffle(Enumerable.Range(0, 100).ToArray())
|
||||
.Select(arr => arr.Take(count).ToList())
|
||||
select indices.Select(idx =>
|
||||
new SavePositionNode(
|
||||
Guid.NewGuid(),
|
||||
idx,
|
||||
$"Position_{idx}",
|
||||
MotionState.Default,
|
||||
SaveImage: false,
|
||||
ManualImagePath: ""))
|
||||
.ToList();
|
||||
|
||||
return gen.ToArbitrary();
|
||||
}
|
||||
|
||||
// Feature: cnc-multi-position-image-capture, Property 5: 多位置按 Index 升序执行
|
||||
// **Validates: Requirements 3.1**
|
||||
[Property(MaxTest = 100)]
|
||||
public Property MultiPosition_ExecutedInStrictlyAscendingIndexOrder()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
SavePositionNodesArb(),
|
||||
savePositionNodes =>
|
||||
{
|
||||
var (service, _) = CreateServiceWithImage();
|
||||
|
||||
// Build a CncProgram containing only the generated SavePositionNodes
|
||||
// (in their original random order - the service should sort by Index)
|
||||
var program = new CncProgram(
|
||||
Guid.NewGuid(),
|
||||
"TestProgram",
|
||||
DateTime.UtcNow,
|
||||
DateTime.UtcNow,
|
||||
savePositionNodes.Cast<CncNode>().ToList().AsReadOnly());
|
||||
|
||||
// Capture progress reports to verify execution order
|
||||
var reportedPositionIndices = new List<int>();
|
||||
var reportedNodeIds = new List<Guid>();
|
||||
var progress = new SynchronousProgress<CncNodeExecutionProgress>(p =>
|
||||
{
|
||||
// Capture the first Running report for each node (the initial progress report)
|
||||
if (p.State == NodeExecutionState.Running && p.PositionIndex.HasValue)
|
||||
{
|
||||
reportedNodeIds.Add(p.NodeId);
|
||||
reportedPositionIndices.Add(p.PositionIndex.Value);
|
||||
}
|
||||
});
|
||||
|
||||
service.ExecuteAsync(program, progress, CancellationToken.None)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
// Build a map from NodeId to Index
|
||||
var nodeIndexMap = savePositionNodes.ToDictionary(n => n.Id, n => n.Index);
|
||||
|
||||
// Verify 1: All nodes were executed
|
||||
if (reportedNodeIds.Count != savePositionNodes.Count)
|
||||
return false;
|
||||
|
||||
// Verify 2: Nodes were processed in strictly ascending Index order
|
||||
var executedIndices = reportedNodeIds
|
||||
.Select(id => nodeIndexMap[id])
|
||||
.ToList();
|
||||
|
||||
for (int i = 1; i < executedIndices.Count; i++)
|
||||
{
|
||||
if (executedIndices[i] <= executedIndices[i - 1])
|
||||
return false;
|
||||
}
|
||||
|
||||
// Verify 3: Progress report PositionIndex values are strictly ascending from 0
|
||||
for (int i = 0; i < reportedPositionIndices.Count; i++)
|
||||
{
|
||||
if (reportedPositionIndices[i] != i)
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,263 @@
|
||||
#pragma warning disable xUnit1031 // FsCheck property tests require synchronous execution via GetAwaiter().GetResult()
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using System.Windows.Media;
|
||||
using System.Windows.Media.Imaging;
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
using Moq;
|
||||
using Prism.Events;
|
||||
using XP.Common.Logging.Interfaces;
|
||||
using XplorePlane.Events;
|
||||
using XplorePlane.Models;
|
||||
using XplorePlane.Services;
|
||||
using XplorePlane.Services.AppState;
|
||||
using XplorePlane.Services.Cnc;
|
||||
using XplorePlane.Services.InspectionResults;
|
||||
using XplorePlane.Services.MainViewport;
|
||||
using Xunit;
|
||||
|
||||
namespace XplorePlane.Tests.Services
|
||||
{
|
||||
/// <summary>
|
||||
/// Property 3: 采集或保存失败不中断后续执行
|
||||
/// **Validates: Requirements 1.5, 1.6, 3.3, 3.6**
|
||||
///
|
||||
/// For any CNC program with multiple SavePositionNodes, if image acquisition fails
|
||||
/// (detector returns null) or image persistence fails (I/O error) at any position,
|
||||
/// all subsequent positions SHALL still be attempted for execution.
|
||||
/// </summary>
|
||||
public class ExecutionResiliencePropertyTests
|
||||
{
|
||||
// ── Helper: Create a frozen BitmapSource for testing ──
|
||||
private static BitmapSource CreateTestBitmap()
|
||||
{
|
||||
var stride = 4;
|
||||
var pixels = new byte[stride * 1];
|
||||
var bitmap = BitmapSource.Create(1, 1, 96, 96, PixelFormats.Bgra32, null, pixels, stride);
|
||||
bitmap.Freeze();
|
||||
return bitmap;
|
||||
}
|
||||
|
||||
// ── Helper: Create service with full mock access ──
|
||||
private static (
|
||||
CncExecutionService Service,
|
||||
Mock<IInspectionResultStore> Store,
|
||||
Mock<ILoggerService> Logger,
|
||||
Mock<IMainViewportService> MainViewport,
|
||||
Mock<IAppStateService> AppState,
|
||||
Mock<IImagePersistenceService> ImagePersistence)
|
||||
CreateServiceWithImagePersistence()
|
||||
{
|
||||
var mockStore = new Mock<IInspectionResultStore>();
|
||||
var mockLogger = new Mock<ILoggerService>();
|
||||
var mockMainViewportService = new Mock<IMainViewportService>();
|
||||
var mockAppStateService = new Mock<IAppStateService>();
|
||||
var mockPipelineExecutionService = new Mock<IPipelineExecutionService>();
|
||||
var mockImageProcessingService = new Mock<IImageProcessingService>();
|
||||
var mockEventAggregator = new Mock<IEventAggregator>();
|
||||
var mockImagePersistenceService = new Mock<IImagePersistenceService>();
|
||||
mockLogger.Setup(l => l.ForModule<CncExecutionService>()).Returns(mockLogger.Object);
|
||||
|
||||
mockEventAggregator
|
||||
.Setup(ea => ea.GetEvent<DetectorDisconnectedEvent>())
|
||||
.Returns(new DetectorDisconnectedEvent());
|
||||
|
||||
mockStore.Setup(s => s.BeginRunAsync(
|
||||
It.IsAny<InspectionRunRecord>(),
|
||||
It.IsAny<InspectionAssetWriteRequest>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.AppendNodeResultAsync(
|
||||
It.IsAny<InspectionNodeResult>(),
|
||||
It.IsAny<IEnumerable<InspectionMetricResult>>(),
|
||||
It.IsAny<PipelineExecutionSnapshot>(),
|
||||
It.IsAny<IEnumerable<InspectionAssetWriteRequest>>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.CompleteRunAsync(
|
||||
It.IsAny<Guid>(),
|
||||
It.IsAny<bool?>(),
|
||||
It.IsAny<DateTime?>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
// Default: WriteSummaryAsync succeeds
|
||||
mockImagePersistenceService.Setup(s => s.WriteSummaryAsync(
|
||||
It.IsAny<BatchCaptureResult>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(true);
|
||||
|
||||
var service = new CncExecutionService(
|
||||
mockStore.Object,
|
||||
mockLogger.Object,
|
||||
mockMainViewportService.Object,
|
||||
mockAppStateService.Object,
|
||||
mockPipelineExecutionService.Object,
|
||||
mockImageProcessingService.Object,
|
||||
mockEventAggregator.Object,
|
||||
mockImagePersistenceService.Object);
|
||||
|
||||
return (service, mockStore, mockLogger, mockMainViewportService, mockAppStateService, mockImagePersistenceService);
|
||||
}
|
||||
|
||||
// ── Generator: Produce N SavePositionNodes with unique ascending indices ──
|
||||
private static Gen<List<SavePositionNode>> SavePositionNodesGen(int minCount, int maxCount)
|
||||
{
|
||||
return
|
||||
from count in Gen.Choose(minCount, maxCount)
|
||||
from nodes in GenSavePositionNodes(count)
|
||||
select nodes;
|
||||
}
|
||||
|
||||
private static Gen<List<SavePositionNode>> GenSavePositionNodes(int count)
|
||||
{
|
||||
Gen<List<SavePositionNode>> acc = Gen.Constant(new List<SavePositionNode>());
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
var idx = i;
|
||||
acc = from list in acc
|
||||
from saveImage in Gen.Elements(true, false)
|
||||
select new List<SavePositionNode>(list)
|
||||
{
|
||||
new SavePositionNode(
|
||||
Guid.NewGuid(), idx, $"Pos_{idx}",
|
||||
MotionState.Default, SaveImage: saveImage)
|
||||
};
|
||||
}
|
||||
return acc;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generator for a set of failure indices (positions where acquisition or save will fail).
|
||||
/// Ensures at least one failure position and that failures don't cover ALL positions
|
||||
/// (so we can verify subsequent positions still execute).
|
||||
/// </summary>
|
||||
private static Gen<(HashSet<int> DetectorFailIndices, HashSet<int> SaveFailIndices)> FailureIndicesGen(int totalPositions)
|
||||
{
|
||||
return
|
||||
from failCount in Gen.Choose(1, Math.Max(1, totalPositions - 1))
|
||||
from failIndices in Gen.Shuffle(Enumerable.Range(0, totalPositions).ToArray())
|
||||
.Select(arr => arr.Take(failCount).ToList())
|
||||
from splitPoint in Gen.Choose(0, failCount)
|
||||
let detectorFails = new HashSet<int>(failIndices.Take(splitPoint))
|
||||
let saveFails = new HashSet<int>(failIndices.Skip(splitPoint))
|
||||
select (detectorFails, saveFails);
|
||||
}
|
||||
|
||||
// ── Property Test ──
|
||||
|
||||
/// <summary>
|
||||
/// Feature: cnc-multi-position-image-capture, Property 3: 采集或保存失败不中断后续执行
|
||||
/// **Validates: Requirements 1.5, 1.6, 3.3, 3.6**
|
||||
///
|
||||
/// For any CNC program with N >= 2 SavePositionNodes, if image acquisition fails
|
||||
/// (detector returns null) or image persistence fails (I/O error) at randomly selected
|
||||
/// positions, ALL N positions SHALL still be attempted (progress reported for each).
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property AcquisitionOrSaveFailure_DoesNotInterruptSubsequentPositions()
|
||||
{
|
||||
var gen =
|
||||
from nodes in SavePositionNodesGen(2, 8)
|
||||
from failures in FailureIndicesGen(nodes.Count)
|
||||
select (nodes, failures.DetectorFailIndices, failures.SaveFailIndices);
|
||||
|
||||
return Prop.ForAll(
|
||||
gen.ToArbitrary(),
|
||||
tuple =>
|
||||
{
|
||||
var (saveNodes, detectorFailIndices, saveFailIndices) = tuple;
|
||||
int totalPositions = saveNodes.Count;
|
||||
|
||||
var (service, _, _, mockMainViewport, _, mockImagePersistence) =
|
||||
CreateServiceWithImagePersistence();
|
||||
|
||||
// ── Configure detector mock ──
|
||||
// For positions where detector should fail, return null.
|
||||
// For others, return a valid image.
|
||||
var testBitmap = CreateTestBitmap();
|
||||
|
||||
// TryGetSourceImage reads from LatestManualImage first, then CurrentDisplayImage.
|
||||
// We use CurrentDisplayImage to control per-position behavior.
|
||||
mockMainViewport.SetupGet(m => m.LatestManualImage)
|
||||
.Returns((System.Windows.Media.ImageSource)null);
|
||||
|
||||
// Use a callback-based setup to return null or valid image based on position
|
||||
var imageSequence = new Queue<BitmapSource>();
|
||||
foreach (var node in saveNodes)
|
||||
{
|
||||
int nodeIndex = saveNodes.IndexOf(node);
|
||||
if (detectorFailIndices.Contains(nodeIndex))
|
||||
imageSequence.Enqueue(null); // Detector fails
|
||||
else
|
||||
imageSequence.Enqueue(testBitmap); // Detector succeeds
|
||||
}
|
||||
|
||||
// Also need an initial call for runSourceImage at the start of ExecuteAsync
|
||||
mockMainViewport.Setup(m => m.CurrentDisplayImage)
|
||||
.Returns(() =>
|
||||
{
|
||||
if (imageSequence.Count > 0)
|
||||
return imageSequence.Dequeue();
|
||||
return testBitmap;
|
||||
});
|
||||
|
||||
// ── Configure image persistence mock ──
|
||||
// For positions where save should fail, throw IOException.
|
||||
// For others, return success.
|
||||
mockImagePersistence.Setup(s => s.SaveImageAsync(
|
||||
It.IsAny<byte[]>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.Returns<byte[], string, string, CancellationToken>((_, nodeName, __, ___) =>
|
||||
{
|
||||
// Find the position index by node name
|
||||
var posIdx = saveNodes.FindIndex(n => n.Name == nodeName);
|
||||
if (posIdx >= 0 && saveFailIndices.Contains(posIdx))
|
||||
{
|
||||
// Simulate I/O failure
|
||||
return Task.FromResult(new ImageSaveResult(
|
||||
false, string.Empty, 0, "Simulated I/O error"));
|
||||
}
|
||||
return Task.FromResult(new ImageSaveResult(
|
||||
true, $"C:\\Images\\{nodeName}.bmp", 1024, null));
|
||||
});
|
||||
|
||||
// ── Build CNC program ──
|
||||
var program = new CncProgram(
|
||||
Guid.NewGuid(), "TestProgram",
|
||||
DateTime.UtcNow, DateTime.UtcNow,
|
||||
saveNodes.Cast<CncNode>().ToList().AsReadOnly());
|
||||
|
||||
// ── Track progress reports ──
|
||||
var reportedNodeIds = new List<Guid>();
|
||||
var progress = new SynchronousProgress<CncNodeExecutionProgress>(p =>
|
||||
{
|
||||
// Count Running reports for SavePositionNodes (first report per position)
|
||||
if (p.State == NodeExecutionState.Running && p.PositionIndex.HasValue)
|
||||
{
|
||||
if (!reportedNodeIds.Contains(p.NodeId))
|
||||
reportedNodeIds.Add(p.NodeId);
|
||||
}
|
||||
});
|
||||
|
||||
// ── Execute ──
|
||||
service.ExecuteAsync(program, progress, CancellationToken.None)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
// ── Verify: ALL positions were attempted ──
|
||||
// Each SavePositionNode should have received at least one Running progress report
|
||||
bool allPositionsAttempted = reportedNodeIds.Count == totalPositions;
|
||||
|
||||
return allPositionsAttempted;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,339 @@
|
||||
#pragma warning disable xUnit1031 // FsCheck property tests require synchronous execution via GetAwaiter().GetResult()
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using System.Windows.Media;
|
||||
using System.Windows.Media.Imaging;
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
using Moq;
|
||||
using Prism.Events;
|
||||
using XP.Common.Logging.Interfaces;
|
||||
using XplorePlane.Events;
|
||||
using XplorePlane.Models;
|
||||
using XplorePlane.Services;
|
||||
using XplorePlane.Services.AppState;
|
||||
using XplorePlane.Services.Cnc;
|
||||
using XplorePlane.Services.InspectionResults;
|
||||
using XplorePlane.Services.MainViewport;
|
||||
using XplorePlane.ViewModels;
|
||||
using Xunit;
|
||||
|
||||
namespace XplorePlane.Tests.Services
|
||||
{
|
||||
/// <summary>
|
||||
/// Property 6: 采集图像传递给紧邻的 InspectionModuleNode
|
||||
/// Feature: cnc-multi-position-image-capture
|
||||
/// **Validates: Requirements 3.2**
|
||||
///
|
||||
/// For any CNC program where a SavePositionNode is immediately followed (by Index order)
|
||||
/// by an InspectionModuleNode, the image acquired at that SavePositionNode SHALL be passed
|
||||
/// as the source image to the InspectionModuleNode's pipeline execution.
|
||||
/// </summary>
|
||||
public class ImagePassingPropertyTests
|
||||
{
|
||||
// ── Helper: Create a 1x1 BitmapSource for testing ──────────────────────
|
||||
|
||||
private static BitmapSource CreateTestBitmap()
|
||||
{
|
||||
var bitmap = new WriteableBitmap(1, 1, 96, 96, PixelFormats.Bgr32, null);
|
||||
bitmap.Freeze();
|
||||
return bitmap;
|
||||
}
|
||||
|
||||
// ── Generator: CNC programs with SavePositionNodes optionally followed by InspectionModuleNodes ──
|
||||
|
||||
private static Gen<string> NonEmptyStringGen =>
|
||||
ArbMap.Default.GeneratorFor<NonEmptyString>().Select(s => s.Get);
|
||||
|
||||
private static Gen<PipelineModel> PipelineGen =>
|
||||
from name in NonEmptyStringGen
|
||||
select new PipelineModel
|
||||
{
|
||||
Name = name,
|
||||
Nodes = new List<PipelineNodeModel>
|
||||
{
|
||||
new PipelineNodeModel { OperatorKey = "test_op", Order = 0, IsEnabled = true }
|
||||
}
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Generates a CNC program where some SavePositionNodes are followed by InspectionModuleNodes
|
||||
/// and some are not. Returns the program along with metadata about which pairs exist.
|
||||
/// </summary>
|
||||
private static Gen<CncProgram> CncProgramWithMixedFollowersGen()
|
||||
{
|
||||
return from saveCount in Gen.Choose(1, 5)
|
||||
from followFlags in Gen.ListOf<bool>(ArbMap.Default.GeneratorFor<bool>(), saveCount)
|
||||
from programName in NonEmptyStringGen
|
||||
let nodes = BuildMixedNodes(saveCount, followFlags)
|
||||
select new CncProgram(
|
||||
Guid.NewGuid(),
|
||||
programName,
|
||||
DateTime.UtcNow,
|
||||
DateTime.UtcNow,
|
||||
nodes.AsReadOnly());
|
||||
}
|
||||
|
||||
private static List<CncNode> BuildMixedNodes(int saveCount, IReadOnlyList<bool> followFlags)
|
||||
{
|
||||
var nodes = new List<CncNode>();
|
||||
int index = 0;
|
||||
|
||||
for (int i = 0; i < saveCount; i++)
|
||||
{
|
||||
// Add a SavePositionNode
|
||||
var spNode = new SavePositionNode(
|
||||
Guid.NewGuid(),
|
||||
index,
|
||||
$"Position_{i}",
|
||||
MotionState.Default,
|
||||
SaveImage: false,
|
||||
ManualImagePath: "");
|
||||
nodes.Add(spNode);
|
||||
index++;
|
||||
|
||||
// Optionally follow with an InspectionModuleNode
|
||||
if (i < followFlags.Count && followFlags[i])
|
||||
{
|
||||
var pipeline = new PipelineModel
|
||||
{
|
||||
Name = $"Pipeline_{i}",
|
||||
Nodes = new List<PipelineNodeModel>
|
||||
{
|
||||
new PipelineNodeModel { OperatorKey = "test_op", Order = 0, IsEnabled = true }
|
||||
}
|
||||
};
|
||||
var inspNode = new InspectionModuleNode(
|
||||
Guid.NewGuid(),
|
||||
index,
|
||||
$"Inspect_{i}",
|
||||
pipeline);
|
||||
nodes.Add(inspNode);
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
return nodes;
|
||||
}
|
||||
|
||||
// ── Service Factory ──────────────────────────────────────────────────────
|
||||
|
||||
private static (
|
||||
CncExecutionService Service,
|
||||
Mock<IPipelineExecutionService> PipelineExec,
|
||||
Mock<IMainViewportService> MainViewport,
|
||||
Mock<IImagePersistenceService> ImagePersistence,
|
||||
Mock<ILoggerService> Logger)
|
||||
CreateServiceWithCapture(BitmapSource detectorImage)
|
||||
{
|
||||
var mockStore = new Mock<IInspectionResultStore>();
|
||||
var mockLogger = new Mock<ILoggerService>();
|
||||
var mockMainViewportService = new Mock<IMainViewportService>();
|
||||
var mockAppStateService = new Mock<IAppStateService>();
|
||||
var mockPipelineExecutionService = new Mock<IPipelineExecutionService>();
|
||||
var mockImageProcessingService = new Mock<IImageProcessingService>();
|
||||
var mockEventAggregator = new Mock<IEventAggregator>();
|
||||
var mockImagePersistenceService = new Mock<IImagePersistenceService>();
|
||||
|
||||
mockLogger.Setup(l => l.ForModule<CncExecutionService>()).Returns(mockLogger.Object);
|
||||
|
||||
mockEventAggregator
|
||||
.Setup(ea => ea.GetEvent<DetectorDisconnectedEvent>())
|
||||
.Returns(new DetectorDisconnectedEvent());
|
||||
|
||||
// Return the detector image from the viewport service (simulates detector acquisition)
|
||||
mockMainViewportService
|
||||
.Setup(m => m.CurrentDisplayImage)
|
||||
.Returns(detectorImage);
|
||||
|
||||
mockStore.Setup(s => s.BeginRunAsync(
|
||||
It.IsAny<InspectionRunRecord>(),
|
||||
It.IsAny<InspectionAssetWriteRequest>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.AppendNodeResultAsync(
|
||||
It.IsAny<InspectionNodeResult>(),
|
||||
It.IsAny<IEnumerable<InspectionMetricResult>>(),
|
||||
It.IsAny<PipelineExecutionSnapshot>(),
|
||||
It.IsAny<IEnumerable<InspectionAssetWriteRequest>>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.CompleteRunAsync(
|
||||
It.IsAny<Guid>(),
|
||||
It.IsAny<bool?>(),
|
||||
It.IsAny<DateTime?>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.SaveImageAsync(
|
||||
It.IsAny<byte[]>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(new ImageSaveResult(true, "test.bmp", 100));
|
||||
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.WriteSummaryAsync(
|
||||
It.IsAny<BatchCaptureResult>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(true);
|
||||
|
||||
var service = new CncExecutionService(
|
||||
mockStore.Object,
|
||||
mockLogger.Object,
|
||||
mockMainViewportService.Object,
|
||||
mockAppStateService.Object,
|
||||
mockPipelineExecutionService.Object,
|
||||
mockImageProcessingService.Object,
|
||||
mockEventAggregator.Object,
|
||||
mockImagePersistenceService.Object);
|
||||
|
||||
return (service, mockPipelineExecutionService, mockMainViewportService, mockImagePersistenceService, mockLogger);
|
||||
}
|
||||
|
||||
// ── Property 6: 采集图像传递给紧邻的 InspectionModuleNode ──────────────
|
||||
|
||||
// Feature: cnc-multi-position-image-capture, Property 6: 采集图像传递给紧邻的 InspectionModuleNode
|
||||
// Validates: Requirements 3.2
|
||||
[Property(MaxTest = 100)]
|
||||
public Property AcquiredImage_PassedToFollowingInspectionModuleNode()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
CncProgramWithMixedFollowersGen().ToArbitrary(),
|
||||
program =>
|
||||
{
|
||||
var detectorImage = CreateTestBitmap();
|
||||
var (service, mockPipelineExec, _, _, _) = CreateServiceWithCapture(detectorImage);
|
||||
|
||||
// Track all pipeline execution calls with their source images
|
||||
var pipelineCalls = new List<(Guid NodeId, BitmapSource SourceImage)>();
|
||||
|
||||
mockPipelineExec
|
||||
.Setup(p => p.ExecutePipelineAsync(
|
||||
It.IsAny<IEnumerable<PipelineNodeViewModel>>(),
|
||||
It.IsAny<BitmapSource>(),
|
||||
It.IsAny<IProgress<PipelineProgress>>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.Callback<IEnumerable<PipelineNodeViewModel>, BitmapSource, IProgress<PipelineProgress>, CancellationToken>(
|
||||
(nodes, source, progress, ct) =>
|
||||
{
|
||||
// We can't easily get the NodeId from here, but we track the source image
|
||||
pipelineCalls.Add((Guid.Empty, source));
|
||||
})
|
||||
.ReturnsAsync(detectorImage);
|
||||
|
||||
service.ExecuteAsync(program, null, CancellationToken.None)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
// Determine expected behavior from the program structure
|
||||
var allNodesOrdered = program.Nodes.OrderBy(n => n.Index).ToList();
|
||||
var savePositionNodes = allNodesOrdered.OfType<SavePositionNode>().ToList();
|
||||
|
||||
int expectedPipelineCalls = 0;
|
||||
foreach (var sp in savePositionNodes)
|
||||
{
|
||||
int spOrderIndex = allNodesOrdered.FindIndex(n => n.Id == sp.Id);
|
||||
if (spOrderIndex >= 0 && spOrderIndex + 1 < allNodesOrdered.Count)
|
||||
{
|
||||
var nextNode = allNodesOrdered[spOrderIndex + 1];
|
||||
if (nextNode is InspectionModuleNode)
|
||||
expectedPipelineCalls++;
|
||||
}
|
||||
}
|
||||
|
||||
// Verify: pipeline was called exactly for each SavePositionNode followed by InspectionModuleNode
|
||||
bool correctCallCount = pipelineCalls.Count == expectedPipelineCalls;
|
||||
|
||||
// Verify: each pipeline call received a non-null source image (the detector image)
|
||||
bool allReceivedImage = pipelineCalls.All(c => c.SourceImage != null);
|
||||
|
||||
// Verify: each pipeline call received the same detector image
|
||||
bool allReceivedCorrectImage = pipelineCalls.All(c =>
|
||||
ReferenceEquals(c.SourceImage, detectorImage));
|
||||
|
||||
return correctCallCount && allReceivedImage && allReceivedCorrectImage;
|
||||
});
|
||||
}
|
||||
|
||||
// ── Property 6 (negative case): SavePositionNode NOT followed by InspectionModuleNode ──
|
||||
|
||||
// Feature: cnc-multi-position-image-capture, Property 6 (negative): No pipeline execution for non-followed SavePositionNodes
|
||||
// Validates: Requirements 3.2
|
||||
[Property(MaxTest = 100)]
|
||||
public Property NoPipelineExecution_WhenNoFollowingInspectionModuleNode()
|
||||
{
|
||||
// Generate programs where NO SavePositionNode is followed by an InspectionModuleNode
|
||||
var gen = from saveCount in Gen.Choose(1, 5)
|
||||
from programName in NonEmptyStringGen
|
||||
let nodes = BuildNodesWithoutFollowingInspection(saveCount)
|
||||
select new CncProgram(
|
||||
Guid.NewGuid(),
|
||||
programName,
|
||||
DateTime.UtcNow,
|
||||
DateTime.UtcNow,
|
||||
nodes.AsReadOnly());
|
||||
|
||||
return Prop.ForAll(
|
||||
gen.ToArbitrary(),
|
||||
program =>
|
||||
{
|
||||
var detectorImage = CreateTestBitmap();
|
||||
var (service, mockPipelineExec, _, _, _) = CreateServiceWithCapture(detectorImage);
|
||||
|
||||
int pipelineCallCount = 0;
|
||||
mockPipelineExec
|
||||
.Setup(p => p.ExecutePipelineAsync(
|
||||
It.IsAny<IEnumerable<PipelineNodeViewModel>>(),
|
||||
It.IsAny<BitmapSource>(),
|
||||
It.IsAny<IProgress<PipelineProgress>>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.Callback<IEnumerable<PipelineNodeViewModel>, BitmapSource, IProgress<PipelineProgress>, CancellationToken>(
|
||||
(_, _, _, _) => Interlocked.Increment(ref pipelineCallCount))
|
||||
.ReturnsAsync(detectorImage);
|
||||
|
||||
service.ExecuteAsync(program, null, CancellationToken.None)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
// No pipeline execution should occur for SavePositionNodes
|
||||
// (InspectionModuleNodes in the general loop may still trigger pipeline,
|
||||
// but since we only have SavePositionNodes and non-inspection nodes, count should be 0)
|
||||
return pipelineCallCount == 0;
|
||||
});
|
||||
}
|
||||
|
||||
private static List<CncNode> BuildNodesWithoutFollowingInspection(int saveCount)
|
||||
{
|
||||
var nodes = new List<CncNode>();
|
||||
int index = 0;
|
||||
|
||||
for (int i = 0; i < saveCount; i++)
|
||||
{
|
||||
// Add a SavePositionNode
|
||||
nodes.Add(new SavePositionNode(
|
||||
Guid.NewGuid(),
|
||||
index,
|
||||
$"Position_{i}",
|
||||
MotionState.Default,
|
||||
SaveImage: false,
|
||||
ManualImagePath: ""));
|
||||
index++;
|
||||
|
||||
// Follow with a non-inspection node (e.g., WaitDelayNode with 0ms)
|
||||
nodes.Add(new WaitDelayNode(
|
||||
Guid.NewGuid(),
|
||||
index,
|
||||
$"Wait_{i}",
|
||||
0));
|
||||
index++;
|
||||
}
|
||||
|
||||
return nodes;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,301 @@
|
||||
#pragma warning disable xUnit1031 // FsCheck property tests require synchronous execution via GetAwaiter().GetResult()
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using System.Windows.Media;
|
||||
using System.Windows.Media.Imaging;
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
using Moq;
|
||||
using Prism.Events;
|
||||
using XP.Common.Logging.Interfaces;
|
||||
using XplorePlane.Events;
|
||||
using XplorePlane.Models;
|
||||
using XplorePlane.Services;
|
||||
using XplorePlane.Services.AppState;
|
||||
using XplorePlane.Services.Cnc;
|
||||
using XplorePlane.Services.InspectionResults;
|
||||
using XplorePlane.Services.MainViewport;
|
||||
using Xunit;
|
||||
|
||||
namespace XplorePlane.Tests.Services
|
||||
{
|
||||
/// <summary>
|
||||
/// Feature: cnc-multi-position-image-capture, Property 2: 图像持久化对所有 SaveImage=true 节点触发
|
||||
/// **Validates: Requirements 1.1, 2.5**
|
||||
///
|
||||
/// For any CNC program containing one or more SavePositionNode with SaveImage=true
|
||||
/// (regardless of whether ManualImagePath is set or empty), the CNC_Execution_Service
|
||||
/// SHALL invoke the Image_Persistence_Service exactly once per such node that is reached
|
||||
/// during execution.
|
||||
/// </summary>
|
||||
public class ImagePersistenceCallPropertyTests
|
||||
{
|
||||
/// <summary>
|
||||
/// Creates a 1x1 pixel frozen BitmapSource for testing purposes.
|
||||
/// </summary>
|
||||
private static BitmapSource CreateTestBitmap()
|
||||
{
|
||||
var bitmap = BitmapSource.Create(
|
||||
1, 1, 96, 96,
|
||||
PixelFormats.Gray16,
|
||||
null,
|
||||
new byte[] { 0xFF, 0xFF },
|
||||
2);
|
||||
bitmap.Freeze();
|
||||
return bitmap;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Creates a fully mocked CncExecutionService with IMainViewportService returning
|
||||
/// a valid image (so TryGetSourceImage always succeeds) and IImagePersistenceService
|
||||
/// tracking SaveImageAsync calls.
|
||||
/// </summary>
|
||||
private static (CncExecutionService Service, Mock<IImagePersistenceService> ImagePersistence)
|
||||
CreateServiceWithImageSupport()
|
||||
{
|
||||
var mockStore = new Mock<IInspectionResultStore>();
|
||||
var mockLogger = new Mock<ILoggerService>();
|
||||
var mockMainViewportService = new Mock<IMainViewportService>();
|
||||
var mockAppStateService = new Mock<IAppStateService>();
|
||||
var mockPipelineExecutionService = new Mock<IPipelineExecutionService>();
|
||||
var mockImageProcessingService = new Mock<IImageProcessingService>();
|
||||
var mockEventAggregator = new Mock<IEventAggregator>();
|
||||
var mockImagePersistenceService = new Mock<IImagePersistenceService>();
|
||||
|
||||
mockLogger.Setup(l => l.ForModule<CncExecutionService>()).Returns(mockLogger.Object);
|
||||
|
||||
// Set up GetEvent<DetectorDisconnectedEvent>() so the constructor subscription doesn't throw
|
||||
mockEventAggregator
|
||||
.Setup(ea => ea.GetEvent<DetectorDisconnectedEvent>())
|
||||
.Returns(new DetectorDisconnectedEvent());
|
||||
|
||||
// Mock IMainViewportService to return a valid image so TryGetSourceImage() succeeds
|
||||
var testBitmap = CreateTestBitmap();
|
||||
mockMainViewportService
|
||||
.Setup(m => m.LatestManualImage)
|
||||
.Returns(testBitmap);
|
||||
|
||||
// Mock IInspectionResultStore methods
|
||||
mockStore.Setup(s => s.BeginRunAsync(
|
||||
It.IsAny<InspectionRunRecord>(),
|
||||
It.IsAny<InspectionAssetWriteRequest>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.AppendNodeResultAsync(
|
||||
It.IsAny<InspectionNodeResult>(),
|
||||
It.IsAny<IEnumerable<InspectionMetricResult>>(),
|
||||
It.IsAny<PipelineExecutionSnapshot>(),
|
||||
It.IsAny<IEnumerable<InspectionAssetWriteRequest>>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.CompleteRunAsync(
|
||||
It.IsAny<Guid>(),
|
||||
It.IsAny<bool?>(),
|
||||
It.IsAny<DateTime?>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
// Mock SaveImageAsync to return success
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.SaveImageAsync(
|
||||
It.IsAny<byte[]>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(new ImageSaveResult(true, @"C:\test\image.bmp", 1024));
|
||||
|
||||
// Mock WriteSummaryAsync to return success
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.WriteSummaryAsync(
|
||||
It.IsAny<BatchCaptureResult>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(true);
|
||||
|
||||
var service = new CncExecutionService(
|
||||
mockStore.Object,
|
||||
mockLogger.Object,
|
||||
mockMainViewportService.Object,
|
||||
mockAppStateService.Object,
|
||||
mockPipelineExecutionService.Object,
|
||||
mockImageProcessingService.Object,
|
||||
mockEventAggregator.Object,
|
||||
mockImagePersistenceService.Object);
|
||||
|
||||
return (service, mockImagePersistenceService);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generator for a list of SavePositionNodes with random SaveImage flags.
|
||||
/// Ensures at least one node has SaveImage=true.
|
||||
/// </summary>
|
||||
private static Gen<List<SavePositionNode>> SavePositionNodesGen =>
|
||||
from count in Gen.Choose(1, 8)
|
||||
from flags in Gen.ListOf<bool>(ArbMap.Default.GeneratorFor<bool>(), count)
|
||||
let hasAtLeastOneTrue = flags.Any(f => f)
|
||||
let adjustedFlags = hasAtLeastOneTrue ? flags : flags.Select((f, i) => i == 0 || f).ToList()
|
||||
from names in Gen.ListOf<string>(ArbMap.Default.GeneratorFor<NonEmptyString>().Select(s => s.Get), count)
|
||||
select Enumerable.Range(0, count)
|
||||
.Select(i => new SavePositionNode(
|
||||
Guid.NewGuid(),
|
||||
i,
|
||||
names[i],
|
||||
new MotionState(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
|
||||
SaveImage: adjustedFlags[i],
|
||||
ManualImagePath: ""))
|
||||
.ToList();
|
||||
|
||||
/// <summary>
|
||||
/// Generator for SavePositionNodes where some have ManualImagePath set (non-empty)
|
||||
/// and some don't, but all with SaveImage=true to test that persistence is called
|
||||
/// regardless of ManualImagePath being set.
|
||||
/// Note: ManualImagePath validation requires file to exist, so we leave it empty
|
||||
/// in this test (the detector mock provides the image).
|
||||
/// </summary>
|
||||
private static Gen<List<SavePositionNode>> SavePositionNodesAllSaveImageTrueGen =>
|
||||
from count in Gen.Choose(1, 8)
|
||||
from names in Gen.ListOf<string>(ArbMap.Default.GeneratorFor<NonEmptyString>().Select(s => s.Get), count)
|
||||
select Enumerable.Range(0, count)
|
||||
.Select(i => new SavePositionNode(
|
||||
Guid.NewGuid(),
|
||||
i,
|
||||
names[i],
|
||||
new MotionState(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
|
||||
SaveImage: true,
|
||||
ManualImagePath: ""))
|
||||
.ToList();
|
||||
|
||||
// ── Property 2: 图像持久化对所有 SaveImage=true 节点触发 ──────────────
|
||||
|
||||
/// <summary>
|
||||
/// Feature: cnc-multi-position-image-capture, Property 2: 图像持久化对所有 SaveImage=true 节点触发
|
||||
/// **Validates: Requirements 1.1, 2.5**
|
||||
///
|
||||
/// For any CNC program containing SavePositionNodes with mixed SaveImage flags,
|
||||
/// SaveImageAsync is called exactly N times where N = count of nodes with SaveImage=true.
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property SaveImageAsync_CalledExactlyOncePerSaveImageTrueNode()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
SavePositionNodesGen.ToArbitrary(),
|
||||
nodes =>
|
||||
{
|
||||
var (service, mockImagePersistence) = CreateServiceWithImageSupport();
|
||||
|
||||
var program = new CncProgram(
|
||||
Guid.NewGuid(),
|
||||
"TestProgram",
|
||||
DateTime.UtcNow,
|
||||
DateTime.UtcNow,
|
||||
nodes.Cast<CncNode>().ToList().AsReadOnly());
|
||||
|
||||
service.ExecuteAsync(program, null, CancellationToken.None)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
int expectedCalls = nodes.Count(n => n.SaveImage);
|
||||
|
||||
mockImagePersistence.Verify(
|
||||
s => s.SaveImageAsync(
|
||||
It.IsAny<byte[]>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()),
|
||||
Times.Exactly(expectedCalls));
|
||||
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Feature: cnc-multi-position-image-capture, Property 2 (all true variant):
|
||||
/// When all nodes have SaveImage=true, SaveImageAsync is called exactly N times (one per node).
|
||||
/// **Validates: Requirements 1.1, 2.5**
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property SaveImageAsync_CalledForEveryNode_WhenAllSaveImageTrue()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
SavePositionNodesAllSaveImageTrueGen.ToArbitrary(),
|
||||
nodes =>
|
||||
{
|
||||
var (service, mockImagePersistence) = CreateServiceWithImageSupport();
|
||||
|
||||
var program = new CncProgram(
|
||||
Guid.NewGuid(),
|
||||
"TestProgram",
|
||||
DateTime.UtcNow,
|
||||
DateTime.UtcNow,
|
||||
nodes.Cast<CncNode>().ToList().AsReadOnly());
|
||||
|
||||
service.ExecuteAsync(program, null, CancellationToken.None)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
// All nodes have SaveImage=true, so SaveImageAsync should be called for each
|
||||
mockImagePersistence.Verify(
|
||||
s => s.SaveImageAsync(
|
||||
It.IsAny<byte[]>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()),
|
||||
Times.Exactly(nodes.Count));
|
||||
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Feature: cnc-multi-position-image-capture, Property 2 (none true variant):
|
||||
/// When no nodes have SaveImage=true, SaveImageAsync is never called.
|
||||
/// **Validates: Requirements 1.1, 2.5**
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property SaveImageAsync_NeverCalled_WhenNoSaveImageTrue()
|
||||
{
|
||||
var nodesGen =
|
||||
from count in Gen.Choose(1, 8)
|
||||
from names in Gen.ListOf<string>(ArbMap.Default.GeneratorFor<NonEmptyString>().Select(s => s.Get), count)
|
||||
select Enumerable.Range(0, count)
|
||||
.Select(i => new SavePositionNode(
|
||||
Guid.NewGuid(),
|
||||
i,
|
||||
names[i],
|
||||
new MotionState(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
|
||||
SaveImage: false,
|
||||
ManualImagePath: ""))
|
||||
.ToList();
|
||||
|
||||
return Prop.ForAll(
|
||||
nodesGen.ToArbitrary(),
|
||||
nodes =>
|
||||
{
|
||||
var (service, mockImagePersistence) = CreateServiceWithImageSupport();
|
||||
|
||||
var program = new CncProgram(
|
||||
Guid.NewGuid(),
|
||||
"TestProgram",
|
||||
DateTime.UtcNow,
|
||||
DateTime.UtcNow,
|
||||
nodes.Cast<CncNode>().ToList().AsReadOnly());
|
||||
|
||||
service.ExecuteAsync(program, null, CancellationToken.None)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
// No nodes have SaveImage=true, so SaveImageAsync should never be called
|
||||
mockImagePersistence.Verify(
|
||||
s => s.SaveImageAsync(
|
||||
It.IsAny<byte[]>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()),
|
||||
Times.Never);
|
||||
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,294 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Text.Json;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Moq;
|
||||
using XP.Common.Logging.Interfaces;
|
||||
using XplorePlane.Models;
|
||||
using XplorePlane.Services.Cnc;
|
||||
using XplorePlane.Services.Storage;
|
||||
using Xunit;
|
||||
|
||||
namespace XplorePlane.Tests.Services
|
||||
{
|
||||
/// <summary>
|
||||
/// Unit tests for ImagePersistenceService.
|
||||
/// Validates: Requirements 1.3, 1.5, 1.7, 4.3
|
||||
/// </summary>
|
||||
public class ImagePersistenceServiceTests : IDisposable
|
||||
{
|
||||
private readonly string _tempDir;
|
||||
private readonly Mock<IXpDataPathService> _mockDataPathService;
|
||||
private readonly Mock<ILoggerService> _mockLogger;
|
||||
private readonly ImagePersistenceService _service;
|
||||
|
||||
public ImagePersistenceServiceTests()
|
||||
{
|
||||
_tempDir = Path.Combine(Path.GetTempPath(), "ImagePersistenceTests_" + Guid.NewGuid().ToString("N"));
|
||||
Directory.CreateDirectory(_tempDir);
|
||||
|
||||
_mockDataPathService = new Mock<IXpDataPathService>();
|
||||
_mockDataPathService.Setup(s => s.DataPath).Returns(_tempDir);
|
||||
|
||||
_mockLogger = new Mock<ILoggerService>();
|
||||
_mockLogger.Setup(l => l.ForModule<ImagePersistenceService>()).Returns(_mockLogger.Object);
|
||||
|
||||
_service = new ImagePersistenceService(_mockDataPathService.Object, _mockLogger.Object);
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
try
|
||||
{
|
||||
if (Directory.Exists(_tempDir))
|
||||
Directory.Delete(_tempDir, recursive: true);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// Best-effort cleanup
|
||||
}
|
||||
}
|
||||
|
||||
// ── Test: Directory auto-creation ────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task SaveImageAsync_CreatesDirectory_WhenItDoesNotExist()
|
||||
{
|
||||
// Arrange: use a sub-path that doesn't exist yet
|
||||
var nestedDir = Path.Combine(_tempDir, "nested", "deep");
|
||||
_mockDataPathService.Setup(s => s.DataPath).Returns(nestedDir);
|
||||
var service = new ImagePersistenceService(_mockDataPathService.Object, _mockLogger.Object);
|
||||
|
||||
var imageData = new byte[] { 0x42, 0x4D, 0x00, 0x01 }; // minimal data
|
||||
var programName = "TestProgram";
|
||||
var nodeName = "Position1";
|
||||
|
||||
// Act
|
||||
var result = await service.SaveImageAsync(imageData, nodeName, programName);
|
||||
|
||||
// Assert
|
||||
Assert.True(result.Success);
|
||||
Assert.True(Directory.Exists(Path.GetDirectoryName(result.FilePath)));
|
||||
Assert.True(File.Exists(result.FilePath));
|
||||
}
|
||||
|
||||
// ── Test: Successful save returns correct ImageSaveResult ─────────────
|
||||
|
||||
[Fact]
|
||||
public async Task SaveImageAsync_ReturnsCorrectResult_OnSuccess()
|
||||
{
|
||||
// Arrange
|
||||
var imageData = new byte[1024];
|
||||
new Random(42).NextBytes(imageData);
|
||||
var programName = "MyProgram";
|
||||
var nodeName = "Node_A";
|
||||
|
||||
// Act
|
||||
var result = await _service.SaveImageAsync(imageData, nodeName, programName);
|
||||
|
||||
// Assert
|
||||
Assert.True(result.Success);
|
||||
Assert.NotNull(result.FilePath);
|
||||
Assert.Contains(nodeName, result.FilePath);
|
||||
Assert.EndsWith(".bmp", result.FilePath);
|
||||
Assert.Equal(1024, result.FileSizeBytes);
|
||||
Assert.Null(result.ErrorMessage);
|
||||
|
||||
// Verify file actually exists with correct content
|
||||
var savedBytes = await File.ReadAllBytesAsync(result.FilePath);
|
||||
Assert.Equal(imageData, savedBytes);
|
||||
}
|
||||
|
||||
// ── Test: Timeout returns failure result ──────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task SaveImageAsync_ReturnsFailure_WhenCancelled()
|
||||
{
|
||||
// Arrange: pre-cancel the token to simulate timeout/cancellation scenario
|
||||
var imageData = new byte[] { 0x01, 0x02, 0x03 };
|
||||
using var cts = new CancellationTokenSource();
|
||||
cts.Cancel(); // Pre-cancel to trigger OperationCanceledException immediately
|
||||
|
||||
// Act
|
||||
var result = await _service.SaveImageAsync(imageData, "TestNode", "TestProgram", cts.Token);
|
||||
|
||||
// Assert
|
||||
Assert.False(result.Success);
|
||||
Assert.Null(result.FilePath);
|
||||
Assert.Equal(0, result.FileSizeBytes);
|
||||
Assert.NotNull(result.ErrorMessage);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task SaveImageAsync_ReturnsFailure_WhenTimeoutOccurs()
|
||||
{
|
||||
// Arrange: Use a read-only directory to force an IOException, simulating a timeout-like failure
|
||||
// We test the timeout path by using a very short internal timeout via a linked token
|
||||
// Since we can't easily trigger a real 10s timeout in a unit test,
|
||||
// we verify the cancellation path works correctly with a pre-cancelled external token
|
||||
// and verify the error message format for the external cancellation path.
|
||||
|
||||
// To truly test the timeout path, we'd need to mock File.WriteAllBytesAsync,
|
||||
// but since the service uses static File methods, we test the cancellation behavior instead.
|
||||
// The timeout mechanism uses CancellationTokenSource.CreateLinkedTokenSource + CancelAfter(10s).
|
||||
|
||||
// Verify that when external cancellation is NOT requested but operation is cancelled
|
||||
// (simulating internal timeout), the error message mentions timeout.
|
||||
// We achieve this by making the directory path invalid so the write fails.
|
||||
var invalidPath = Path.Combine(_tempDir, new string('x', 300)); // Path too long
|
||||
_mockDataPathService.Setup(s => s.DataPath).Returns(invalidPath);
|
||||
var service = new ImagePersistenceService(_mockDataPathService.Object, _mockLogger.Object);
|
||||
|
||||
var imageData = new byte[] { 0x01, 0x02, 0x03 };
|
||||
|
||||
// Act
|
||||
var result = await service.SaveImageAsync(imageData, "TestNode", "TestProgram");
|
||||
|
||||
// Assert - should fail gracefully (IOException path)
|
||||
Assert.False(result.Success);
|
||||
Assert.NotNull(result.ErrorMessage);
|
||||
Assert.Equal(0, result.FileSizeBytes);
|
||||
}
|
||||
|
||||
// ── Test: WriteSummaryAsync generates valid JSON ──────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task WriteSummaryAsync_GeneratesValidJson()
|
||||
{
|
||||
// Arrange
|
||||
var summary = new BatchCaptureResult
|
||||
{
|
||||
ProgramName = "TestProgram",
|
||||
StartTime = "2025-01-15T14:30:25",
|
||||
DurationSeconds = 45.5,
|
||||
TotalPositions = 3,
|
||||
SucceededPositions = 2,
|
||||
FailedPositions = 1,
|
||||
SavedImageCount = 2,
|
||||
Status = "Completed",
|
||||
Positions = new List<PositionResult>
|
||||
{
|
||||
new PositionResult { NodeName = "Pos1", NodeIndex = 0, Status = "Success", ImagePath = @"C:\img1.bmp" },
|
||||
new PositionResult { NodeName = "Pos2", NodeIndex = 1, Status = "Success", ImagePath = @"C:\img2.bmp" },
|
||||
new PositionResult { NodeName = "Pos3", NodeIndex = 2, Status = "Failed", ErrorMessage = "Detector timeout" }
|
||||
}
|
||||
};
|
||||
var programName = "TestProgram";
|
||||
|
||||
// Act
|
||||
var success = await _service.WriteSummaryAsync(summary, programName);
|
||||
|
||||
// Assert
|
||||
Assert.True(success);
|
||||
|
||||
// Verify the JSON file exists and can be deserialized back
|
||||
var directory = _service.GetBatchCaptureDirectory(programName);
|
||||
var summaryPath = Path.Combine(directory, "summary.json");
|
||||
Assert.True(File.Exists(summaryPath));
|
||||
|
||||
var json = await File.ReadAllTextAsync(summaryPath);
|
||||
var deserialized = JsonSerializer.Deserialize<BatchCaptureResult>(json);
|
||||
|
||||
Assert.NotNull(deserialized);
|
||||
Assert.Equal(summary.ProgramName, deserialized.ProgramName);
|
||||
Assert.Equal(summary.StartTime, deserialized.StartTime);
|
||||
Assert.Equal(summary.DurationSeconds, deserialized.DurationSeconds);
|
||||
Assert.Equal(summary.TotalPositions, deserialized.TotalPositions);
|
||||
Assert.Equal(summary.SucceededPositions, deserialized.SucceededPositions);
|
||||
Assert.Equal(summary.FailedPositions, deserialized.FailedPositions);
|
||||
Assert.Equal(summary.SavedImageCount, deserialized.SavedImageCount);
|
||||
Assert.Equal(summary.Status, deserialized.Status);
|
||||
Assert.Equal(3, deserialized.Positions.Count);
|
||||
Assert.Equal("Pos1", deserialized.Positions[0].NodeName);
|
||||
Assert.Equal("Failed", deserialized.Positions[2].Status);
|
||||
}
|
||||
|
||||
// ── Test: WriteSummaryAsync returns false on I/O failure ──────────────
|
||||
|
||||
[Fact]
|
||||
public async Task WriteSummaryAsync_ReturnsFalse_OnIOFailure()
|
||||
{
|
||||
// Arrange: use an invalid path that will cause I/O failure
|
||||
var invalidPath = Path.Combine(_tempDir, new string('x', 300));
|
||||
_mockDataPathService.Setup(s => s.DataPath).Returns(invalidPath);
|
||||
var service = new ImagePersistenceService(_mockDataPathService.Object, _mockLogger.Object);
|
||||
|
||||
var summary = new BatchCaptureResult
|
||||
{
|
||||
ProgramName = "TestProgram",
|
||||
TotalPositions = 1,
|
||||
Positions = new List<PositionResult>()
|
||||
};
|
||||
|
||||
// Act
|
||||
var result = await service.WriteSummaryAsync(summary, "TestProgram");
|
||||
|
||||
// Assert - should return false, not throw
|
||||
Assert.False(result);
|
||||
|
||||
// Verify error was logged
|
||||
_mockLogger.Verify(
|
||||
l => l.Error(It.IsAny<Exception>(), It.IsAny<string>(), It.IsAny<object[]>()),
|
||||
Times.Once);
|
||||
}
|
||||
|
||||
// ── Test: GetBatchCaptureDirectory returns correct path format ────────
|
||||
|
||||
[Fact]
|
||||
public void GetBatchCaptureDirectory_ReturnsCorrectPathFormat()
|
||||
{
|
||||
// Arrange
|
||||
var programName = "MyProgram";
|
||||
var expectedDate = DateTime.Now.ToString("yyyy-MM-dd");
|
||||
|
||||
// Act
|
||||
var result = _service.GetBatchCaptureDirectory(programName);
|
||||
|
||||
// Assert
|
||||
Assert.Contains("CapturedImages", result);
|
||||
Assert.Contains(expectedDate, result);
|
||||
Assert.Contains(programName, result);
|
||||
Assert.StartsWith(_tempDir, result);
|
||||
}
|
||||
|
||||
// ── Test: SaveImageAsync sanitizes node name in file path ─────────────
|
||||
|
||||
[Fact]
|
||||
public async Task SaveImageAsync_SanitizesNodeName_InFilePath()
|
||||
{
|
||||
// Arrange
|
||||
var imageData = new byte[] { 0x42, 0x4D };
|
||||
var unsafeNodeName = "Node:With*Invalid?Chars";
|
||||
|
||||
// Act
|
||||
var result = await _service.SaveImageAsync(imageData, unsafeNodeName, "Program1");
|
||||
|
||||
// Assert
|
||||
Assert.True(result.Success);
|
||||
var fileName = Path.GetFileName(result.FilePath);
|
||||
Assert.DoesNotContain(":", fileName);
|
||||
Assert.DoesNotContain("*", fileName);
|
||||
Assert.DoesNotContain("?", fileName);
|
||||
Assert.Contains("Node_With_Invalid_Chars", fileName);
|
||||
}
|
||||
|
||||
// ── Test: SaveImageAsync logs on success ──────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task SaveImageAsync_LogsInfo_OnSuccess()
|
||||
{
|
||||
// Arrange
|
||||
var imageData = new byte[512];
|
||||
|
||||
// Act
|
||||
await _service.SaveImageAsync(imageData, "TestNode", "TestProgram");
|
||||
|
||||
// Assert
|
||||
_mockLogger.Verify(
|
||||
l => l.Info(It.IsAny<string>(), It.IsAny<object[]>()),
|
||||
Times.Once);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,209 @@
|
||||
#pragma warning disable xUnit1031 // FsCheck property tests require synchronous execution via GetAwaiter().GetResult()
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using System.Windows.Media;
|
||||
using System.Windows.Media.Imaging;
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
using Moq;
|
||||
using Prism.Events;
|
||||
using XP.Common.Logging.Interfaces;
|
||||
using XplorePlane.Events;
|
||||
using XplorePlane.Models;
|
||||
using XplorePlane.Services;
|
||||
using XplorePlane.Services.AppState;
|
||||
using XplorePlane.Services.Cnc;
|
||||
using XplorePlane.Services.InspectionResults;
|
||||
using XplorePlane.Services.MainViewport;
|
||||
using Xunit;
|
||||
|
||||
namespace XplorePlane.Tests.Services
|
||||
{
|
||||
/// <summary>
|
||||
/// Property 7: 进度报告包含正确的索引和总数
|
||||
/// **Validates: Requirements 3.4**
|
||||
///
|
||||
/// For any CNC program with N SavePositionNodes, the CNC_Execution_Service SHALL report
|
||||
/// progress N times (or fewer if cancelled), each report containing a 0-based position index
|
||||
/// and the total count N, with indices strictly increasing from 0.
|
||||
/// </summary>
|
||||
public class ProgressReportPropertyTests
|
||||
{
|
||||
private static (CncExecutionService Service, Mock<IMainViewportService> MainViewport)
|
||||
CreateServiceWithImage()
|
||||
{
|
||||
var mockStore = new Mock<IInspectionResultStore>();
|
||||
var mockLogger = new Mock<ILoggerService>();
|
||||
var mockMainViewportService = new Mock<IMainViewportService>();
|
||||
var mockAppStateService = new Mock<IAppStateService>();
|
||||
var mockPipelineExecutionService = new Mock<IPipelineExecutionService>();
|
||||
var mockImageProcessingService = new Mock<IImageProcessingService>();
|
||||
var mockEventAggregator = new Mock<IEventAggregator>();
|
||||
var mockImagePersistenceService = new Mock<IImagePersistenceService>();
|
||||
|
||||
mockLogger.Setup(l => l.ForModule<CncExecutionService>()).Returns(mockLogger.Object);
|
||||
|
||||
mockEventAggregator
|
||||
.Setup(ea => ea.GetEvent<DetectorDisconnectedEvent>())
|
||||
.Returns(new DetectorDisconnectedEvent());
|
||||
|
||||
mockStore.Setup(s => s.BeginRunAsync(
|
||||
It.IsAny<InspectionRunRecord>(),
|
||||
It.IsAny<InspectionAssetWriteRequest>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.AppendNodeResultAsync(
|
||||
It.IsAny<InspectionNodeResult>(),
|
||||
It.IsAny<IEnumerable<InspectionMetricResult>>(),
|
||||
It.IsAny<PipelineExecutionSnapshot>(),
|
||||
It.IsAny<IEnumerable<InspectionAssetWriteRequest>>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.CompleteRunAsync(
|
||||
It.IsAny<Guid>(),
|
||||
It.IsAny<bool?>(),
|
||||
It.IsAny<DateTime?>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
// Provide a valid image so that image acquisition succeeds
|
||||
var dummyImage = CreateDummyBitmap();
|
||||
mockMainViewportService.SetupGet(m => m.LatestManualImage).Returns((ImageSource)null);
|
||||
mockMainViewportService.SetupGet(m => m.CurrentDisplayImage).Returns(dummyImage);
|
||||
|
||||
// Image persistence returns success
|
||||
mockImagePersistenceService.Setup(s => s.SaveImageAsync(
|
||||
It.IsAny<byte[]>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(new ImageSaveResult(true, @"C:\test\image.bmp", 1024));
|
||||
|
||||
mockImagePersistenceService.Setup(s => s.WriteSummaryAsync(
|
||||
It.IsAny<BatchCaptureResult>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(true);
|
||||
|
||||
var service = new CncExecutionService(
|
||||
mockStore.Object,
|
||||
mockLogger.Object,
|
||||
mockMainViewportService.Object,
|
||||
mockAppStateService.Object,
|
||||
mockPipelineExecutionService.Object,
|
||||
mockImageProcessingService.Object,
|
||||
mockEventAggregator.Object,
|
||||
mockImagePersistenceService.Object);
|
||||
|
||||
return (service, mockMainViewportService);
|
||||
}
|
||||
|
||||
private static BitmapSource CreateDummyBitmap()
|
||||
{
|
||||
var stride = 4 * 4; // 4 pixels wide, 4 bytes per pixel
|
||||
var pixels = new byte[stride * 4]; // 4x4 image
|
||||
var bitmap = BitmapSource.Create(4, 4, 96, 96, PixelFormats.Bgra32, null, pixels, stride);
|
||||
bitmap.Freeze();
|
||||
return bitmap;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generates a CncProgram with N SavePositionNodes (N between 1 and 10),
|
||||
/// each with unique ascending indices.
|
||||
/// </summary>
|
||||
private static Arbitrary<CncProgram> SavePositionProgramArb()
|
||||
{
|
||||
var gen =
|
||||
from count in Gen.Choose(1, 10)
|
||||
from name in ArbMap.Default.GeneratorFor<NonEmptyString>().Select(s => s.Get)
|
||||
from nodes in GenSavePositionNodes(count)
|
||||
select new CncProgram(
|
||||
Guid.NewGuid(), name,
|
||||
DateTime.UtcNow, DateTime.UtcNow,
|
||||
nodes.AsReadOnly());
|
||||
return gen.ToArbitrary();
|
||||
}
|
||||
|
||||
private static Gen<List<CncNode>> GenSavePositionNodes(int count)
|
||||
{
|
||||
Gen<List<CncNode>> acc = Gen.Constant(new List<CncNode>());
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
var idx = i;
|
||||
acc = from list in acc
|
||||
from nodeName in ArbMap.Default.GeneratorFor<NonEmptyString>().Select(s => s.Get)
|
||||
let node = new SavePositionNode(
|
||||
Guid.NewGuid(), idx, $"Pos_{nodeName}_{idx}",
|
||||
MotionState.Default, SaveImage: false)
|
||||
select new List<CncNode>(list) { node };
|
||||
}
|
||||
return acc;
|
||||
}
|
||||
|
||||
// ── Property 7: 进度报告包含正确的索引和总数 ──────────────────────────
|
||||
|
||||
// Feature: cnc-multi-position-image-capture, Property 7: 进度报告包含正确的索引和总数
|
||||
// Validates: Requirements 3.4
|
||||
[Property(MaxTest = 100)]
|
||||
public Property ProgressReports_ContainCorrectIndexAndTotal()
|
||||
{
|
||||
return Prop.ForAll(
|
||||
SavePositionProgramArb(),
|
||||
program =>
|
||||
{
|
||||
var (service, _) = CreateServiceWithImage();
|
||||
|
||||
var savePositionCount = program.Nodes.OfType<SavePositionNode>().Count();
|
||||
|
||||
// Capture all progress reports that have PositionIndex set (Running state)
|
||||
var runningReports = new List<(int PositionIndex, int TotalPositions)>();
|
||||
var progress = new SynchronousProgress<CncNodeExecutionProgress>(p =>
|
||||
{
|
||||
if (p.State == NodeExecutionState.Running
|
||||
&& p.PositionIndex.HasValue
|
||||
&& p.TotalPositions.HasValue)
|
||||
{
|
||||
runningReports.Add((p.PositionIndex.Value, p.TotalPositions.Value));
|
||||
}
|
||||
});
|
||||
|
||||
service.ExecuteAsync(program, progress, CancellationToken.None)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
// Verify: at least N Running progress reports (one per position)
|
||||
if (runningReports.Count < savePositionCount)
|
||||
return false;
|
||||
|
||||
// Verify: all TotalPositions values equal N
|
||||
if (runningReports.Any(r => r.TotalPositions != savePositionCount))
|
||||
return false;
|
||||
|
||||
// Verify: PositionIndex values in Running reports are strictly increasing from 0
|
||||
// Extract unique position indices in order of first appearance
|
||||
var seenIndices = new List<int>();
|
||||
foreach (var report in runningReports)
|
||||
{
|
||||
if (seenIndices.Count == 0 || seenIndices.Last() != report.PositionIndex)
|
||||
seenIndices.Add(report.PositionIndex);
|
||||
}
|
||||
|
||||
// Must have exactly N distinct position indices
|
||||
if (seenIndices.Count != savePositionCount)
|
||||
return false;
|
||||
|
||||
// Indices must be 0, 1, 2, ..., N-1
|
||||
for (int i = 0; i < savePositionCount; i++)
|
||||
{
|
||||
if (seenIndices[i] != i)
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,384 @@
|
||||
#pragma warning disable xUnit1031 // FsCheck property tests require synchronous execution via GetAwaiter().GetResult()
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using System.Windows.Media;
|
||||
using System.Windows.Media.Imaging;
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
using Moq;
|
||||
using Prism.Events;
|
||||
using XP.Common.Logging.Interfaces;
|
||||
using XplorePlane.Events;
|
||||
using XplorePlane.Models;
|
||||
using XplorePlane.Services;
|
||||
using XplorePlane.Services.AppState;
|
||||
using XplorePlane.Services.Cnc;
|
||||
using XplorePlane.Services.InspectionResults;
|
||||
using XplorePlane.Services.MainViewport;
|
||||
using Xunit;
|
||||
|
||||
namespace XplorePlane.Tests.Services
|
||||
{
|
||||
/// <summary>
|
||||
/// Property 9: 运行摘要字段完整性与一致性
|
||||
/// Validates: Requirements 4.1, 4.2
|
||||
///
|
||||
/// For any completed (non-cancelled) batch execution with known position results,
|
||||
/// the generated BatchCaptureResult SHALL satisfy:
|
||||
/// SucceededPositions + FailedPositions == TotalPositions,
|
||||
/// and a position is marked "Success" if and only if its image capture completed
|
||||
/// AND its inspection pipeline (if present) executed without error.
|
||||
/// </summary>
|
||||
public class SummaryCorrectnessPropertyTests
|
||||
{
|
||||
/// <summary>
|
||||
/// Creates a CncExecutionService with mocks configured for multi-position testing.
|
||||
/// Returns the service and the mock for IImagePersistenceService to capture WriteSummaryAsync calls.
|
||||
/// The failurePattern parameter controls which positions fail image acquisition (detector returns null).
|
||||
/// The pipelineFailurePattern controls which positions fail pipeline execution.
|
||||
/// </summary>
|
||||
private static (CncExecutionService Service, Mock<IImagePersistenceService> ImagePersistence)
|
||||
CreateServiceWithFailurePatterns(
|
||||
bool[] imageAcquisitionFailures,
|
||||
bool[] pipelineFailures)
|
||||
{
|
||||
var mockStore = new Mock<IInspectionResultStore>();
|
||||
var mockLogger = new Mock<ILoggerService>();
|
||||
var mockMainViewportService = new Mock<IMainViewportService>();
|
||||
var mockAppStateService = new Mock<IAppStateService>();
|
||||
var mockPipelineExecutionService = new Mock<IPipelineExecutionService>();
|
||||
var mockImageProcessingService = new Mock<IImageProcessingService>();
|
||||
var mockEventAggregator = new Mock<IEventAggregator>();
|
||||
var mockImagePersistenceService = new Mock<IImagePersistenceService>();
|
||||
|
||||
mockLogger.Setup(l => l.ForModule<CncExecutionService>()).Returns(mockLogger.Object);
|
||||
|
||||
mockEventAggregator
|
||||
.Setup(ea => ea.GetEvent<DetectorDisconnectedEvent>())
|
||||
.Returns(new DetectorDisconnectedEvent());
|
||||
|
||||
mockStore.Setup(s => s.BeginRunAsync(
|
||||
It.IsAny<InspectionRunRecord>(),
|
||||
It.IsAny<InspectionAssetWriteRequest>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.AppendNodeResultAsync(
|
||||
It.IsAny<InspectionNodeResult>(),
|
||||
It.IsAny<IEnumerable<InspectionMetricResult>>(),
|
||||
It.IsAny<PipelineExecutionSnapshot>(),
|
||||
It.IsAny<IEnumerable<InspectionAssetWriteRequest>>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
mockStore.Setup(s => s.CompleteRunAsync(
|
||||
It.IsAny<Guid>(),
|
||||
It.IsAny<bool?>(),
|
||||
It.IsAny<DateTime?>()))
|
||||
.Returns(Task.CompletedTask);
|
||||
|
||||
// Track which position index is being processed to control failure patterns
|
||||
int callIndex = 0;
|
||||
|
||||
// Control image acquisition: when imageAcquisitionFailures[i] is true,
|
||||
// the detector returns null for that position (causing failure).
|
||||
// We use LatestManualImage to provide/deny images.
|
||||
mockMainViewportService
|
||||
.Setup(m => m.LatestManualImage)
|
||||
.Returns(() =>
|
||||
{
|
||||
// Return null to simulate detector failure for positions marked to fail
|
||||
return null;
|
||||
});
|
||||
|
||||
mockMainViewportService
|
||||
.Setup(m => m.CurrentDisplayImage)
|
||||
.Returns(() => null);
|
||||
|
||||
// Use AppStateService.LatestDetectorFrame to control image availability per position
|
||||
// We'll use a sequence-based approach via callback
|
||||
var positionCallCount = 0;
|
||||
mockAppStateService
|
||||
.Setup(a => a.LatestDetectorFrame)
|
||||
.Returns(() =>
|
||||
{
|
||||
int currentPos = positionCallCount++;
|
||||
if (currentPos < imageAcquisitionFailures.Length && imageAcquisitionFailures[currentPos])
|
||||
{
|
||||
// Return null frame to simulate acquisition failure
|
||||
return null;
|
||||
}
|
||||
// Return a valid frame
|
||||
return new DetectorFrame
|
||||
{
|
||||
ImageData = new ushort[4],
|
||||
Width = 2,
|
||||
Height = 2
|
||||
};
|
||||
});
|
||||
|
||||
// Control pipeline execution: throw exception for positions marked to fail
|
||||
var pipelineCallCount = 0;
|
||||
mockPipelineExecutionService
|
||||
.Setup(p => p.ExecutePipelineAsync(
|
||||
It.IsAny<IEnumerable<PipelineNodeViewModel>>(),
|
||||
It.IsAny<BitmapSource>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.Returns<IEnumerable<PipelineNodeViewModel>, BitmapSource, CancellationToken>((nodes, img, ct) =>
|
||||
{
|
||||
int currentPipelinePos = pipelineCallCount++;
|
||||
if (currentPipelinePos < pipelineFailures.Length && pipelineFailures[currentPipelinePos])
|
||||
{
|
||||
throw new Exception("Simulated pipeline failure");
|
||||
}
|
||||
return Task.FromResult(img);
|
||||
});
|
||||
|
||||
// Image persistence always succeeds
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.SaveImageAsync(
|
||||
It.IsAny<byte[]>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(new ImageSaveResult(true, "C:\\test\\image.bmp", 1024));
|
||||
|
||||
mockImagePersistenceService
|
||||
.Setup(s => s.WriteSummaryAsync(
|
||||
It.IsAny<BatchCaptureResult>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.ReturnsAsync(true);
|
||||
|
||||
var service = new CncExecutionService(
|
||||
mockStore.Object,
|
||||
mockLogger.Object,
|
||||
mockMainViewportService.Object,
|
||||
mockAppStateService.Object,
|
||||
mockPipelineExecutionService.Object,
|
||||
mockImageProcessingService.Object,
|
||||
mockEventAggregator.Object,
|
||||
mockImagePersistenceService.Object);
|
||||
|
||||
return (service, mockImagePersistenceService);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generates a list of SavePositionNodes with optional trailing InspectionModuleNodes.
|
||||
/// </summary>
|
||||
private static Gen<(List<CncNode> Nodes, bool[] HasInspection)> GenSavePositionProgram(int count)
|
||||
{
|
||||
return from hasInspections in Gen.ListOf(count, ArbMap.Default.GeneratorFor<bool>())
|
||||
let nodes = BuildNodes(count, hasInspections.ToArray())
|
||||
select (nodes, hasInspections.ToArray());
|
||||
}
|
||||
|
||||
private static List<CncNode> BuildNodes(int positionCount, bool[] hasInspection)
|
||||
{
|
||||
var nodes = new List<CncNode>();
|
||||
int index = 0;
|
||||
for (int i = 0; i < positionCount; i++)
|
||||
{
|
||||
var spNode = new SavePositionNode(
|
||||
Guid.NewGuid(),
|
||||
index,
|
||||
$"Position_{i}",
|
||||
MotionState.Default,
|
||||
SaveImage: true,
|
||||
ManualImagePath: "");
|
||||
nodes.Add(spNode);
|
||||
index++;
|
||||
|
||||
if (i < hasInspection.Length && hasInspection[i])
|
||||
{
|
||||
var inspNode = new InspectionModuleNode(
|
||||
Guid.NewGuid(),
|
||||
index,
|
||||
$"Inspect_{i}",
|
||||
new PipelineModel { Name = $"Pipeline_{i}" });
|
||||
nodes.Add(inspNode);
|
||||
index++;
|
||||
}
|
||||
}
|
||||
return nodes;
|
||||
}
|
||||
|
||||
// ── Property 9: 运行摘要字段完整性与一致性 ──────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// **Validates: Requirements 4.1, 4.2**
|
||||
///
|
||||
/// For any completed (non-cancelled) batch execution:
|
||||
/// SucceededPositions + FailedPositions == TotalPositions == N
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property Summary_SucceededPlusFailedEqualsTotalPositions()
|
||||
{
|
||||
// Generate 1-8 positions with random failure patterns
|
||||
var gen =
|
||||
from posCount in Gen.Choose(1, 8)
|
||||
from imageFailures in Gen.ListOf(posCount, Gen.Elements(true, false))
|
||||
from pipelineFailures in Gen.ListOf(posCount, Gen.Elements(true, false))
|
||||
from hasInspections in Gen.ListOf(posCount, ArbMap.Default.GeneratorFor<bool>())
|
||||
select new
|
||||
{
|
||||
PositionCount = posCount,
|
||||
ImageFailures = imageFailures.ToArray(),
|
||||
PipelineFailures = pipelineFailures.ToArray(),
|
||||
HasInspections = hasInspections.ToArray()
|
||||
};
|
||||
|
||||
return Prop.ForAll(
|
||||
gen.ToArbitrary(),
|
||||
testCase =>
|
||||
{
|
||||
var nodes = BuildNodes(testCase.PositionCount, testCase.HasInspections);
|
||||
var program = new CncProgram(
|
||||
Guid.NewGuid(),
|
||||
"TestProgram",
|
||||
DateTime.UtcNow,
|
||||
DateTime.UtcNow,
|
||||
nodes.AsReadOnly());
|
||||
|
||||
// Build pipeline failure pattern: only positions with inspections can have pipeline failures
|
||||
// Map pipeline failures to only those positions that have an inspection node following them
|
||||
var effectivePipelineFailures = new bool[testCase.PositionCount];
|
||||
for (int i = 0; i < testCase.PositionCount; i++)
|
||||
{
|
||||
effectivePipelineFailures[i] = testCase.HasInspections[i] && testCase.PipelineFailures[i];
|
||||
}
|
||||
|
||||
var (service, mockImagePersistence) = CreateServiceWithFailurePatterns(
|
||||
testCase.ImageFailures,
|
||||
effectivePipelineFailures);
|
||||
|
||||
// Capture the BatchCaptureResult passed to WriteSummaryAsync
|
||||
BatchCaptureResult capturedResult = null;
|
||||
mockImagePersistence
|
||||
.Setup(s => s.WriteSummaryAsync(
|
||||
It.IsAny<BatchCaptureResult>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.Callback<BatchCaptureResult, string, CancellationToken>((result, _, _) =>
|
||||
{
|
||||
capturedResult = result;
|
||||
})
|
||||
.ReturnsAsync(true);
|
||||
|
||||
service.ExecuteAsync(program, null, CancellationToken.None)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
// Verify invariants
|
||||
if (capturedResult == null)
|
||||
return false;
|
||||
|
||||
// Invariant 1: SucceededPositions + FailedPositions == TotalPositions
|
||||
bool sumCorrect = capturedResult.SucceededPositions + capturedResult.FailedPositions
|
||||
== capturedResult.TotalPositions;
|
||||
|
||||
// Invariant 2: TotalPositions == N (number of SavePositionNodes)
|
||||
bool totalCorrect = capturedResult.TotalPositions == testCase.PositionCount;
|
||||
|
||||
// Invariant 3: Status == "Completed" (not cancelled)
|
||||
bool statusCorrect = capturedResult.Status == "Completed";
|
||||
|
||||
// Invariant 4: Each position's Status matches whether it succeeded or failed
|
||||
bool positionsCorrect = capturedResult.Positions.Count == testCase.PositionCount;
|
||||
if (positionsCorrect)
|
||||
{
|
||||
int succeededCount = capturedResult.Positions.Count(p => p.Status == "Success");
|
||||
int failedCount = capturedResult.Positions.Count(p => p.Status == "Failed");
|
||||
positionsCorrect = succeededCount == capturedResult.SucceededPositions
|
||||
&& failedCount == capturedResult.FailedPositions;
|
||||
}
|
||||
|
||||
return sumCorrect && totalCorrect && statusCorrect && positionsCorrect;
|
||||
});
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// **Validates: Requirements 4.1, 4.2**
|
||||
///
|
||||
/// A position is marked "Success" if and only if its image capture completed
|
||||
/// AND its inspection pipeline (if present) executed without error.
|
||||
/// A position with image acquisition failure must be "Failed".
|
||||
/// </summary>
|
||||
[Property(MaxTest = 100)]
|
||||
public Property Summary_PositionStatusReflectsActualOutcome()
|
||||
{
|
||||
var gen =
|
||||
from posCount in Gen.Choose(1, 6)
|
||||
from imageFailures in Gen.ListOf(posCount, Gen.Elements(true, false))
|
||||
from pipelineFailures in Gen.ListOf(posCount, Gen.Elements(true, false))
|
||||
from hasInspections in Gen.ListOf(posCount, ArbMap.Default.GeneratorFor<bool>())
|
||||
select new
|
||||
{
|
||||
PositionCount = posCount,
|
||||
ImageFailures = imageFailures.ToArray(),
|
||||
PipelineFailures = pipelineFailures.ToArray(),
|
||||
HasInspections = hasInspections.ToArray()
|
||||
};
|
||||
|
||||
return Prop.ForAll(
|
||||
gen.ToArbitrary(),
|
||||
testCase =>
|
||||
{
|
||||
var nodes = BuildNodes(testCase.PositionCount, testCase.HasInspections);
|
||||
var program = new CncProgram(
|
||||
Guid.NewGuid(),
|
||||
"TestProgram",
|
||||
DateTime.UtcNow,
|
||||
DateTime.UtcNow,
|
||||
nodes.AsReadOnly());
|
||||
|
||||
var effectivePipelineFailures = new bool[testCase.PositionCount];
|
||||
for (int i = 0; i < testCase.PositionCount; i++)
|
||||
{
|
||||
effectivePipelineFailures[i] = testCase.HasInspections[i] && testCase.PipelineFailures[i];
|
||||
}
|
||||
|
||||
var (service, mockImagePersistence) = CreateServiceWithFailurePatterns(
|
||||
testCase.ImageFailures,
|
||||
effectivePipelineFailures);
|
||||
|
||||
BatchCaptureResult capturedResult = null;
|
||||
mockImagePersistence
|
||||
.Setup(s => s.WriteSummaryAsync(
|
||||
It.IsAny<BatchCaptureResult>(),
|
||||
It.IsAny<string>(),
|
||||
It.IsAny<CancellationToken>()))
|
||||
.Callback<BatchCaptureResult, string, CancellationToken>((result, _, _) =>
|
||||
{
|
||||
capturedResult = result;
|
||||
})
|
||||
.ReturnsAsync(true);
|
||||
|
||||
service.ExecuteAsync(program, null, CancellationToken.None)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
if (capturedResult == null || capturedResult.Positions.Count != testCase.PositionCount)
|
||||
return false;
|
||||
|
||||
// Verify each position's status matches expected outcome
|
||||
for (int i = 0; i < testCase.PositionCount; i++)
|
||||
{
|
||||
var posResult = capturedResult.Positions[i];
|
||||
bool imageAcquired = !testCase.ImageFailures[i];
|
||||
bool pipelineFailed = effectivePipelineFailures[i];
|
||||
|
||||
// A position is "Success" iff image capture completed AND pipeline (if present) succeeded
|
||||
bool expectedSuccess = imageAcquired && !pipelineFailed;
|
||||
string expectedStatus = expectedSuccess ? "Success" : "Failed";
|
||||
|
||||
if (posResult.Status != expectedStatus)
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2,6 +2,8 @@
|
||||
// Validates: Requirements 6.1, 6.2
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.ComponentModel;
|
||||
using FsCheck;
|
||||
using FsCheck.Fluent;
|
||||
using FsCheck.Xunit;
|
||||
@@ -65,5 +67,65 @@ namespace XplorePlane.Tests.ViewModels
|
||||
return runningOk && succeededOk && failedOk && idleOk;
|
||||
});
|
||||
}
|
||||
|
||||
#region ManualImagePath Binding Tests - Validates: Requirements 2.4
|
||||
|
||||
[Fact]
|
||||
public void BrowseImageCommand_IsNotNull_AndCanExecute()
|
||||
{
|
||||
// Arrange
|
||||
var node = new SavePositionNode(Guid.NewGuid(), 0, "Pos_0", MotionState.Default);
|
||||
var vm = new CncNodeViewModel(node, (_, __) => { });
|
||||
|
||||
// Act & Assert
|
||||
Assert.NotNull(vm.BrowseImageCommand);
|
||||
Assert.True(vm.BrowseImageCommand.CanExecute(null));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ManualImagePath_Set_RaisesPropertyChangedNotification()
|
||||
{
|
||||
// Arrange
|
||||
var node = new SavePositionNode(Guid.NewGuid(), 0, "Pos_0", MotionState.Default);
|
||||
var vm = new CncNodeViewModel(node, (_, __) => { });
|
||||
var changedProperties = new List<string>();
|
||||
((INotifyPropertyChanged)vm).PropertyChanged += (_, e) => changedProperties.Add(e.PropertyName);
|
||||
|
||||
// Act
|
||||
vm.ManualImagePath = @"C:\Images\test.bmp";
|
||||
|
||||
// Assert
|
||||
Assert.Contains(nameof(vm.ManualImagePath), changedProperties);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ManualImagePath_Getter_ReturnsValueFromUnderlyingModel()
|
||||
{
|
||||
// Arrange
|
||||
var expectedPath = @"D:\TestImages\sample.png";
|
||||
var node = new SavePositionNode(Guid.NewGuid(), 0, "Pos_0", MotionState.Default, ManualImagePath: expectedPath);
|
||||
var vm = new CncNodeViewModel(node, (_, __) => { });
|
||||
|
||||
// Act & Assert
|
||||
Assert.Equal(expectedPath, vm.ManualImagePath);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ManualImagePath_Set_UpdatesUnderlyingModel()
|
||||
{
|
||||
// Arrange
|
||||
var node = new SavePositionNode(Guid.NewGuid(), 0, "Pos_0", MotionState.Default);
|
||||
var vm = new CncNodeViewModel(node, (_, __) => { });
|
||||
var newPath = @"C:\Images\updated.tiff";
|
||||
|
||||
// Act
|
||||
vm.ManualImagePath = newPath;
|
||||
|
||||
// Assert
|
||||
var updatedNode = Assert.IsType<SavePositionNode>(vm.Model);
|
||||
Assert.Equal(newPath, updatedNode.ManualImagePath);
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user