package com.zy.core.utils.station;
|
|
import com.zy.asrs.domain.enums.NotifyMsgType;
|
import com.zy.asrs.entity.WrkMast;
|
import com.zy.asrs.service.WrkAnalysisService;
|
import com.zy.asrs.service.WrkMastService;
|
import com.zy.asrs.utils.NotifyUtils;
|
import com.zy.common.utils.RedisUtil;
|
import com.zy.core.cache.SlaveConnection;
|
import com.zy.core.dispatch.StationCommandDispatchResult;
|
import com.zy.core.dispatch.StationCommandDispatcher;
|
import com.zy.core.enums.RedisKeyType;
|
import com.zy.core.enums.SlaveType;
|
import com.zy.core.enums.WrkStsType;
|
import com.zy.core.model.StationObjModel;
|
import com.zy.core.model.command.StationCommand;
|
import com.zy.core.model.protocol.StationProtocol;
|
import com.zy.core.move.StationMoveCoordinator;
|
import com.zy.core.thread.StationThread;
|
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.OutOrderDispatchDecision;
|
import org.junit.jupiter.api.Test;
|
import org.springframework.test.util.ReflectionTestUtils;
|
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Map;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
import static org.mockito.ArgumentMatchers.any;
|
import static org.mockito.ArgumentMatchers.anyString;
|
import static org.mockito.ArgumentMatchers.eq;
|
import static org.mockito.Mockito.mock;
|
import static org.mockito.Mockito.same;
|
import static org.mockito.Mockito.times;
|
import static org.mockito.Mockito.verify;
|
import static org.mockito.Mockito.when;
|
|
class StationOutboundDispatchProcessorTest {
|
|
@Test
|
void crnStationOutExecute_recordsDispatchSessionAndClearsStationCacheAfterIssuingMoveCommand() {
|
StationOutboundDispatchProcessor processor = new StationOutboundDispatchProcessor();
|
WrkMastService wrkMastService = mock(WrkMastService.class);
|
WrkAnalysisService wrkAnalysisService = mock(WrkAnalysisService.class);
|
RedisUtil redisUtil = mock(RedisUtil.class);
|
StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
|
StationCommandDispatcher dispatcher = mock(StationCommandDispatcher.class);
|
StationDispatchLoadSupport loadSupport = mock(StationDispatchLoadSupport.class);
|
StationOutboundDecisionSupport decisionSupport = mock(StationOutboundDecisionSupport.class);
|
StationThread stationThread = mock(StationThread.class);
|
|
ReflectionTestUtils.setField(processor, "wrkMastService", wrkMastService);
|
ReflectionTestUtils.setField(processor, "wrkAnalysisService", wrkAnalysisService);
|
ReflectionTestUtils.setField(processor, "redisUtil", redisUtil);
|
ReflectionTestUtils.setField(processor, "stationMoveCoordinator", coordinator);
|
ReflectionTestUtils.setField(processor, "stationCommandDispatcher", dispatcher);
|
ReflectionTestUtils.setField(processor, "stationDispatchLoadSupport", loadSupport);
|
ReflectionTestUtils.setField(processor, "stationOutboundDecisionSupport", decisionSupport);
|
|
WrkMast wrkMast = buildWrkMast(10001, 145);
|
wrkMast.setWrkSts(WrkStsType.OUTBOUND_RUN_COMPLETE.sts);
|
wrkMast.setCrnNo(4);
|
when(wrkMastService.list(any(com.baomidou.mybatisplus.core.conditions.Wrapper.class)))
|
.thenReturn(Collections.singletonList(wrkMast));
|
when(wrkMastService.updateById(wrkMast)).thenReturn(true);
|
|
StationObjModel stationObjModel = new StationObjModel();
|
stationObjModel.setDeviceNo(1);
|
stationObjModel.setStationId(101);
|
when(redisUtil.get(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + 10001))
|
.thenReturn(com.alibaba.fastjson.JSON.toJSONString(stationObjModel));
|
when(redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + 101)).thenReturn(null);
|
|
StationProtocol stationProtocol = buildStationProtocol(101, 0, 101);
|
stationProtocol.setAutoing(true);
|
stationProtocol.setLoading(true);
|
when(stationThread.getStatusMap()).thenReturn(Map.of(101, stationProtocol));
|
|
DispatchLimitConfig limitConfig = new DispatchLimitConfig();
|
LoadGuardState loadGuardState = new LoadGuardState();
|
LoopHitResult noHit = LoopHitResult.noHit();
|
OutOrderDispatchDecision decision = OutOrderDispatchDecision.direct(145);
|
StationCommand command = buildCommand(10001, 101, 145);
|
|
when(loadSupport.getDispatchLimitConfig(null, null)).thenReturn(limitConfig);
|
when(loadSupport.countCurrentStationTask()).thenReturn(0);
|
when(loadSupport.buildLoadGuardState(limitConfig)).thenReturn(loadGuardState);
|
when(decisionSupport.getAllOutOrderList()).thenReturn(List.of(101, 121, 145));
|
when(decisionSupport.resolveOutboundPathLenFactor(wrkMast)).thenReturn(0.25d);
|
when(decisionSupport.resolveOutboundDispatchDecision(101, wrkMast, List.of(101, 121, 145), 0.25d)).thenReturn(decision);
|
when(loadSupport.getDispatchLimitConfig(101, 145)).thenReturn(limitConfig);
|
when(loadSupport.findPathLoopHit(limitConfig, 101, 145, loadGuardState, wrkMast, 0.25d)).thenReturn(noHit);
|
when(loadSupport.isDispatchBlocked(limitConfig, 0, loadGuardState, false)).thenReturn(false);
|
when(decisionSupport.buildOutboundMoveCommand(stationThread, wrkMast, 101, 145, 0.25d)).thenReturn(command);
|
when(dispatcher.dispatch(1, command, "station-operate-process", "crnStationOutExecute"))
|
.thenReturn(StationCommandDispatchResult.accepted("accepted", 1, "station-operate-process", "crnStationOutExecute"));
|
|
SlaveConnection.put(SlaveType.Devp, 1, stationThread);
|
try {
|
processor.crnStationOutExecute();
|
|
verify(wrkAnalysisService, times(1)).markOutboundStationStart(eq(wrkMast), any(Date.class));
|
verify(coordinator, times(1)).recordDispatch(eq(10001), eq(101), eq("crnStationOutExecute"), same(command), eq(false));
|
verify(redisUtil, times(1)).set(eq(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + 101), eq("lock"), eq(5L));
|
verify(redisUtil, times(1)).del(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + 10001);
|
verify(loadSupport, times(1)).saveLoopLoadReserve(10001, noHit);
|
assertEquals(WrkStsType.STATION_RUN.sts, wrkMast.getWrkSts());
|
} finally {
|
SlaveConnection.remove(SlaveType.Devp, 1);
|
}
|
}
|
|
@Test
|
void dualCrnStationOutExecute_recordsDispatchSessionAndClearsDualCacheAfterIssuingMoveCommand() {
|
StationOutboundDispatchProcessor processor = new StationOutboundDispatchProcessor();
|
WrkMastService wrkMastService = mock(WrkMastService.class);
|
RedisUtil redisUtil = mock(RedisUtil.class);
|
StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
|
StationCommandDispatcher dispatcher = mock(StationCommandDispatcher.class);
|
NotifyUtils notifyUtils = mock(NotifyUtils.class);
|
StationOutboundDecisionSupport decisionSupport = mock(StationOutboundDecisionSupport.class);
|
StationThread stationThread = mock(StationThread.class);
|
|
ReflectionTestUtils.setField(processor, "wrkMastService", wrkMastService);
|
ReflectionTestUtils.setField(processor, "redisUtil", redisUtil);
|
ReflectionTestUtils.setField(processor, "stationMoveCoordinator", coordinator);
|
ReflectionTestUtils.setField(processor, "stationCommandDispatcher", dispatcher);
|
ReflectionTestUtils.setField(processor, "notifyUtils", notifyUtils);
|
ReflectionTestUtils.setField(processor, "stationOutboundDecisionSupport", decisionSupport);
|
|
WrkMast wrkMast = buildWrkMast(10002, 188);
|
wrkMast.setWrkSts(WrkStsType.OUTBOUND_RUN_COMPLETE.sts);
|
wrkMast.setDualCrnNo(2);
|
when(wrkMastService.list(any(com.baomidou.mybatisplus.core.conditions.Wrapper.class)))
|
.thenReturn(Collections.singletonList(wrkMast));
|
when(wrkMastService.updateById(wrkMast)).thenReturn(true);
|
|
StationObjModel stationObjModel = new StationObjModel();
|
stationObjModel.setDeviceNo(1);
|
stationObjModel.setStationId(121);
|
when(redisUtil.get(RedisKeyType.DUAL_CRN_OUT_TASK_STATION_INFO.key + 10002))
|
.thenReturn(com.alibaba.fastjson.JSON.toJSONString(stationObjModel));
|
when(redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + 121)).thenReturn(null);
|
|
StationProtocol stationProtocol = buildStationProtocol(121, 0, 121);
|
stationProtocol.setAutoing(true);
|
stationProtocol.setLoading(true);
|
when(stationThread.getStatusMap()).thenReturn(Map.of(121, stationProtocol));
|
|
StationCommand command = buildCommand(10002, 121, 188);
|
when(decisionSupport.resolveOutboundPathLenFactor(wrkMast)).thenReturn(0.5d);
|
when(decisionSupport.buildOutboundMoveCommand(stationThread, wrkMast, 121, 188, 0.5d)).thenReturn(command);
|
when(dispatcher.dispatch(1, command, "station-operate-process", "dualCrnStationOutExecute"))
|
.thenReturn(StationCommandDispatchResult.accepted("accepted", 1, "station-operate-process", "dualCrnStationOutExecute"));
|
|
SlaveConnection.put(SlaveType.Devp, 1, stationThread);
|
try {
|
processor.dualCrnStationOutExecute();
|
|
verify(coordinator, times(1)).recordDispatch(eq(10002), eq(121), eq("dualCrnStationOutExecute"), same(command), eq(false));
|
verify(notifyUtils, times(1)).notify(String.valueOf(SlaveType.Devp), 1, "10002", wrkMast.getWmsWrkNo(), NotifyMsgType.STATION_OUT_TASK_RUN, null);
|
verify(redisUtil, times(1)).set(eq(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + 121), eq("lock"), eq(5L));
|
verify(redisUtil, times(1)).del(RedisKeyType.DUAL_CRN_OUT_TASK_STATION_INFO.key + 10002);
|
assertEquals(WrkStsType.STATION_RUN.sts, wrkMast.getWrkSts());
|
} finally {
|
SlaveConnection.remove(SlaveType.Devp, 1);
|
}
|
}
|
|
private static WrkMast buildWrkMast(int wrkNo, int targetStationId) {
|
WrkMast wrkMast = new WrkMast();
|
wrkMast.setWrkNo(wrkNo);
|
wrkMast.setStaNo(targetStationId);
|
wrkMast.setWmsWrkNo("WMS-" + wrkNo);
|
wrkMast.setIoTime(new Date());
|
return wrkMast;
|
}
|
|
private static StationProtocol buildStationProtocol(int stationId,
|
int taskNo,
|
int targetStationId) {
|
StationProtocol stationProtocol = new StationProtocol();
|
stationProtocol.setStationId(stationId);
|
stationProtocol.setTaskNo(taskNo);
|
stationProtocol.setTargetStaNo(targetStationId);
|
return stationProtocol;
|
}
|
|
private static StationCommand buildCommand(int wrkNo,
|
int stationId,
|
int targetStationId) {
|
StationCommand command = new StationCommand();
|
command.setTaskNo(wrkNo);
|
command.setStationId(stationId);
|
command.setTargetStaNo(targetStationId);
|
return command;
|
}
|
}
|
