#

Junjie

昨天 058d7bbb714634e42bff1dd71fdfca3a378421d3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
package com.zy.core.thread.impl.station;
 
import com.alibaba.fastjson.JSON;
import com.core.common.SpringUtils;
import com.zy.asrs.entity.DeviceConfig;
import com.zy.common.utils.RedisUtil;
import com.zy.core.enums.RedisKeyType;
import com.zy.core.model.CommandResponse;
import com.zy.core.model.command.StationCommand;
import com.zy.core.move.StationMoveCoordinator;
import com.zy.core.move.StationMoveSessionRegistry;
import com.zy.core.move.StationMoveSession;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.test.util.ReflectionTestUtils;
 
import java.util.List;
import java.util.function.Function;
 
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
 
class StationSegmentExecutorTest {
 
    @Test
    void resolveCurrentPathIndex_prefersForwardOccurrenceForLoopRevisitStations() {
        StationSegmentExecutor executor = new StationSegmentExecutor(new DeviceConfig(), mock(RedisUtil.class), command -> null);
 
        Integer second121Index = ReflectionTestUtils.invokeMethod(
                executor,
                "resolveCurrentPathIndex",
                List.of(121, 124, 186, 189, 121, 124, 125, 127),
                121,
                3
        );
        Integer second124Index = ReflectionTestUtils.invokeMethod(
                executor,
                "resolveCurrentPathIndex",
                List.of(121, 124, 186, 189, 121, 124, 125, 127),
                124,
                4
        );
        Integer same124Index = ReflectionTestUtils.invokeMethod(
                executor,
                "resolveCurrentPathIndex",
                List.of(121, 124, 186, 189, 121, 124, 125, 127),
                124,
                5
        );
 
        assertEquals(Integer.valueOf(4), second121Index);
        assertEquals(Integer.valueOf(5), second124Index);
        assertEquals(Integer.valueOf(5), same124Index);
    }
 
    @Test
    void sendSegmentWithRetry_skipsWhenRouteIsCancelPending() {
        ApplicationContext applicationContext = mock(ApplicationContext.class);
        StationMoveCoordinator coordinator = new StationMoveCoordinator();
        StationMoveSessionRegistry sessionRegistry = new StationMoveSessionRegistry();
        RedisUtil redisUtil = mock(RedisUtil.class);
        @SuppressWarnings("unchecked")
        Function<StationCommand, CommandResponse> commandSender = mock(Function.class);
 
        ReflectionTestUtils.setField(coordinator, "sessionRegistry", sessionRegistry);
        ReflectionTestUtils.setField(coordinator, "redisUtil", redisUtil);
        ReflectionTestUtils.setField(sessionRegistry, "redisUtil", redisUtil);
        when(applicationContext.getBean(StationMoveCoordinator.class)).thenReturn(coordinator);
        SpringUtils.init(applicationContext);
 
        StationSegmentExecutor executor = new StationSegmentExecutor(new DeviceConfig(), redisUtil, commandSender);
 
        StationCommand command = new StationCommand();
        command.setTaskNo(10492);
        command.setStationId(186);
        command.setTargetStaNo(124);
        command.setRouteVersion(23);
 
        StationMoveSession session = new StationMoveSession();
        session.setTaskNo(10492);
        session.setRouteVersion(23);
        session.setStatus(StationMoveSession.STATUS_CANCEL_PENDING);
 
        when(redisUtil.get(RedisKeyType.STATION_MOVE_SESSION_.key + 10492))
                .thenReturn(JSON.toJSONString(session));
        when(redisUtil.get(RedisKeyType.DEVICE_STATION_MOVE_RESET.key + 10492)).thenReturn(null);
        when(commandSender.apply(any())).thenReturn(new CommandResponse(true));
 
        Boolean result = ReflectionTestUtils.invokeMethod(
                executor,
                "sendSegmentWithRetry",
                command,
                null,
                null,
                186
        );
 
        assertFalse(Boolean.TRUE.equals(result));
        verify(commandSender, never()).apply(any());
    }
}