package com.zy.core.utils.station;
|
|
import com.zy.asrs.domain.enums.NotifyMsgType;
|
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.WrkAnalysisService;
|
import com.zy.asrs.service.WrkMastService;
|
import com.zy.asrs.utils.NotifyUtils;
|
import com.zy.common.entity.FindCrnNoResult;
|
import com.zy.common.service.CommonService;
|
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.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 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 java.util.Objects;
|
|
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.never;
|
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 StationRegularDispatchProcessorTest {
|
|
@Test
|
void stationInExecute_recordsDispatchSessionAfterIssuingMoveCommand() {
|
StationRegularDispatchProcessor processor = new StationRegularDispatchProcessor();
|
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);
|
|
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);
|
|
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));
|
|
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);
|
|
SlaveConnection.put(SlaveType.Devp, 1, stationThread);
|
try {
|
processor.stationInExecute();
|
|
verify(coordinator, times(1)).recordDispatch(eq(500670), eq(101), eq("stationInExecute"), same(command), eq(false));
|
verify(redisUtil, times(1)).set(eq(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + 101), eq("lock"), eq(5L));
|
verify(loadSupport, times(1)).saveLoopLoadReserve(500670, noHit);
|
} finally {
|
SlaveConnection.remove(SlaveType.Devp, 1);
|
}
|
}
|
|
@Test
|
void stationOutExecuteFinish_attemptsClearPathBeforeCompletingTask() {
|
StationRegularDispatchProcessor processor = new StationRegularDispatchProcessor();
|
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(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);
|
|
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 {
|
processor.stationOutExecuteFinish();
|
|
verify(stationThread, times(1)).clearPath(10335);
|
verify(coordinator, times(1)).finishSession(10335);
|
verify(wrkMastService, times(1)).updateById(wrkMast);
|
verify(notifyUtils, times(1)).notify(String.valueOf(SlaveType.Devp), 1, "10335", wrkMast.getWmsWrkNo(), NotifyMsgType.STATION_OUT_TASK_RUN_COMPLETE, null);
|
assertEquals(WrkStsType.STATION_RUN_COMPLETE.sts, wrkMast.getWrkSts());
|
} finally {
|
SlaveConnection.remove(SlaveType.Devp, 1);
|
}
|
}
|
|
@Test
|
void checkTaskToComplete_marksTaskCompleteAfterLeavingTargetStation() {
|
StationRegularDispatchProcessor processor = new StationRegularDispatchProcessor();
|
WrkMastService wrkMastService = mock(WrkMastService.class);
|
BasStationService basStationService = mock(BasStationService.class);
|
StationMoveCoordinator coordinator = mock(StationMoveCoordinator.class);
|
RedisUtil redisUtil = mock(RedisUtil.class);
|
StationThread stationThread = mock(StationThread.class);
|
|
ReflectionTestUtils.setField(processor, "wrkMastService", wrkMastService);
|
ReflectionTestUtils.setField(processor, "basStationService", basStationService);
|
ReflectionTestUtils.setField(processor, "stationMoveCoordinator", coordinator);
|
ReflectionTestUtils.setField(processor, "redisUtil", redisUtil);
|
|
WrkMast wrkMast = buildWrkMast(10335, 145);
|
wrkMast.setWrkSts(WrkStsType.STATION_RUN_COMPLETE.sts);
|
when(wrkMastService.list(any(com.baomidou.mybatisplus.core.conditions.Wrapper.class)))
|
.thenReturn(Collections.singletonList(wrkMast));
|
|
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, 0, 145);
|
when(stationThread.getStatusMap()).thenReturn(Map.of(145, stationProtocol));
|
when(redisUtil.get(anyString())).thenReturn(null);
|
|
SlaveConnection.put(SlaveType.Devp, 1, stationThread);
|
try {
|
processor.checkTaskToComplete();
|
|
verify(coordinator, times(1)).finishSession(10335);
|
verify(wrkMastService, times(1)).updateById(wrkMast);
|
assertEquals(WrkStsType.COMPLETE_OUTBOUND.sts, wrkMast.getWrkSts());
|
} finally {
|
SlaveConnection.remove(SlaveType.Devp, 1);
|
}
|
}
|
|
private static BasDevp buildBasDevp(int devpNo) {
|
BasDevp basDevp = new BasDevp();
|
basDevp.setDevpNo(devpNo);
|
return basDevp;
|
}
|
|
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;
|
}
|
}
|
