移除接收区间补采与完整性旧链路

yeg

2026-09-02 74f55db1acd945f4860b2d0b4bae48e2b918b32b

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

@@ -3,6 +3,7 @@
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;
@@ -15,6 +16,8 @@
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;
@@ -28,6 +31,7 @@
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;

@@ -221,6 +225,20 @@
    }

    @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));
    }

    @Test
    void createShouldRejectBatteriesFromDifferentGroups()
    {
        TTest test = validTest();
@@ -350,6 +368,195 @@
        verify(testMapper).insertTestAudit(eq(10L), eq("TEST_DELETED"), eq(7L), eq("operator"), any(), isNull());
    }

    @Test
    void startReceptionShouldPersistReceptionWithoutLegacyIntervals()
    {
        TTest current = validTest();
        current.setTestId(10L);
        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.collectorOnline(8L)).thenReturn(true);
        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.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.collectorOnline(8L)).thenReturn(true);
        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.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.collectorOnline(8L)).thenReturn(true);
        when(testMapper.updateReceptionStarted(eq(10L), any(), anyBoolean(), eq("operator"))).thenReturn(1);

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

    }

    @Test
    void startReceptionShouldRejectOfflineSourceWithoutWritingAnything()
    {
        TTest current = validTest();
        current.setTestId(10L);
        current.setReceptionStatus("NOT_STARTED");
        when(testMapper.selectTestByIdForUpdate(10L)).thenReturn(current);
        TDetectionChannel channel = new TDetectionChannel();
        channel.setChannelId(100L);
        channel.setOnlineStatus("OFFLINE");
        when(testMapper.selectReceptionChannelForUpdate(100L)).thenReturn(channel);

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

        assertEquals("检测柜通道 100 当前离线或不可观测", exception.getMessage());
        verify(testMapper, never()).updateReceptionStarted(any(), any(), anyBoolean(), any());
    }

    @Test
    void startReceptionShouldRejectIncompleteCollectorMappingsBeforeWriting()
    {
        TTest current = validTest();
        current.setTestId(10L);
        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.collectorOnline(8L)).thenReturn(true);
        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 pauseReceptionShouldStopPollingAndAppendAudit()
    {
        TTest current = validTest();
        current.setTestId(10L);
        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.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.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, never()).deleteChannelLeasesByTestId(anyLong());
        verify(testMapper, never()).deleteCollectorChannelLeasesByTestId(anyLong());
        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.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()
    {
        mockEnabledPeopleAndType();