#

Junjie

10 小时以前 26784989e73fc36c6315e54939d1b13a50eb5020

 src/test/java/com/zy/core/utils/StationOperateProcessUtilsReroutePipelineTest.java

@@ -1,8 +1,12 @@
package com.zy.core.utils;

import com.zy.asrs.entity.BasStationOpt;
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.entity.BasStation;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.BasStationService;
import com.zy.asrs.service.BasStationOptService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.service.WrkAnalysisService;
import com.zy.asrs.utils.NotifyUtils;
@@ -25,6 +29,7 @@
import org.junit.jupiter.api.Test;
import org.springframework.test.util.ReflectionTestUtils;

import java.util.Date;
import java.util.Collections;
import java.util.List;
import java.util.Map;
@@ -39,12 +44,21 @@
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.same;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class StationOperateProcessUtilsReroutePipelineTest {

    @SuppressWarnings("unchecked")
    private void stubTaskDispatchLock(StationMoveCoordinator coordinator) {
        when(coordinator.withTaskDispatchLock(any(), any())).thenAnswer(invocation -> {
            java.util.function.Supplier<Object> supplier = invocation.getArgument(1);
            return supplier == null ? null : supplier.get();
        });
    }

    @Test
    void choosesRunBlockCommandBuilderForRunBlockRerouteScene() {
@@ -178,6 +192,7 @@
        StationOperateProcessUtils utils = new StationOperateProcessUtils();
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        stubTaskDispatchLock(coordinator);
        ReflectionTestUtils.setField(utils, "stationMoveCoordinator", coordinator);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);

@@ -219,13 +234,97 @@
    }

    @Test
    void checkStationOutOrder_skipsWhenBlockedSessionAlreadyOwnsCurrentStation() {
    void idleRecover_skipsWhenCurrentStationIsStillInsideRecentlyIssuedActiveRoute() {
        StationOperateProcessUtils utils = new StationOperateProcessUtils();
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        stubTaskDispatchLock(coordinator);
        ReflectionTestUtils.setField(utils, "stationMoveCoordinator", coordinator);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);

        StationMoveSession session = new StationMoveSession();
        session.setStatus(StationMoveSession.STATUS_RUNNING);
        session.setDispatchStationId(196);
        session.setCurrentStationId(189);
        session.setFullPathStationIds(List.of(196, 195, 189, 121, 124));
        session.setLastIssuedAt(System.currentTimeMillis());
        when(coordinator.loadSession(10510)).thenReturn(session);

        StationCommand command = new StationCommand();
        command.setTaskNo(10510);
        command.setStationId(121);
        command.setTargetStaNo(124);

        StationOperateProcessUtils.RerouteContext context = StationOperateProcessUtils.RerouteContext.create(
                StationOperateProcessUtils.RerouteSceneType.IDLE_RECOVER,
                buildBasDevp(1),
                mock(StationThread.class),
                buildStationProtocol(121, 10510, 121),
                buildWrkMast(10510, 124),
                Collections.emptyList(),
                0.0d,
                "checkStationIdleRecover"
        ).withRecentDispatchGuard();

        StationOperateProcessUtils.RerouteExecutionResult result = utils.executeReroutePlan(
                context,
                StationOperateProcessUtils.RerouteCommandPlan.dispatch(
                        command,
                        StationOperateProcessUtils.RerouteDecision.proceed(124),
                        "checkStationIdleRecover"
                )
        );

        assertTrue(result.skipped());
        assertEquals("recent-dispatch", result.skipReason());
        verify(coordinator, never()).cancelSession(10510);
    }

    @Test
    void idleRecover_skipsWhenStationCommandLogShowsRecentIssuedMove() {
        StationOperateProcessUtils utils = new StationOperateProcessUtils();
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        BasStationOptService basStationOptService = mock(BasStationOptService.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        stubTaskDispatchLock(coordinator);
        ReflectionTestUtils.setField(utils, "stationMoveCoordinator", coordinator);
        ReflectionTestUtils.setField(utils, "basStationOptService", basStationOptService);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);

        StationMoveSession session = new StationMoveSession();
        session.setStatus(StationMoveSession.STATUS_RUNNING);
        session.setDispatchStationId(136);
        session.setCurrentStationId(145);
        session.setFullPathStationIds(List.of(136, 137, 139, 142, 143, 145, 148, 149, 151));
        session.setLastIssuedAt(System.currentTimeMillis() - 20_000L);
        when(coordinator.loadSession(10493)).thenReturn(session);

        BasStationOpt recentOpt = new BasStationOpt();
        recentOpt.setTaskNo(10493);
        recentOpt.setStationId(148);
        recentOpt.setSend(1);
        recentOpt.setMode(String.valueOf(com.zy.core.enums.StationCommandType.MOVE));
        recentOpt.setSendTime(new Date());
        when(basStationOptService.list(any(com.baomidou.mybatisplus.core.conditions.Wrapper.class)))
                .thenReturn(Collections.singletonList(recentOpt));

        Boolean skipped = ReflectionTestUtils.invokeMethod(utils,
                "shouldSkipIdleRecoverForRecentDispatch",
                10493,
                148);

        assertTrue(Boolean.TRUE.equals(skipped));
    }

    @Test
    void checkStationOutOrder_skipsWhenActiveSessionAlreadyOwnsCurrentStation() {
        StationOperateProcessUtils utils = new StationOperateProcessUtils();
        BasDevpService basDevpService = mock(BasDevpService.class);
        WrkMastService wrkMastService = mock(WrkMastService.class);
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        StationThread stationThread = mock(StationThread.class);
        stubTaskDispatchLock(coordinator);

        ReflectionTestUtils.setField(utils, "basDevpService", basDevpService);
        ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
@@ -240,6 +339,69 @@
        StationProtocol stationProtocol = buildStationProtocol(145, 10337, 145);
        stationProtocol.setAutoing(true);
        stationProtocol.setLoading(true);
        when(stationThread.getStatusMap()).thenReturn(Map.of(145, stationProtocol));

        StationCommand command = new StationCommand();
        command.setTaskNo(10337);
        command.setStationId(145);
        command.setTargetStaNo(111);
        when(stationThread.getCommand(eq(com.zy.core.enums.StationCommandType.MOVE), eq(10337), eq(145), eq(111), eq(0), eq(0.0d)))
                .thenReturn(command);

        WrkMast wrkMast = buildWrkMast(10337, 111);
        wrkMast.setWrkSts(WrkStsType.STATION_RUN.sts);
        wrkMast.setIoType(WrkIoType.OUT.id);
        when(wrkMastService.selectByWorkNo(10337)).thenReturn(wrkMast);

        StationMoveSession session = new StationMoveSession();
        session.setTaskNo(10337);
        session.setStatus(StationMoveSession.STATUS_RUNNING);
        session.setDispatchMode(StationMoveDispatchMode.CIRCLE);
        session.setCurrentStationId(145);
        session.setCurrentRouteTargetStationId(148);
        session.setNextDecisionStationId(148);
        session.setFullPathStationIds(List.of(145, 148, 149, 151, 119, 118, 117, 115, 114, 111));
        when(coordinator.loadSession(10337)).thenReturn(session);

        when(redisUtil.get(anyString())).thenReturn(null);

        MessageQueue.init(SlaveType.Devp, 1);
        SlaveConnection.put(SlaveType.Devp, 1, stationThread);
        try {
            utils.checkStationOutOrder();

            assertNull(MessageQueue.peek(SlaveType.Devp, 1));
            verify(stationThread, never()).getCommand(eq(com.zy.core.enums.StationCommandType.MOVE), eq(10337), eq(145), eq(111), eq(0), eq(0.0d));
        } finally {
            MessageQueue.clear(SlaveType.Devp, 1);
            SlaveConnection.remove(SlaveType.Devp, 1);
        }
    }

    @Test
    void checkStationOutOrder_restartsWhenBlockedSessionExistsButStationNoLongerRunBlock() {
        StationOperateProcessUtils utils = new StationOperateProcessUtils();
        BasDevpService basDevpService = mock(BasDevpService.class);
        WrkMastService wrkMastService = mock(WrkMastService.class);
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        StationThread stationThread = mock(StationThread.class);
        stubTaskDispatchLock(coordinator);

        ReflectionTestUtils.setField(utils, "basDevpService", basDevpService);
        ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
        ReflectionTestUtils.setField(utils, "stationMoveCoordinator", coordinator);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);

        BasDevp basDevp = buildBasDevp(1);
        basDevp.setIsOutOrderList("[{\"deviceNo\":1,\"stationId\":145}]");
        when(basDevpService.list(any(com.baomidou.mybatisplus.core.conditions.Wrapper.class)))
                .thenReturn(Collections.singletonList(basDevp));

        StationProtocol stationProtocol = buildStationProtocol(145, 10337, 145);
        stationProtocol.setAutoing(true);
        stationProtocol.setLoading(true);
        stationProtocol.setRunBlock(false);
        when(stationThread.getStatusMap()).thenReturn(Map.of(145, stationProtocol));

        StationCommand command = new StationCommand();
@@ -271,8 +433,8 @@
        try {
            utils.checkStationOutOrder();

            assertNull(MessageQueue.peek(SlaveType.Devp, 1));
            verify(stationThread, never()).getCommand(eq(com.zy.core.enums.StationCommandType.MOVE), eq(10337), eq(145), eq(111), eq(0), eq(0.0d));
            assertTrue(MessageQueue.peek(SlaveType.Devp, 1) != null);
            verify(stationThread, times(1)).getCommand(eq(com.zy.core.enums.StationCommandType.MOVE), eq(10337), eq(145), eq(111), eq(0), eq(0.0d));
        } finally {
            MessageQueue.clear(SlaveType.Devp, 1);
            SlaveConnection.remove(SlaveType.Devp, 1);
@@ -330,10 +492,13 @@
    }

    @Test
    void executePlan_runBlockReroute_skipsWhenBlockedSessionMatchesCandidatePath() {
    void executePlan_runBlockReroute_reissuesWhenBlockedSessionMatchesCandidatePath() {
        StationOperateProcessUtils utils = new StationOperateProcessUtils();
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        stubTaskDispatchLock(coordinator);
        ReflectionTestUtils.setField(utils, "stationMoveCoordinator", coordinator);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);

        StationCommand command = new StationCommand();
        command.setTaskNo(100);
@@ -374,9 +539,112 @@
                    )
            );

            assertTrue(result.skipped());
            assertEquals("run-block-same-path", result.skipReason());
            verify(coordinator, never()).cancelSession(100);
            assertTrue(!result.skipped());
            org.mockito.InOrder inOrder = inOrder(coordinator);
            inOrder.verify(coordinator).markCancelPending(100, "reroute_pending");
            inOrder.verify(coordinator).cancelSession(100);
            verify(coordinator, times(1)).cancelSession(100);
        } finally {
            MessageQueue.clear(SlaveType.Devp, 1);
        }
    }

    @Test
    void executePlan_runBlockReroute_ignoresCurrentTaskBufferAfterReset() {
        StationOperateProcessUtils utils = new StationOperateProcessUtils();
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        stubTaskDispatchLock(coordinator);
        ReflectionTestUtils.setField(utils, "stationMoveCoordinator", coordinator);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);

        StationCommand command = new StationCommand();
        command.setTaskNo(10388);
        command.setStationId(186);
        command.setTargetStaNo(124);
        command.setNavigatePath(List.of(186, 189, 121, 124));
        command.setOriginalNavigatePath(List.of(186, 189, 121, 124));

        StationTaskBufferItem bufferItem = new StationTaskBufferItem();
        bufferItem.setTaskNo(10388);

        when(redisUtil.get(anyString())).thenReturn(null);

        StationOperateProcessUtils.RerouteContext context = StationOperateProcessUtils.RerouteContext.create(
                StationOperateProcessUtils.RerouteSceneType.RUN_BLOCK_REROUTE,
                buildBasDevp(1),
                mock(StationThread.class),
                buildStationProtocol(186, 10388, 189, Collections.singletonList(bufferItem)),
                buildWrkMast(10388, 124),
                Collections.emptyList(),
                0.0d,
                "checkStationRunBlock_reroute"
        ).withCancelSessionBeforeDispatch()
                .withResetSegmentCommandsBeforeDispatch();

        MessageQueue.init(SlaveType.Devp, 1);
        try {
            StationOperateProcessUtils.RerouteExecutionResult result = utils.executeReroutePlan(
                    context,
                    StationOperateProcessUtils.RerouteCommandPlan.dispatch(
                            command,
                            StationOperateProcessUtils.RerouteDecision.proceed(124),
                            "checkStationRunBlock_reroute"
                    )
            );

            assertTrue(!result.skipped());
            verify(coordinator, times(1)).cancelSession(10388);
        } finally {
            MessageQueue.clear(SlaveType.Devp, 1);
        }
    }

    @Test
    void executePlan_runBlockReroute_bypassesSuppressDispatchAfterReset() {
        StationOperateProcessUtils utils = new StationOperateProcessUtils();
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        stubTaskDispatchLock(coordinator);
        ReflectionTestUtils.setField(utils, "stationMoveCoordinator", coordinator);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);

        StationCommand command = new StationCommand();
        command.setTaskNo(10388);
        command.setStationId(186);
        command.setTargetStaNo(124);
        command.setNavigatePath(List.of(186, 124));
        command.setOriginalNavigatePath(List.of(186, 124));

        when(redisUtil.get(anyString())).thenReturn(null);
        when(coordinator.shouldSuppressDispatch(10388, 186, command)).thenReturn(true);

        StationOperateProcessUtils.RerouteContext context = StationOperateProcessUtils.RerouteContext.create(
                StationOperateProcessUtils.RerouteSceneType.RUN_BLOCK_REROUTE,
                buildBasDevp(1),
                mock(StationThread.class),
                buildStationProtocol(186, 10388, 186),
                buildWrkMast(10388, 124),
                Collections.emptyList(),
                0.0d,
                "checkStationRunBlock_reroute"
        ).withSuppressDispatchGuard()
                .withCancelSessionBeforeDispatch()
                .withResetSegmentCommandsBeforeDispatch();

        MessageQueue.init(SlaveType.Devp, 1);
        try {
            StationOperateProcessUtils.RerouteExecutionResult result = utils.executeReroutePlan(
                    context,
                    StationOperateProcessUtils.RerouteCommandPlan.dispatch(
                            command,
                            StationOperateProcessUtils.RerouteDecision.proceed(124),
                            "checkStationRunBlock_reroute"
                    )
            );

            assertTrue(!result.skipped());
            verify(coordinator, times(1)).cancelSession(10388);
        } finally {
            MessageQueue.clear(SlaveType.Devp, 1);
        }
@@ -392,6 +660,7 @@
        WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        StationThread stationThread = mock(StationThread.class);
        stubTaskDispatchLock(coordinator);

        ReflectionTestUtils.setField(utils, "basDevpService", basDevpService);
        ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
@@ -452,6 +721,7 @@
        NotifyUtils notifyUtils = mock(NotifyUtils.class);
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        StationThread stationThread = mock(StationThread.class);
        stubTaskDispatchLock(coordinator);

        ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);
@@ -498,6 +768,53 @@
    }

    @Test
    void stationOutExecuteFinish_attemptsClearPathBeforeCompletingTask() {
        StationOperateProcessUtils utils = new StationOperateProcessUtils();
        WrkMastService wrkMastService = mock(WrkMastService.class);
        BasStationService basStationService = mock(BasStationService.class);
        WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
        NotifyUtils notifyUtils = mock(NotifyUtils.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        StationThread stationThread = mock(StationThread.class);

        ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
        ReflectionTestUtils.setField(utils, "basStationService", basStationService);
        ReflectionTestUtils.setField(utils, "wrkAnalysisService", wrkAnalysisService);
        ReflectionTestUtils.setField(utils, "notifyUtils", notifyUtils);
        ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);
        ReflectionTestUtils.setField(utils, "stationMoveCoordinator", coordinator);

        WrkMast wrkMast = buildWrkMast(10335, 145);
        wrkMast.setWrkSts(WrkStsType.STATION_RUN.sts);
        when(wrkMastService.list(any(com.baomidou.mybatisplus.core.conditions.Wrapper.class)))
                .thenReturn(Collections.singletonList(wrkMast));
        when(wrkMastService.updateById(wrkMast)).thenReturn(true);

        BasStation basStation = new BasStation();
        basStation.setStationId(145);
        basStation.setDeviceNo(1);
        when(basStationService.getOne(any(com.baomidou.mybatisplus.core.conditions.Wrapper.class)))
                .thenReturn(basStation);

        StationProtocol stationProtocol = buildStationProtocol(145, 10335, 145);
        when(stationThread.getStatusMap()).thenReturn(Map.of(145, stationProtocol));
        when(stationThread.clearPath(10335)).thenReturn(true);

        SlaveConnection.put(SlaveType.Devp, 1, stationThread);
        try {
            utils.stationOutExecuteFinish();

            verify(stationThread, times(1)).clearPath(10335);
            verify(coordinator, times(1)).finishSession(10335);
            verify(wrkMastService, times(1)).updateById(wrkMast);
            assertEquals(WrkStsType.STATION_RUN_COMPLETE.sts, wrkMast.getWrkSts());
        } finally {
            SlaveConnection.remove(SlaveType.Devp, 1);
        }
    }

    @Test
    void watchCircleStation_usesSessionArrivalStateWhenLegacyCommandMissing() {
        StationOperateProcessUtils utils = new StationOperateProcessUtils();
        BasDevpService basDevpService = mock(BasDevpService.class);
@@ -505,6 +822,7 @@
        StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
        RedisUtil redisUtil = mock(RedisUtil.class);
        StationThread stationThread = mock(StationThread.class);
        stubTaskDispatchLock(coordinator);

        ReflectionTestUtils.setField(utils, "basDevpService", basDevpService);
        ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);