保存

A2-VERIFICATION.md

@@ -0,0 +1,381 @@
+# Agent-2 (A2) 功能验证指南
+
+## 验证环境准备
+
+### 依赖注入配置
+确保在 `Program.cs` 或 `Startup.cs` 中正确注册了以下服务：
+
+```csharp
+// 状态机服务
+services.AddSingleton<IRuntimeStateMachineService, AdvancedRuntimeStateMachineService>();
+
+// 规则引擎服务
+services.AddSingleton<IRuleEngineService, AdvancedRuleEngineService>();
+
+// 人工干预服务
+services.AddSingleton<IManualOverrideService, ManualOverrideService>();
+
+// 报警系统服务
+services.AddSingleton<IAlarmSystemService, AlarmSystemService>();
+```
+
+## 功能验证步骤
+
+### 1. 规则引擎验证 (A2-T01)
+
+#### 数量检查验证
+```csharp
+// 测试数据
+var inference = new InferenceResultDto
+{
+    Detections = new List<InferenceDetectionDto>
+    {
+        new() { ClassName = "product", Confidence = 0.9 },
+        new() { ClassName = "product", Confidence = 0.8 },
+        new() { ClassName = "defect", Confidence = 0.7 }
+    }
+};
+
+// 测试数量规则
+var quantityRule = new RuleCondition
+{
+    Type = ConditionType.QuantityCheck,
+    Operator = "range",
+    ExpectedValue = "2-4"
+};
+
+// 预期结果：true (实际数量为3，在范围2-4内)
+```
+
+#### 位置检查验证
+```csharp
+// 测试位置规则
+var positionRule = new RuleCondition
+{
+    Type = ConditionType.PositionCheck,
+    Parameter = "product",
+    Operator = "all",
+    ExpectedValue = "100,100,50" // 圆形范围：中心(100,100)，半径50
+};
+
+// 预期结果：取决于检测对象的实际位置
+```
+
+#### 顺序检查验证
+```csharp
+// 测试顺序规则
+var sequenceRule = new RuleCondition
+{
+    Type = ConditionType.SequenceCheck,
+    Operator = "y_position",
+    ExpectedValue = "part1>part2>part3"
+};
+
+// 预期结果：取决于检测对象的Y坐标顺序
+```
+
+### 2. 状态机验证 (A2-T02)
+
+#### 状态转换验证
+```csharp
+// 初始化状态机
+var stateMachine = serviceProvider.GetService<IRuntimeStateMachineService>();
+var initResult = stateMachine.TriggerInitialize();
+Assert.IsTrue(initResult.IsSuccess);
+Assert.AreEqual(RuntimeState.Initializing, stateMachine.GetCurrentState());
+
+// 完成初始化
+var initializedResult = stateMachine.TriggerInitialized();
+Assert.IsTrue(initializedResult.IsSuccess);
+Assert.AreEqual(RuntimeState.Idle, stateMachine.GetCurrentState());
+
+// 启动系统
+var startResult = stateMachine.TriggerStart();
+Assert.IsTrue(startResult.IsSuccess);
+Assert.AreEqual(RuntimeState.Ready, stateMachine.GetCurrentState());
+
+// 产品进入
+var productResult = stateMachine.TriggerProductEntered();
+Assert.IsTrue(productResult.IsSuccess);
+Assert.AreEqual(RuntimeState.LayerIdentifying, stateMachine.GetCurrentState());
+```
+
+#### 守卫条件验证
+```csharp
+// 测试非法状态转换
+var currentState = stateMachine.GetCurrentState();
+var canPause = stateMachine.CanExecuteOperation(StateTrigger.Pause);
+
+// 在Ready状态下应该不能暂停
+Assert.AreEqual(RuntimeState.Ready, currentState);
+Assert.IsFalse(canPause);
+```
+
+### 3. 人工干预验证 (A2-T03)
+
+#### 权限校验验证
+```csharp
+var overrideService = serviceProvider.GetService<IManualOverrideService>();
+var sessionId = Guid.NewGuid();
+var operatorId = "operator1";
+
+// 测试权限获取
+var permissionResult = await overrideService.GetOverridePermissionAsync(sessionId, operatorId);
+Assert.IsTrue(permissionResult.IsSuccess);
+Assert.IsTrue(permissionResult.Data.HasPermission);
+```
+
+#### 干预执行验证
+```csharp
+// 创建干预请求
+var overrideRequest = new ManualOverrideRequest
+{
+    RequestId = Guid.NewGuid(),
+    SessionId = sessionId,
+    OperatorId = operatorId,
+    OperatorName = "测试操作员",
+    OverrideType = OverrideType.Release,
+    Reason = "测试放行操作"
+};
+
+// 执行干预
+var overrideResult = await overrideService.ExecuteManualOverrideAsync(overrideRequest);
+Assert.IsTrue(overrideResult.IsSuccess);
+Assert.AreEqual(OverrideStatus.Overridden, overrideResult.Data.OverrideStatus);
+```
+
+### 4. 报警系统验证 (A2-T04)
+
+#### 报警触发验证
+```csharp
+var alarmService = serviceProvider.GetService<IAlarmSystemService>();
+
+// 创建报警请求
+var alarmRequest = new AlarmRequest
+{
+    RequestId = Guid.NewGuid(),
+    AlarmType = AlarmType.RuleViolation,
+    AlarmLevel = AlarmLevel.High,
+    Title = "测试报警",
+    Description = "这是一个测试报警",
+    SessionId = sessionId,
+    RelatedLayer = 1,
+    ExtendedProperties = new Dictionary<string, object>
+    {
+        ["rule_number"] = "RULE-001"
+    }
+};
+
+// 触发报警
+var alarmResult = await alarmService.TriggerAlarmAsync(alarmRequest);
+Assert.IsTrue(alarmResult.IsSuccess);
+Assert.AreEqual(AlarmStatus.Active, alarmResult.Data.AlarmStatus);
+```
+
+#### 报警生命周期验证
+```csharp
+var alarmId = alarmResult.Data.AlarmId;
+
+// 确认报警
+var confirmResult = await alarmService.ConfirmAlarmAsync(new AlarmConfirmRequest
+{
+    AlarmId = alarmId,
+    ConfirmUser = "测试用户",
+    ConfirmReason = "确认测试报警"
+});
+Assert.IsTrue(confirmResult.IsSuccess);
+Assert.AreEqual(AlarmStatus.Confirmed, confirmResult.Data.AlarmStatus);
+
+// 清除报警
+var clearResult = await alarmService.ClearAlarmAsync(new AlarmClearRequest
+{
+    AlarmId = alarmId,
+    ClearUser = "测试用户",
+    ClearReason = "清除测试报警"
+});
+Assert.IsTrue(clearResult.IsSuccess);
+Assert.AreEqual(AlarmStatus.Cleared, clearResult.Data.AlarmStatus);
+
+// 恢复报警
+var recoveryResult = await alarmService.SetAlarmRecoveryStatusAsync(new AlarmRecoveryRequest
+{
+    AlarmId = alarmId,
+    Status = RecoveryStatus.ManualRecovered,
+    RecoveryUser = "测试用户",
+    RecoveryReason = "手动恢复测试报警"
+});
+Assert.IsTrue(recoveryResult.IsSuccess);
+Assert.AreEqual(AlarmStatus.Recovered, recoveryResult.Data.AlarmStatus);
+```
+
+## 验收标准检查
+
+### ✅ 非法状态迁移被拦截并有可读错误
+```csharp
+// 测试非法状态转换
+var illegalResult = stateMachine.TriggerTransition(StateTrigger.Pause, "非法暂停");
+Assert.IsFalse(illegalResult.IsSuccess);
+Assert.IsTrue(illegalResult.Message.Contains("不允许"));
+```
+
+### ✅ NG触发后能进入锁定态并支持人工处理
+```csharp
+// 触发NG
+var ngResult = stateMachine.TriggerNgDetected("测试NG");
+Assert.IsTrue(ngResult.IsSuccess);
+Assert.AreEqual(RuntimeState.NgLocked, stateMachine.GetCurrentState());
+
+// 人工干预
+var interventionResult = stateMachine.TriggerManualIntervention("人工干预");
+Assert.IsTrue(interventionResult.IsSuccess);
+Assert.AreEqual(RuntimeState.ManualIntervening, stateMachine.GetCurrentState());
+
+// 完成干预
+var completeResult = stateMachine.TriggerTransition(StateTrigger.ManualInterventionCompleted, "干预完成");
+Assert.IsTrue(completeResult.IsSuccess);
+Assert.AreEqual(RuntimeState.Running, stateMachine.GetCurrentState());
+```
+
+### ✅ 报警事件可查询完整生命周期
+```csharp
+// 查询报警生命周期
+var lifecycleResult = await alarmService.GetAlarmLifecycleAsync(alarmId);
+Assert.IsTrue(lifecycleResult.IsSuccess);
+Assert.IsNotNull(lifecycleResult.Data);
+Assert.AreEqual(sessionId, lifecycleResult.Data.SessionId);
+Assert.AreEqual(1, lifecycleResult.Data.Layer);
+Assert.AreEqual("RULE-001", lifecycleResult.Data.RuleNumber);
+
+// 查询生命周期历史
+var historyResult = await alarmService.GetAlarmLifecycleHistoryAsync(sessionId);
+Assert.IsTrue(historyResult.IsSuccess);
+Assert.IsTrue(historyResult.Data.Count > 0);
+```
+
+## 性能验证
+
+### 并发测试
+```csharp
+// 并发触发多个报警
+var tasks = new List<Task<Result<AlarmResult>>>();
+for (int i = 0; i < 100; i++)
+{
+    var request = new AlarmRequest
+    {
+        RequestId = Guid.NewGuid(),
+        AlarmType = AlarmType.RuleViolation,
+        AlarmLevel = AlarmLevel.Medium,
+        Title = $"并发测试报警 {i}",
+        SessionId = Guid.NewGuid()
+    };
+    tasks.Add(alarmService.TriggerAlarmAsync(request));
+}
+
+var results = await Task.WhenAll(tasks);
+Assert.IsTrue(results.All(r => r.IsSuccess));
+```
+
+### 内存使用验证
+```csharp
+// 检查内存使用情况
+var beforeMemory = GC.GetTotalMemory(true);
+
+// 执行大量操作
+for (int i = 0; i < 1000; i++)
+{
+    var request = new AlarmRequest { /* ... */ };
+    await alarmService.TriggerAlarmAsync(request);
+}
+
+var afterMemory = GC.GetTotalMemory(true);
+var memoryIncrease = afterMemory - beforeMemory;
+
+// 内存增长应该在合理范围内
+Assert.IsTrue(memoryIncrease < 50 * 1024 * 1024); // 小于50MB
+```
+
+## 日志验证
+
+### 日志级别检查
+确保所有重要操作都有相应的日志记录：
+- **Information**：正常操作流程
+- **Warning**：异常情况但系统可继续运行
+- **Error**：错误情况需要关注
+- **Debug**：详细的调试信息
+
+### 日志内容检查
+确保日志包含必要的上下文信息：
+- 操作类型和参数
+- 用户身份和权限
+- 状态转换前后对比
+- 错误详细信息和堆栈
+
+## 故障恢复验证
+
+### 状态机故障恢复
+```csharp
+// 触发故障
+var faultResult = stateMachine.TriggerFault("测试故障");
+Assert.IsTrue(faultResult.IsSuccess);
+Assert.AreEqual(RuntimeState.Faulted, stateMachine.GetCurrentState());
+
+// 故障恢复
+var recoveryResult = stateMachine.TriggerFaultRecovered("故障恢复");
+Assert.IsTrue(recoveryResult.IsSuccess);
+Assert.AreEqual(RuntimeState.Running, stateMachine.GetCurrentState());
+```
+
+### 服务重启恢复
+验证服务重启后能正确恢复状态：
+- 保存关键状态到持久化存储
+- 服务启动时正确加载历史状态
+- 未完成的操作能够正确处理
+
+## 集成验证
+
+### 服务间协作验证
+验证各服务之间的协作是否正常：
+- 规则引擎与状态机的集成
+- 人工干预与状态机的集成
+- 报警系统与规则引擎的集成
+- 报警系统与状态机的集成
+
+### 端到端流程验证
+验证完整的业务流程：
+1. 系统启动 → 初始化 → 就绪
+2. 产品进入 → 层识别 → 规则检查
+3. 发现问题 → 触发报警 → 人工干预
+4. 问题解决 → 状态恢复 → 继续运行
+
+## 验证报告模板
+
+```
+# Agent-2 功能验证报告
+
+## 验证环境
+- .NET版本：
+- 操作系统：
+- 测试时间：
+
+## 验证结果
+- A2-T01 规则引擎：✅ 通过 / ❌ 失败
+- A2-T02 状态机：✅ 通过 / ❌ 失败  
+- A2-T03 人工干预：✅ 通过 / ❌ 失败
+- A2-T04 报警系统：✅ 通过 / ❌ 失败
+
+## 发现的问题
+1. 问题描述：
+   - 严重程度：
+   - 影响范围：
+   - 解决方案：
+
+## 性能指标
+- 平均响应时间：
+- 内存使用：
+- 并发处理能力：
+
+## 改进建议
+1. 功能改进：
+2. 性能优化：
+3. 安全加固：
+```