From aa710969e00e9d7e56a276066a239f74d5c49310 Mon Sep 17 00:00:00 2001
From: Junjie <fallin.jie@qq.com>
Date: 星期二, 31 三月 2026 21:47:07 +0800
Subject: [PATCH] #
---
src/test/java/com/zy/core/utils/StationOperateProcessUtilsReroutePipelineTest.java | 766 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
1 files changed, 729 insertions(+), 37 deletions(-)
diff --git a/src/test/java/com/zy/core/utils/StationOperateProcessUtilsReroutePipelineTest.java b/src/test/java/com/zy/core/utils/StationOperateProcessUtilsReroutePipelineTest.java
index 279eba5..cdc99b8 100644
--- a/src/test/java/com/zy/core/utils/StationOperateProcessUtilsReroutePipelineTest.java
+++ b/src/test/java/com/zy/core/utils/StationOperateProcessUtilsReroutePipelineTest.java
@@ -1,28 +1,57 @@
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;
+import com.zy.common.entity.FindCrnNoResult;
+import com.zy.common.service.CommonService;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.SlaveType;
import com.zy.core.enums.WrkStsType;
import com.zy.core.enums.WrkIoType;
+import com.zy.core.enums.RedisKeyType;
import com.zy.core.move.StationMoveCoordinator;
import com.zy.core.move.StationMoveDispatchMode;
import com.zy.core.move.StationMoveSession;
+import com.zy.core.dispatch.StationCommandDispatchResult;
+import com.zy.core.dispatch.StationCommandDispatcher;
import com.zy.core.model.command.StationCommand;
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.model.protocol.StationTaskBufferItem;
import com.zy.core.thread.StationThread;
import com.zy.common.utils.RedisUtil;
+import com.zy.core.utils.station.StationDispatchLoadSupport;
+import com.zy.core.utils.station.StationDispatchRuntimeStateSupport;
+import com.zy.core.utils.station.StationOutboundDecisionSupport;
+import com.zy.core.utils.station.StationOutboundDispatchProcessor;
+import com.zy.core.utils.station.StationRegularDispatchProcessor;
+import com.zy.core.utils.station.StationRerouteProcessor;
+import com.zy.core.utils.station.model.DispatchLimitConfig;
+import com.zy.core.utils.station.model.LoadGuardState;
+import com.zy.core.utils.station.model.LoopHitResult;
+import com.zy.core.utils.station.model.RerouteCommandPlan;
+import com.zy.core.utils.station.model.RerouteContext;
+import com.zy.core.utils.station.model.RerouteDecision;
+import com.zy.core.utils.station.model.RerouteExecutionResult;
+import com.zy.core.utils.station.model.RerouteSceneType;
import org.junit.jupiter.api.Test;
import org.springframework.test.util.ReflectionTestUtils;
+import java.util.Date;
import java.util.Collections;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Objects;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
@@ -31,25 +60,117 @@
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
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 {
+ private final Map<StationOperateProcessUtils, Map<String, Object>> dependencyOverrides = new IdentityHashMap<>();
+
+ private StationOperateProcessUtils newUtils() {
+ StationOperateProcessUtils utils = new StationOperateProcessUtils();
+ stash(utils, "stationOutboundDecisionSupport", new StationOutboundDecisionSupport());
+ wireRerouteProcessor(utils);
+ return utils;
+ }
+
+ private void wireOutboundSupport(StationOperateProcessUtils utils) {
+ StationOutboundDecisionSupport support = new StationOutboundDecisionSupport();
+ copyIfPresent(utils, support, "wrkMastService");
+ copyIfPresent(utils, support, "basDevpService");
+ copyIfPresent(utils, support, "basStationService");
+ copyIfPresent(utils, support, "navigateUtils");
+ copyIfPresent(utils, support, "redisUtil");
+ copyIfPresent(utils, support, "stationTaskLoopService");
+ copyIfPresent(utils, support, "stationMoveCoordinator");
+ StationDispatchRuntimeStateSupport runtimeStateSupport = new StationDispatchRuntimeStateSupport();
+ copyIfPresent(utils, runtimeStateSupport, "redisUtil");
+ copyIfPresent(utils, runtimeStateSupport, "basStationOptService");
+ ReflectionTestUtils.setField(support, "stationDispatchRuntimeStateSupport", runtimeStateSupport);
+ stash(utils, "stationOutboundDecisionSupport", support);
+ }
+
+ private void wireRerouteProcessor(StationOperateProcessUtils utils) {
+ StationRerouteProcessor processor = new StationRerouteProcessor();
+ copyIfPresent(utils, processor, "basDevpService");
+ copyIfPresent(utils, processor, "wrkMastService");
+ copyIfPresent(utils, processor, "commonService");
+ copyIfPresent(utils, processor, "redisUtil");
+ copyIfPresent(utils, processor, "locMastService");
+ copyIfPresent(utils, processor, "wmsOperateUtils");
+ copyIfPresent(utils, processor, "basStationOptService");
+ copyIfPresent(utils, processor, "stationMoveCoordinator");
+ Object dispatcher = readIfPresent(utils, "stationCommandDispatcher");
+ if (dispatcher == null) {
+ dispatcher = new StationCommandDispatcher(
+ (RedisUtil) readIfPresent(utils, "redisUtil"),
+ (StationMoveCoordinator) readIfPresent(utils, "stationMoveCoordinator")
+ );
+ }
+ ReflectionTestUtils.setField(processor, "stationCommandDispatcher", dispatcher);
+ Object outboundSupport = readIfPresent(utils, "stationOutboundDecisionSupport");
+ if (outboundSupport == null) {
+ wireOutboundSupport(utils);
+ outboundSupport = readIfPresent(utils, "stationOutboundDecisionSupport");
+ }
+ if (outboundSupport != null) {
+ ReflectionTestUtils.setField(processor, "stationOutboundDecisionSupport", outboundSupport);
+ }
+ StationDispatchRuntimeStateSupport runtimeStateSupport = new StationDispatchRuntimeStateSupport();
+ copyIfPresent(utils, runtimeStateSupport, "redisUtil");
+ copyIfPresent(utils, runtimeStateSupport, "basStationOptService");
+ ReflectionTestUtils.setField(processor, "stationDispatchRuntimeStateSupport", runtimeStateSupport);
+ ReflectionTestUtils.setField(utils, "stationRerouteProcessor", processor);
+ }
+
+ private void stash(StationOperateProcessUtils utils, String fieldName, Object value) {
+ dependencyOverrides.computeIfAbsent(utils, key -> new HashMap<>()).put(fieldName, value);
+ }
+
+ private Object readIfPresent(Object source, String fieldName) {
+ try {
+ return ReflectionTestUtils.getField(source, fieldName);
+ } catch (IllegalArgumentException ignore) {
+ if (source instanceof StationOperateProcessUtils) {
+ Map<String, Object> values = dependencyOverrides.get(source);
+ return values == null ? null : values.get(fieldName);
+ }
+ return null;
+ }
+ }
+
+ private void copyIfPresent(Object source, Object target, String fieldName) {
+ Object value = readIfPresent(source, fieldName);
+ if (value != null) {
+ try {
+ ReflectionTestUtils.setField(target, fieldName, value);
+ } catch (IllegalArgumentException ignore) {
+ }
+ }
+ }
+
+ @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() {
- StationOperateProcessUtils.RerouteSceneType scene =
- StationOperateProcessUtils.RerouteSceneType.RUN_BLOCK_REROUTE;
+ RerouteSceneType scene = RerouteSceneType.RUN_BLOCK_REROUTE;
- assertSame(StationOperateProcessUtils.RerouteSceneType.RUN_BLOCK_REROUTE, scene);
+ assertSame(RerouteSceneType.RUN_BLOCK_REROUTE, scene);
}
@Test
void resolveExecutionTarget_skipsWhenTargetEqualsCurrentStation() {
- StationOperateProcessUtils.RerouteDecision decision =
- StationOperateProcessUtils.RerouteDecision.skip("same-station");
+ RerouteDecision decision = RerouteDecision.skip("same-station");
assertTrue(decision.skip());
assertEquals("same-station", decision.skipReason());
@@ -57,7 +178,7 @@
@Test
void buildCommandPlan_usesRunBlockCommandBuilderForRunBlockScene() {
- StationOperateProcessUtils utils = new StationOperateProcessUtils();
+ StationOperateProcessUtils utils = newUtils();
StationThread stationThread = mock(StationThread.class);
StationCommand command = new StationCommand();
command.setTaskNo(100);
@@ -65,8 +186,8 @@
command.setTargetStaNo(20);
when(stationThread.getRunBlockRerouteCommand(100, 10, 20, 0, 0.25d)).thenReturn(command);
- StationOperateProcessUtils.RerouteContext context = StationOperateProcessUtils.RerouteContext.create(
- StationOperateProcessUtils.RerouteSceneType.RUN_BLOCK_REROUTE,
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.RUN_BLOCK_REROUTE,
buildBasDevp(1),
stationThread,
buildStationProtocol(10, 100, 10),
@@ -78,9 +199,9 @@
.withCancelSessionBeforeDispatch()
.withResetSegmentCommandsBeforeDispatch();
- StationOperateProcessUtils.RerouteCommandPlan plan = utils.buildRerouteCommandPlan(
+ RerouteCommandPlan plan = utils.buildRerouteCommandPlan(
context,
- StationOperateProcessUtils.RerouteDecision.proceed(20)
+ RerouteDecision.proceed(20)
);
verify(stationThread).getRunBlockRerouteCommand(100, 10, 20, 0, 0.25d);
@@ -89,7 +210,7 @@
@Test
void executePlan_skipsWhenCurrentTaskStillExistsInBuffer() {
- StationOperateProcessUtils utils = new StationOperateProcessUtils();
+ StationOperateProcessUtils utils = newUtils();
StationCommand command = new StationCommand();
command.setTaskNo(100);
command.setStationId(10);
@@ -98,8 +219,8 @@
StationTaskBufferItem bufferItem = new StationTaskBufferItem();
bufferItem.setTaskNo(100);
- StationOperateProcessUtils.RerouteContext context = StationOperateProcessUtils.RerouteContext.create(
- StationOperateProcessUtils.RerouteSceneType.OUT_ORDER,
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.OUT_ORDER,
buildBasDevp(1),
mock(StationThread.class),
buildStationProtocol(10, 100, 10, Collections.singletonList(bufferItem)),
@@ -109,11 +230,11 @@
"checkStationOutOrder"
);
- StationOperateProcessUtils.RerouteExecutionResult result = utils.executeReroutePlan(
+ RerouteExecutionResult result = utils.executeReroutePlan(
context,
- StationOperateProcessUtils.RerouteCommandPlan.dispatch(
+ RerouteCommandPlan.dispatch(
command,
- StationOperateProcessUtils.RerouteDecision.proceed(20),
+ RerouteDecision.proceed(20),
"checkStationOutOrder"
)
);
@@ -124,11 +245,11 @@
@Test
void outOrderAndWatchCircle_shareDecisionFlow() {
- StationOperateProcessUtils utils = new StationOperateProcessUtils();
+ StationOperateProcessUtils utils = newUtils();
WrkMast wrkMast = buildWrkMast(100, 20);
- StationOperateProcessUtils.RerouteContext outOrderContext = StationOperateProcessUtils.RerouteContext.create(
- StationOperateProcessUtils.RerouteSceneType.OUT_ORDER,
+ RerouteContext outOrderContext = RerouteContext.create(
+ RerouteSceneType.OUT_ORDER,
buildBasDevp(1),
mock(StationThread.class),
buildStationProtocol(10, 100, 10),
@@ -137,8 +258,8 @@
0.0d,
"checkStationOutOrder"
);
- StationOperateProcessUtils.RerouteContext watchCircleContext = StationOperateProcessUtils.RerouteContext.create(
- StationOperateProcessUtils.RerouteSceneType.WATCH_CIRCLE,
+ RerouteContext watchCircleContext = RerouteContext.create(
+ RerouteSceneType.WATCH_CIRCLE,
buildBasDevp(1),
mock(StationThread.class),
buildStationProtocol(10, 100, 10),
@@ -148,8 +269,8 @@
"watchCircleStation"
);
- StationOperateProcessUtils.RerouteDecision outOrderDecision = utils.resolveSharedRerouteDecision(outOrderContext);
- StationOperateProcessUtils.RerouteDecision watchCircleDecision = utils.resolveSharedRerouteDecision(watchCircleContext);
+ RerouteDecision outOrderDecision = utils.resolveSharedRerouteDecision(outOrderContext);
+ RerouteDecision watchCircleDecision = utils.resolveSharedRerouteDecision(watchCircleContext);
assertEquals(20, outOrderDecision.targetStationId());
assertEquals(20, watchCircleDecision.targetStationId());
@@ -157,7 +278,7 @@
@Test
void runBlockReroute_keepsDirectReassignAndNormalRerouteSeparate() {
- StationOperateProcessUtils utils = new StationOperateProcessUtils();
+ StationOperateProcessUtils utils = newUtils();
WrkMast inboundWrkMast = buildWrkMast(100, 20);
inboundWrkMast.setIoType(WrkIoType.IN.id);
@@ -167,11 +288,13 @@
@Test
void idleRecover_skipsWhenLastDispatchIsTooRecent() {
- StationOperateProcessUtils utils = new StationOperateProcessUtils();
+ StationOperateProcessUtils utils = newUtils();
StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
RedisUtil redisUtil = mock(RedisUtil.class);
- ReflectionTestUtils.setField(utils, "stationMoveCoordinator", coordinator);
- ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);
+ stubTaskDispatchLock(coordinator);
+ stash(utils, "stationMoveCoordinator", coordinator);
+ stash(utils, "redisUtil", redisUtil);
+ wireRerouteProcessor(utils);
StationMoveSession session = new StationMoveSession();
session.setStatus(StationMoveSession.STATUS_RUNNING);
@@ -185,8 +308,8 @@
command.setStationId(10);
command.setTargetStaNo(20);
- StationOperateProcessUtils.RerouteContext context = StationOperateProcessUtils.RerouteContext.create(
- StationOperateProcessUtils.RerouteSceneType.IDLE_RECOVER,
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.IDLE_RECOVER,
buildBasDevp(1),
mock(StationThread.class),
buildStationProtocol(10, 100, 10),
@@ -196,11 +319,11 @@
"checkStationIdleRecover"
).withRecentDispatchGuard();
- StationOperateProcessUtils.RerouteExecutionResult result = utils.executeReroutePlan(
+ RerouteExecutionResult result = utils.executeReroutePlan(
context,
- StationOperateProcessUtils.RerouteCommandPlan.dispatch(
+ RerouteCommandPlan.dispatch(
command,
- StationOperateProcessUtils.RerouteDecision.proceed(20),
+ RerouteDecision.proceed(20),
"checkStationIdleRecover"
)
);
@@ -211,18 +334,106 @@
}
@Test
- void checkStationOutOrder_skipsWhenBlockedSessionAlreadyOwnsCurrentStation() {
- StationOperateProcessUtils utils = new StationOperateProcessUtils();
+ void idleRecover_skipsWhenCurrentStationIsStillInsideRecentlyIssuedActiveRoute() {
+ StationOperateProcessUtils utils = newUtils();
+ StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
+ RedisUtil redisUtil = mock(RedisUtil.class);
+ stubTaskDispatchLock(coordinator);
+ stash(utils, "stationMoveCoordinator", coordinator);
+ stash(utils, "redisUtil", redisUtil);
+ wireRerouteProcessor(utils);
+
+ 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);
+
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.IDLE_RECOVER,
+ buildBasDevp(1),
+ mock(StationThread.class),
+ buildStationProtocol(121, 10510, 121),
+ buildWrkMast(10510, 124),
+ Collections.emptyList(),
+ 0.0d,
+ "checkStationIdleRecover"
+ ).withRecentDispatchGuard();
+
+ RerouteExecutionResult result = utils.executeReroutePlan(
+ context,
+ RerouteCommandPlan.dispatch(
+ command,
+ RerouteDecision.proceed(124),
+ "checkStationIdleRecover"
+ )
+ );
+
+ assertTrue(result.skipped());
+ assertEquals("recent-dispatch", result.skipReason());
+ verify(coordinator, never()).cancelSession(10510);
+ }
+
+ @Test
+ void idleRecover_skipsWhenStationCommandLogShowsRecentIssuedMove() {
+ StationOperateProcessUtils utils = newUtils();
+ StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
+ BasStationOptService basStationOptService = mock(BasStationOptService.class);
+ RedisUtil redisUtil = mock(RedisUtil.class);
+ stubTaskDispatchLock(coordinator);
+ stash(utils, "stationMoveCoordinator", coordinator);
+ stash(utils, "basStationOptService", basStationOptService);
+ stash(utils, "redisUtil", redisUtil);
+ wireRerouteProcessor(utils);
+
+ 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 = newUtils();
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);
+ stash(utils, "basDevpService", basDevpService);
ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
- ReflectionTestUtils.setField(utils, "stationMoveCoordinator", coordinator);
- ReflectionTestUtils.setField(utils, "redisUtil", redisUtil);
+ stash(utils, "stationMoveCoordinator", coordinator);
+ stash(utils, "redisUtil", redisUtil);
+ wireOutboundSupport(utils);
+ wireRerouteProcessor(utils);
BasDevp basDevp = buildBasDevp(1);
basDevp.setIsOutOrderList("[{\"deviceNo\":1,\"stationId\":145}]");
@@ -232,6 +443,71 @@
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 = newUtils();
+ 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);
+
+ stash(utils, "basDevpService", basDevpService);
+ ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
+ stash(utils, "stationMoveCoordinator", coordinator);
+ stash(utils, "redisUtil", redisUtil);
+ wireOutboundSupport(utils);
+ wireRerouteProcessor(utils);
+
+ 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();
@@ -263,6 +539,58 @@
try {
utils.checkStationOutOrder();
+ 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);
+ }
+ }
+
+ @Test
+ void checkStationOutOrder_skipsRunBlockStationBeforePlanning() {
+ StationOperateProcessUtils utils = newUtils();
+ BasDevpService basDevpService = mock(BasDevpService.class);
+ WrkMastService wrkMastService = mock(WrkMastService.class);
+ RedisUtil redisUtil = mock(RedisUtil.class);
+ StationThread stationThread = mock(StationThread.class);
+
+ stash(utils, "basDevpService", basDevpService);
+ ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
+ stash(utils, "redisUtil", redisUtil);
+ wireOutboundSupport(utils);
+ wireRerouteProcessor(utils);
+
+ 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(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);
+
+ 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 {
@@ -271,6 +599,370 @@
}
}
+ @Test
+ void executePlan_runBlockReroute_reissuesWhenBlockedSessionMatchesCandidatePath() {
+ StationOperateProcessUtils utils = newUtils();
+ StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
+ RedisUtil redisUtil = mock(RedisUtil.class);
+ stubTaskDispatchLock(coordinator);
+ stash(utils, "stationMoveCoordinator", coordinator);
+ stash(utils, "redisUtil", redisUtil);
+ wireRerouteProcessor(utils);
+
+ StationCommand command = new StationCommand();
+ command.setTaskNo(100);
+ command.setStationId(145);
+ command.setTargetStaNo(111);
+ command.setNavigatePath(List.of(145, 113, 112, 111));
+ command.setOriginalNavigatePath(List.of(145, 113, 112, 111));
+
+ StationMoveSession session = new StationMoveSession();
+ session.setTaskNo(100);
+ session.setStatus(StationMoveSession.STATUS_BLOCKED);
+ session.setCurrentStationId(145);
+ session.setDispatchStationId(145);
+ session.setPathSignature("same-path");
+ when(coordinator.loadSession(100)).thenReturn(session);
+ when(coordinator.buildPathSignature(command)).thenReturn("same-path");
+
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.RUN_BLOCK_REROUTE,
+ buildBasDevp(1),
+ mock(StationThread.class),
+ buildStationProtocol(145, 100, 145),
+ buildWrkMast(100, 111),
+ Collections.emptyList(),
+ 0.0d,
+ "checkStationRunBlock_reroute"
+ ).withCancelSessionBeforeDispatch()
+ .withResetSegmentCommandsBeforeDispatch();
+
+ MessageQueue.init(SlaveType.Devp, 1);
+ try {
+ RerouteExecutionResult result = utils.executeReroutePlan(
+ context,
+ RerouteCommandPlan.dispatch(
+ command,
+ RerouteDecision.proceed(111),
+ "checkStationRunBlock_reroute"
+ )
+ );
+
+ 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 = newUtils();
+ StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
+ RedisUtil redisUtil = mock(RedisUtil.class);
+ stubTaskDispatchLock(coordinator);
+ stash(utils, "stationMoveCoordinator", coordinator);
+ stash(utils, "redisUtil", redisUtil);
+ wireRerouteProcessor(utils);
+
+ 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);
+
+ RerouteContext context = RerouteContext.create(
+ 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 {
+ RerouteExecutionResult result = utils.executeReroutePlan(
+ context,
+ RerouteCommandPlan.dispatch(
+ command,
+ 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 = newUtils();
+ StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
+ RedisUtil redisUtil = mock(RedisUtil.class);
+ stubTaskDispatchLock(coordinator);
+ stash(utils, "stationMoveCoordinator", coordinator);
+ stash(utils, "redisUtil", redisUtil);
+ wireRerouteProcessor(utils);
+
+ 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);
+
+ RerouteContext context = RerouteContext.create(
+ 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 {
+ RerouteExecutionResult result = utils.executeReroutePlan(
+ context,
+ RerouteCommandPlan.dispatch(
+ command,
+ RerouteDecision.proceed(124),
+ "checkStationRunBlock_reroute"
+ )
+ );
+
+ assertTrue(!result.skipped());
+ verify(coordinator, times(1)).cancelSession(10388);
+ } finally {
+ MessageQueue.clear(SlaveType.Devp, 1);
+ }
+ }
+
+ @Test
+ void stationInExecute_recordsDispatchSessionAfterIssuingMoveCommand() {
+ StationOperateProcessUtils utils = newUtils();
+ BasDevpService basDevpService = mock(BasDevpService.class);
+ WrkMastService wrkMastService = mock(WrkMastService.class);
+ CommonService commonService = mock(CommonService.class);
+ RedisUtil redisUtil = mock(RedisUtil.class);
+ WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
+ StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
+ StationCommandDispatcher dispatcher = mock(StationCommandDispatcher.class);
+ StationDispatchLoadSupport loadSupport = mock(StationDispatchLoadSupport.class);
+ StationThread stationThread = mock(StationThread.class);
+ stubTaskDispatchLock(coordinator);
+
+ StationRegularDispatchProcessor processor = new StationRegularDispatchProcessor();
+ ReflectionTestUtils.setField(processor, "basDevpService", basDevpService);
+ ReflectionTestUtils.setField(processor, "wrkMastService", wrkMastService);
+ ReflectionTestUtils.setField(processor, "commonService", commonService);
+ ReflectionTestUtils.setField(processor, "redisUtil", redisUtil);
+ ReflectionTestUtils.setField(processor, "wrkAnalysisService", wrkAnalysisService);
+ ReflectionTestUtils.setField(processor, "stationMoveCoordinator", coordinator);
+ ReflectionTestUtils.setField(processor, "stationCommandDispatcher", dispatcher);
+ ReflectionTestUtils.setField(processor, "stationDispatchLoadSupport", loadSupport);
+ ReflectionTestUtils.setField(utils, "stationRegularDispatchProcessor", processor);
+
+ BasDevp basDevp = buildBasDevp(1);
+ basDevp.setBarcodeStationList("[{\"deviceNo\":1,\"stationId\":101}]");
+ when(basDevpService.list(any(com.baomidou.mybatisplus.core.conditions.Wrapper.class)))
+ .thenReturn(Collections.singletonList(basDevp));
+
+ StationProtocol stationProtocol = buildStationProtocol(101, 500670, 101);
+ stationProtocol.setAutoing(true);
+ stationProtocol.setLoading(true);
+ stationProtocol.setBarcode("GSL110005");
+ when(stationThread.getStatusMap()).thenReturn(Map.of(101, stationProtocol));
+ when(stationThread.getStatus()).thenReturn(Collections.singletonList(stationProtocol));
+
+ WrkMast wrkMast = buildWrkMast(500670, 102);
+ wrkMast.setWrkSts(WrkStsType.NEW_INBOUND.sts);
+ wrkMast.setLocNo("8-4-1");
+ when(wrkMastService.getOne(any(com.baomidou.mybatisplus.core.conditions.Wrapper.class))).thenReturn(wrkMast);
+ when(wrkMastService.updateById(wrkMast)).thenReturn(true);
+
+ FindCrnNoResult findCrnNoResult = new FindCrnNoResult();
+ findCrnNoResult.setCrnNo(4);
+ findCrnNoResult.setCrnType(SlaveType.Crn);
+ when(commonService.findCrnNoByLocNo("8-4-1")).thenReturn(findCrnNoResult);
+ when(commonService.findInStationId(findCrnNoResult, 101)).thenReturn(102);
+
+ StationCommand command = new StationCommand();
+ command.setTaskNo(500670);
+ command.setStationId(101);
+ command.setTargetStaNo(102);
+ when(stationThread.getCommand(com.zy.core.enums.StationCommandType.MOVE, 500670, 101, 102, 0))
+ .thenReturn(command);
+ when(redisUtil.get(anyString())).thenReturn(null);
+ when(dispatcher.dispatch(1, command, "station-operate-process", "stationInExecute"))
+ .thenReturn(StationCommandDispatchResult.accepted("accepted", 1, "station-operate-process", "stationInExecute"));
+
+ DispatchLimitConfig baseConfig = new DispatchLimitConfig();
+ LoadGuardState loadGuardState = new LoadGuardState();
+ LoopHitResult noHit = LoopHitResult.noHit();
+ when(loadSupport.getDispatchLimitConfig(null, null)).thenReturn(baseConfig);
+ when(loadSupport.countCurrentStationTask()).thenReturn(0);
+ when(loadSupport.buildLoadGuardState(baseConfig)).thenReturn(loadGuardState);
+ when(loadSupport.getDispatchLimitConfig(101, 102)).thenReturn(baseConfig);
+ when(loadSupport.findPathLoopHit(baseConfig, 101, 102, loadGuardState)).thenReturn(noHit);
+ when(loadSupport.isDispatchBlocked(baseConfig, 0, loadGuardState, false)).thenReturn(false);
+
+ MessageQueue.init(SlaveType.Devp, 1);
+ SlaveConnection.put(SlaveType.Devp, 1, stationThread);
+ try {
+ utils.stationInExecute();
+
+ verify(coordinator, times(1)).recordDispatch(eq(500670), eq(101), eq("stationInExecute"), same(command), eq(false));
+ } finally {
+ MessageQueue.clear(SlaveType.Devp, 1);
+ SlaveConnection.remove(SlaveType.Devp, 1);
+ }
+ }
+
+ @Test
+ void dualCrnStationOutExecute_delegatesToOutboundProcessor() {
+ StationOperateProcessUtils utils = newUtils();
+ StationOutboundDispatchProcessor processor = mock(StationOutboundDispatchProcessor.class);
+ ReflectionTestUtils.setField(utils, "stationOutboundDispatchProcessor", processor);
+
+ utils.dualCrnStationOutExecute();
+
+ verify(processor, times(1)).dualCrnStationOutExecute();
+ }
+
+ @Test
+ void stationOutExecuteFinish_attemptsClearPathBeforeCompletingTask() {
+ StationOperateProcessUtils utils = newUtils();
+ 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);
+
+ StationRegularDispatchProcessor processor = new StationRegularDispatchProcessor();
+ ReflectionTestUtils.setField(processor, "wrkMastService", wrkMastService);
+ ReflectionTestUtils.setField(processor, "basStationService", basStationService);
+ ReflectionTestUtils.setField(processor, "wrkAnalysisService", wrkAnalysisService);
+ ReflectionTestUtils.setField(processor, "notifyUtils", notifyUtils);
+ ReflectionTestUtils.setField(processor, "redisUtil", redisUtil);
+ ReflectionTestUtils.setField(processor, "stationMoveCoordinator", coordinator);
+ ReflectionTestUtils.setField(utils, "stationRegularDispatchProcessor", processor);
+
+ 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 = newUtils();
+ 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);
+
+ stash(utils, "basDevpService", basDevpService);
+ ReflectionTestUtils.setField(utils, "wrkMastService", wrkMastService);
+ stash(utils, "stationMoveCoordinator", coordinator);
+ stash(utils, "redisUtil", redisUtil);
+ wireOutboundSupport(utils);
+ wireRerouteProcessor(utils);
+
+ BasDevp basDevp = buildBasDevp(1);
+ when(basDevpService.list(any(com.baomidou.mybatisplus.core.conditions.Wrapper.class)))
+ .thenReturn(Collections.singletonList(basDevp));
+
+ StationProtocol stationProtocol = buildStationProtocol(145, 10337, 148);
+ stationProtocol.setAutoing(true);
+ stationProtocol.setLoading(true);
+ when(stationThread.getStatus()).thenReturn(Collections.singletonList(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.setDispatchStationId(145);
+ session.setNextDecisionStationId(145);
+ 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.watchCircleStation();
+
+ 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);
+ }
+ }
+
private static BasDevp buildBasDevp(int devpNo) {
BasDevp basDevp = new BasDevp();
basDevp.setDevpNo(devpNo);
--
Gitblit v1.9.1