完成测试生命周期与接收边界

yeg

2026-09-05 acfb83068486766f63284b479d30f78e3ec17dca

 ruoyi-admin/src/test/java/com/ruoyi/system/service/impl/TTestServiceImplTest.java

@@ -3,17 +3,22 @@
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.times;

import java.math.BigDecimal;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.time.Instant;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
@@ -23,9 +28,13 @@
import com.ruoyi.system.domain.TTest;
import com.ruoyi.system.domain.TTestBattery;
import com.ruoyi.system.domain.TTestChannelBinding;
import com.ruoyi.system.domain.TTestCollectorChannel;
import com.ruoyi.system.domain.TTestFieldSnapshot;
import com.ruoyi.system.domain.TTestPlanStep;
import com.ruoyi.system.domain.TTestWarningThreshold;
import com.ruoyi.system.domain.TDetectionChannel;
import com.ruoyi.system.mapper.TTestMapper;
import com.ruoyi.system.service.ISharedFieldSnapshotService;

/** 测试配置服务的业务契约测试。 */
@ExtendWith(MockitoExtension.class)
@@ -33,6 +42,9 @@
{
    @Mock
    private TTestMapper testMapper;

    @Mock
    private ISharedFieldSnapshotService sharedFieldSnapshotService;

    @InjectMocks
    private TTestServiceImpl testService;
@@ -53,34 +65,65 @@

        assertEquals(10L, testService.createTest(test));
        assertEquals("WAITING", test.getTestStatus());
        assertEquals("NOT_MONITORED", test.getMonitoringStatus());
        assertEquals("NOT_STARTED", test.getReceptionStatus());
        assertEquals(7L, test.getCreatorId());
        verify(testMapper).insertTestPlanStep(any(TTestPlanStep.class));
        verify(testMapper, never()).insertTestPlanStep(any(TTestPlanStep.class));
        verify(testMapper).insertTestChannelBinding(any(TTestChannelBinding.class));
        verify(testMapper, times(3)).insertTestCollectorChannel(any(TTestCollectorChannel.class));
        verify(sharedFieldSnapshotService, never()).saveForTest(anyLong(), any());
        verify(testMapper).insertTestThreshold(any(TTestWarningThreshold.class));
        verify(testMapper).insertTestAudit(anyLong(), any(), anyLong(), any(), isNull(), any());
        verify(testMapper, never()).insertTestAudit(anyLong(), any(), anyLong(), any(), isNull(), any());
    }

    @Test
    void createShouldAllowMissingCollector()
    void listShouldAggregateBatteryNumbersOutsideDatabaseQuery()
    {
        TTest first = new TTest();
        first.setTestId(10L);
        TTest second = new TTest();
        second.setTestId(11L);
        TTestBattery firstBattery = new TTestBattery();
        firstBattery.setTestId(10L);
        firstBattery.setBatteryNo("BAT-001");
        TTestBattery secondBattery = new TTestBattery();
        secondBattery.setTestId(10L);
        secondBattery.setBatteryNo("BAT-002");
        when(testMapper.selectTestList(any(TTest.class))).thenReturn(java.util.List.of(first, second));
        when(testMapper.selectBatteryNosByTestIds(java.util.List.of(10L, 11L)))
                .thenReturn(java.util.List.of(firstBattery, secondBattery));

        java.util.List<TTest> result = testService.selectTestList(new TTest());

        assertEquals("BAT-001、BAT-002", result.get(0).getBatteryNo());
        assertEquals("", result.get(1).getBatteryNo());
    }

    @Test
    void createShouldRejectMissingCollector()
    {
        TTest test = validTest();
        test.getBatteries().get(0).setCollectorId(null);
        mockEnabledPeopleAndType();
        when(testMapper.countBatteryInEnabledGroup(1L, "BAT-001")).thenReturn(1);
        when(testMapper.countRegisteredChannel(100L)).thenReturn(1);
        when(testMapper.insertTest(any(TTest.class))).thenAnswer(invocation -> {
            invocation.<TTest>getArgument(0).setTestId(10L);
            return 1;
        });
        doAnswer(invocation -> {
            invocation.<TTestBattery>getArgument(0).setRelationId(20L);
            return 1;
        }).when(testMapper).insertTestBattery(any(TTestBattery.class));

        assertEquals(10L, testService.createTest(test));
        ServiceException exception = assertThrows(ServiceException.class, () -> testService.createTest(test));

        verify(testMapper, never()).countCollectorEnabled(anyLong());
        assertEquals("采集器不能为空", exception.getMessage());
        verify(testMapper, never()).insertTest(any(TTest.class));
    }

    @Test
    void createShouldRejectMissingRequiredCollectorChannel()
    {
        TTest test = validTest();
        test.getBatteries().get(0).getCollectorChannels().remove(0);
        mockEnabledOptions();

        ServiceException exception = assertThrows(ServiceException.class, () -> testService.createTest(test));

        assertEquals("每个电池号必须绑定主温度、正电位主通道和负电位主通道", exception.getMessage());
        verify(testMapper, never()).insertTest(any(TTest.class));
    }

    @Test
@@ -152,10 +195,45 @@
        when(testMapper.countBatteryInEnabledGroup(1L, "BAT-002")).thenReturn(1);
        when(testMapper.countRegisteredChannel(100L)).thenReturn(1);
        when(testMapper.countCollectorEnabled(8L)).thenReturn(1);
        when(testMapper.selectCollectorChannelCount(8L)).thenReturn(4);

        ServiceException exception = assertThrows(ServiceException.class, () -> testService.createTest(test));

        assertEquals("同一检测柜通道不可重复绑定", exception.getMessage());
        verify(testMapper, never()).insertTest(any(TTest.class));
    }

    @Test
    void createShouldRejectDuplicateCollectorChannelMapping()
    {
        TTest test = validTest();
        TTestBattery second = validBattery("BAT-002", 2L, 101L);
        test.setBatteries(java.util.List.of(test.getBatteries().get(0), second));
        mockEnabledPeopleAndType();
        when(testMapper.countBatteryInEnabledGroup(1L, "BAT-001")).thenReturn(1);
        when(testMapper.countBatteryInEnabledGroup(1L, "BAT-002")).thenReturn(1);
        when(testMapper.countRegisteredChannel(100L)).thenReturn(1);
        when(testMapper.countRegisteredChannel(101L)).thenReturn(1);
        when(testMapper.countCollectorEnabled(8L)).thenReturn(1);
        when(testMapper.selectCollectorChannelCount(8L)).thenReturn(4);

        ServiceException exception = assertThrows(ServiceException.class, () -> testService.createTest(test));

        assertEquals("同一采集器通道不可重复映射", exception.getMessage());
        verify(testMapper, never()).insertTest(any(TTest.class));
    }

    @Test
    void createShouldRejectCaseInsensitiveDuplicateCollectorMeasurement()
    {
        TTest test = validTest();
        test.getBatteries().get(0).getCollectorChannels()
                .add(collectorChannel("primary_temperature", "主温度重复", "S-04"));
        mockEnabledOptions();

        ServiceException exception = assertThrows(ServiceException.class, () -> testService.createTest(test));

        assertEquals("同一电池号的采集器测量项不可重复", exception.getMessage());
        verify(testMapper, never()).insertTest(any(TTest.class));
    }

@@ -170,6 +248,7 @@
        when(testMapper.countBatteryInEnabledGroup(1L, "BAT-001")).thenReturn(1);
        when(testMapper.countRegisteredChannel(100L)).thenReturn(1);
        when(testMapper.countCollectorEnabled(8L)).thenReturn(1);
        when(testMapper.selectCollectorChannelCount(8L)).thenReturn(4);

        ServiceException exception = assertThrows(ServiceException.class, () -> testService.createTest(test));

@@ -178,19 +257,36 @@
    }

    @Test
    void updateShouldRejectConfigurationAfterMonitoringStarted()
    void updateShouldRejectConfigurationAfterReceptionStarted()
    {
        TTest request = validTest();
        request.setTestId(10L);
        TTest current = validTest();
        current.setTestId(10L);
        current.setMonitoringStatus("MONITORING");
        current.setReceptionStatus("RECEIVING");
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);

        ServiceException exception = assertThrows(ServiceException.class, () -> testService.updateTest(request));

        assertEquals("开始监测后不能修改测试配置", exception.getMessage());
        assertEquals("开始接收后不能修改测试配置", exception.getMessage());
        verify(testMapper, never()).updateTest(any(TTest.class));
    }

    @Test
    void createShouldRejectCollectorChannelOutsideRegisteredRange()
    {
        TTest test = validTest();
        test.getBatteries().get(0).getCollectorChannels().get(2).setChannelCode("S-05");
        mockEnabledPeopleAndType();
        when(testMapper.countBatteryInEnabledGroup(1L, "BAT-001")).thenReturn(1);
        when(testMapper.countRegisteredChannel(100L)).thenReturn(1);
        when(testMapper.countCollectorEnabled(8L)).thenReturn(1);
        when(testMapper.selectCollectorChannelCount(8L)).thenReturn(4);

        ServiceException exception = assertThrows(ServiceException.class, () -> testService.createTest(test));

        assertEquals("采集器通道不存在或超出登记范围", exception.getMessage());
        verify(testMapper, never()).insertTest(any(TTest.class));
    }

    @Test
@@ -202,9 +298,10 @@
        TTest current = validTest();
        current.setTestId(10L);
        current.setCreatorId(7L);
        current.setMonitoringStatus("NOT_MONITORED");
        current.setReceptionStatus("NOT_STARTED");
        current.setMonitorTimeoutMinutes(30);
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        when(testMapper.selectTestBatteries(10L)).thenReturn(current.getBatteries());
        mockEnabledOptions();
        when(testMapper.updateTest(request)).thenReturn(1);
        doAnswer(invocation -> {
@@ -215,8 +312,37 @@
        assertEquals(1, testService.updateTest(request));
        assertEquals(45, request.getMonitorTimeoutMinutes());
        verify(testMapper).deleteTestBindingsByTestId(10L);
        verify(testMapper).deleteTestPlanStepsByTestId(10L);
        verify(testMapper).insertTestAudit(anyLong(), any(), anyLong(), any(), any(), any());
        verify(testMapper, never()).deleteTestPlanStepsByTestId(10L);
        verify(testMapper, never()).insertTestAudit(anyLong(), any(), anyLong(), any(), any(), any());
    }

    @Test
    void updateSameGroupShouldPreserveOriginalFieldSnapshot()
    {
        TTest request = validTest();
        request.setTestId(10L);
        TTest current = validTest();
        current.setTestId(10L);
        current.setCreatorId(7L);
        current.setReceptionStatus("NOT_STARTED");
        TTestFieldSnapshot originalSnapshot = new TTestFieldSnapshot();
        originalSnapshot.setFieldDefinitionId(11L);
        originalSnapshot.setFieldName("额定容量");
        originalSnapshot.setFieldType("number");
        originalSnapshot.setFieldValue("72");

        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        when(testMapper.selectTestBatteries(10L)).thenReturn(current.getBatteries());
        mockEnabledOptions();
        when(testMapper.updateTest(request)).thenReturn(1);
        doAnswer(invocation -> {
            invocation.<TTestBattery>getArgument(0).setRelationId(21L);
            return 1;
        }).when(testMapper).insertTestBattery(any(TTestBattery.class));

        assertEquals(1, testService.updateTest(request));

        verifyNoInteractions(sharedFieldSnapshotService);
    }

    @Test
@@ -224,13 +350,273 @@
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setMonitoringStatus("NOT_MONITORED");
        current.setReceptionStatus("NOT_STARTED");
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        when(testMapper.deleteTestById(10L, "operator")).thenReturn(1);

        assertEquals(1, testService.deleteTestByIds(new Long[] { 10L }, 7L, "operator"));

        verify(testMapper).insertTestAudit(eq(10L), eq("TEST_DELETED"), eq(7L), eq("operator"), any(), isNull());
        verify(testMapper, never()).insertTestAudit(anyLong(), any(), anyLong(), any(), any(), any());
    }

    @Test
    void deleteShouldRejectMismatchedTestAndReceptionStates()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("RUNNING");
        current.setReceptionStatus("NOT_STARTED");
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);

        ServiceException exception = assertThrows(ServiceException.class,
                () -> testService.deleteTestByIds(new Long[] { 10L }, 7L, "operator"));

        assertEquals("开始接收后不能删除测试", exception.getMessage());
        verify(testMapper, never()).deleteTestById(anyLong(), any(String.class));
    }

    @Test
    void startReceptionShouldPersistReceptionWithoutLegacyIntervals()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("WAITING");
        current.setReceptionStatus("NOT_STARTED");
        current.getBatteries().get(0).getBinding().setBindingId(30L);
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        TDetectionChannel channel = new TDetectionChannel();
        channel.setChannelId(100L);
        channel.setOnlineStatus("ONLINE");
        channel.setLastSeenAtUtc(Instant.parse("2026-08-29T12:00:00Z"));
        when(testMapper.selectReceptionChannelForUpdate(100L)).thenReturn(channel);
        when(testMapper.countCollectorEnabled(8L)).thenReturn(1);
        when(testMapper.selectCollectorChannelCount(8L)).thenReturn(4);
        when(testMapper.updateReceptionStarted(eq(10L), any(), anyBoolean(), eq("operator"))).thenReturn(1);

        assertEquals(1, testService.startReception(10L, 7L, "operator"));
        verify(testMapper).insertTestAudit(eq(10L), eq("RECEPTION_STARTED"), eq(7L), eq("operator"), isNull(), any());
    }

    @Test
    void startReceptionShouldMarkRunningCabinetAttachmentWithoutControlCommand()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("WAITING");
        current.setReceptionStatus("NOT_STARTED");
        current.getBatteries().get(0).getBinding().setBindingId(30L);
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        TDetectionChannel channel = new TDetectionChannel();
        channel.setChannelId(100L);
        channel.setOnlineStatus("ONLINE");
        channel.setWorkStatus("WORKING");
        channel.setLastSeenAtUtc(Instant.parse("2026-08-29T12:00:00Z"));
        when(testMapper.selectReceptionChannelForUpdate(100L)).thenReturn(channel);
        when(testMapper.countCollectorEnabled(8L)).thenReturn(1);
        when(testMapper.selectCollectorChannelCount(8L)).thenReturn(4);
        when(testMapper.updateReceptionStarted(eq(10L), any(), anyBoolean(), eq("operator"))).thenReturn(1);

        assertEquals(1, testService.startReception(10L, 7L, "operator"));
        verify(testMapper).insertTestAudit(eq(10L), eq("RECEPTION_STARTED"), eq(7L), eq("operator"), isNull(),
                org.mockito.ArgumentMatchers.argThat(value -> value != null && value.contains("runtimeAttach")
                        && value.contains("true")));
    }

    @Test
    void startReceptionShouldNotDependOnDatabaseLease()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("WAITING");
        current.setReceptionStatus("NOT_STARTED");
        current.getBatteries().get(0).getBinding().setBindingId(30L);
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        TDetectionChannel channel = new TDetectionChannel();
        channel.setChannelId(100L);
        channel.setOnlineStatus("ONLINE");
        channel.setLastSeenAtUtc(Instant.parse("2026-08-29T12:00:00Z"));
        when(testMapper.selectReceptionChannelForUpdate(100L)).thenReturn(channel);
        when(testMapper.countCollectorEnabled(8L)).thenReturn(1);
        when(testMapper.selectCollectorChannelCount(8L)).thenReturn(4);
        when(testMapper.updateReceptionStarted(eq(10L), any(), anyBoolean(), eq("operator"))).thenReturn(1);

        assertEquals(1, testService.startReception(10L, 7L, "operator"));

    }

    @Test
    void startReceptionShouldAllowOfflineSourcesWithoutBlockingReception()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("WAITING");
        current.setReceptionStatus("NOT_STARTED");
        current.getBatteries().get(0).getBinding().setBindingId(30L);
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        TDetectionChannel channel = new TDetectionChannel();
        channel.setChannelId(100L);
        channel.setOnlineStatus("OFFLINE");
        when(testMapper.selectReceptionChannelForUpdate(100L)).thenReturn(channel);
        when(testMapper.countCollectorEnabled(8L)).thenReturn(1);
        when(testMapper.selectCollectorChannelCount(8L)).thenReturn(4);
        when(testMapper.updateReceptionStarted(eq(10L), any(), anyBoolean(), eq("operator"))).thenReturn(1);

        assertEquals(1, testService.startReception(10L, 7L, "operator"));
    }

    @Test
    void startReceptionShouldAllowOfflineCollectorWithoutBlockingReception()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("WAITING");
        current.setReceptionStatus("NOT_STARTED");
        current.getBatteries().get(0).getBinding().setBindingId(30L);
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        TDetectionChannel channel = new TDetectionChannel();
        channel.setChannelId(100L);
        channel.setOnlineStatus("ONLINE");
        when(testMapper.selectReceptionChannelForUpdate(100L)).thenReturn(channel);
        when(testMapper.countCollectorEnabled(8L)).thenReturn(1);
        when(testMapper.selectCollectorChannelCount(8L)).thenReturn(4);
        when(testMapper.updateReceptionStarted(eq(10L), any(), anyBoolean(), eq("operator"))).thenReturn(1);

        assertEquals(1, testService.startReception(10L, 7L, "operator"));
    }

    @Test
    void startReceptionShouldRejectIncompleteCollectorMappingsBeforeWriting()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("WAITING");
        current.setReceptionStatus("NOT_STARTED");
        current.getBatteries().get(0).getBinding().setBindingId(30L);
        current.getBatteries().get(0).setCollectorChannels(Collections.emptyList());
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        TDetectionChannel channel = new TDetectionChannel();
        channel.setChannelId(100L);
        channel.setOnlineStatus("ONLINE");
        channel.setLastSeenAtUtc(Instant.parse("2026-08-29T12:00:00Z"));
        when(testMapper.selectReceptionChannelForUpdate(100L)).thenReturn(channel);
        when(testMapper.countCollectorEnabled(8L)).thenReturn(1);
        when(testMapper.selectCollectorChannelCount(8L)).thenReturn(4);

        ServiceException exception = assertThrows(ServiceException.class,
                () -> testService.startReception(10L, 7L, "operator"));

        assertEquals("每个电池号必须绑定主温度、正电位主通道和负电位主通道", exception.getMessage());
        verify(testMapper, never()).updateReceptionStarted(any(), any(), anyBoolean(), any());
    }

    @Test
    void startReceptionShouldRejectMissingOperatorExplicitly()
    {
        ServiceException exception = assertThrows(ServiceException.class,
                () -> testService.startReception(10L, null, "operator"));

        assertEquals("操作人不能为空", exception.getMessage());
        verify(testMapper, never()).selectTestByIdForUpdate(anyLong());
    }

    @Test
    void startReceptionShouldRejectMismatchedTestAndReceptionStates()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("COMPLETED");
        current.setReceptionStatus("NOT_STARTED");
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);

        ServiceException exception = assertThrows(ServiceException.class,
                () -> testService.startReception(10L, 7L, "operator"));

        assertEquals("当前测试不是未开始接收状态", exception.getMessage());
        verify(testMapper, never()).updateReceptionStarted(any(), any(), anyBoolean(), any());
    }

    @Test
    void pauseReceptionShouldRejectMismatchedTestAndReceptionStates()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("PAUSED");
        current.setReceptionStatus("RECEIVING");
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);

        ServiceException exception = assertThrows(ServiceException.class,
                () -> testService.pauseReception(10L, 7L, "operator"));

        assertEquals("当前测试不是接收中状态", exception.getMessage());
        verify(testMapper, never()).updateReceptionPaused(any(), any(), any());
    }

    @Test
    void pauseReceptionShouldStopPollingAndAppendAudit()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("RUNNING");
        current.setReceptionStatus("RECEIVING");
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        when(testMapper.updateReceptionPaused(eq(10L), eq("operator"), any())).thenReturn(1);

        assertEquals(1, testService.pauseReception(10L, 7L, "operator"));
        verify(testMapper).updateReceptionPaused(eq(10L), eq("operator"), any());
        verify(testMapper).insertTestAudit(eq(10L), eq("RECEPTION_PAUSED"), eq(7L), eq("operator"), isNull(),
                org.mockito.ArgumentMatchers.argThat(value -> value != null && value.contains("STOPPED")));
    }

    @Test
    void resumeReceptionShouldRestartPollingAndAppendAudit()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("PAUSED");
        current.setReceptionStatus("PAUSED");
        List<TTestBattery> configuredBatteries = current.getBatteries();
        current.setBatteries(null);
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        when(testMapper.selectTestBatteries(10L)).thenReturn(configuredBatteries);
        when(testMapper.updateReceptionResumed(eq(10L), eq("operator"), any())).thenReturn(1);

        assertEquals(1, testService.resumeReception(10L, 7L, "operator"));
        verify(testMapper).updateReceptionResumed(eq(10L), eq("operator"), any());
        verify(testMapper).insertTestAudit(eq(10L), eq("RECEPTION_RESUMED"), eq(7L), eq("operator"), isNull(),
                org.mockito.ArgumentMatchers.argThat(value -> value != null && value.contains("RESUMED")));
    }

    @Test
    void stopTestShouldCompleteWithoutLegacyLeaseCleanup()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("PAUSED");
        current.setReceptionStatus("PAUSED");
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        when(testMapper.updateReceptionStopped(eq(10L), eq("operator"), any())).thenReturn(1);

        assertEquals(1, testService.stopTest(10L, 7L, "operator"));
        verify(testMapper).updateReceptionStopped(eq(10L), eq("operator"), any());
        verify(testMapper).insertTestAudit(eq(10L), eq("TEST_STOPPED"), eq(7L), eq("operator"), isNull(),
                org.mockito.ArgumentMatchers.argThat(value -> value != null && value.contains("COMPLETED")));
    }

    @Test
    void stopTestShouldAuditImmediateStop()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setTestStatus("RUNNING");
        current.setReceptionStatus("RECEIVING");
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        when(testMapper.updateReceptionStopped(eq(10L), eq("operator"), any())).thenReturn(1);

        testService.stopTest(10L, 7L, "operator");

        verify(testMapper).insertTestAudit(eq(10L), eq("TEST_STOPPED"), eq(7L), eq("operator"), isNull(),
                org.mockito.ArgumentMatchers.argThat(value -> value != null
                        && value.contains("IMMEDIATE")));
    }

    private void mockEnabledOptions()
@@ -239,6 +625,7 @@
        when(testMapper.countBatteryInEnabledGroup(1L, "BAT-001")).thenReturn(1);
        when(testMapper.countRegisteredChannel(100L)).thenReturn(1);
        when(testMapper.countCollectorEnabled(8L)).thenReturn(1);
        when(testMapper.selectCollectorChannelCount(8L)).thenReturn(4);
    }

    private void mockEnabledPeopleAndType()
@@ -246,6 +633,16 @@
        when(testMapper.countUserEnabled(7L)).thenReturn(1);
        when(testMapper.countUserEnabled(9L)).thenReturn(1);
        when(testMapper.countTestTypeEnabled(3L)).thenReturn(1);
    }

    private void mockGroupSnapshot()
    {
        TTestFieldSnapshot snapshot = new TTestFieldSnapshot();
        snapshot.setFieldDefinitionId(11L);
        snapshot.setFieldName("额定容量");
        snapshot.setFieldType("number");
        snapshot.setFieldValue("72");
        when(sharedFieldSnapshotService.createForBatteryGroup(1L)).thenReturn(java.util.List.of(snapshot));
    }

    private TTest validTest()
@@ -276,6 +673,8 @@
        test.setPrincipalId(9L);
        test.setTestTypeId(3L);
        test.setTestPurpose("验证低温循环性能");
        test.setTestStatus("WAITING");
        test.setReceptionStatus("NOT_STARTED");
        test.setMonitorTimeoutMinutes(30);
        test.setBatteries(Collections.singletonList(validBattery("BAT-001", 1L, 100L)));
        test.setPlanSteps(Collections.singletonList(step));
@@ -295,7 +694,20 @@
        battery.setBatteryNo(batteryNo);
        battery.setCollectorId(8L);
        battery.setBinding(binding);
        battery.setCollectorChannels(new java.util.ArrayList<>(java.util.List.of(
                collectorChannel("PRIMARY_TEMPERATURE", "主温度", "S-01"),
                collectorChannel("PRIMARY_POSITIVE_POTENTIAL", "正电位主通道", "S-02"),
                collectorChannel("PRIMARY_NEGATIVE_POTENTIAL", "负电位主通道", "S-03"))));
        battery.setFields(Collections.emptyList());
        return battery;
    }

    private TTestCollectorChannel collectorChannel(String measurementCode, String measurementName, String channelCode)
    {
        TTestCollectorChannel mapping = new TTestCollectorChannel();
        mapping.setMeasurementCode(measurementCode);
        mapping.setMeasurementName(measurementName);
        mapping.setChannelCode(channelCode);
        return mapping;
    }
}