update

liujie

2026-07-30 280ef5100bece9b40ac51736aef037704a52a4ca

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
107
108
109
110
111
112
package com.tourguide.modules.user.service;
 
import com.tourguide.modules.operation.entity.OperationCity;
import com.tourguide.modules.operation.entity.OperationScenicSpot;
import com.tourguide.modules.operation.mapper.OperationCityMapper;
import com.tourguide.modules.operation.mapper.OperationScenicSpotMapper;
import com.tourguide.modules.user.dto.GuideScenicConfigResponse;
import com.tourguide.modules.user.entity.GuideScenicConfig;
import com.tourguide.modules.user.entity.GuideUser;
import com.tourguide.modules.user.mapper.GuideAutoDisableConfigMapper;
import com.tourguide.modules.user.mapper.GuideScenicConfigMapper;
import com.tourguide.modules.user.mapper.GuideTeamMapper;
import com.tourguide.modules.user.mapper.GuideUserMapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.security.crypto.password.PasswordEncoder;
 
import java.util.Collections;
import java.util.List;
 
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
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 GuideUserScenicConfigServiceTest {
    private GuideUserMapper userMapper;
    private GuideScenicConfigMapper scenicConfigMapper;
    private OperationScenicSpotMapper scenicSpotMapper;
    private OperationCityMapper cityMapper;
    private GuideUserService service;
 
    @BeforeEach
    void setUp() {
        userMapper = mock(GuideUserMapper.class);
        scenicConfigMapper = mock(GuideScenicConfigMapper.class);
        scenicSpotMapper = mock(OperationScenicSpotMapper.class);
        cityMapper = mock(OperationCityMapper.class);
        service = new GuideUserService(
                userMapper,
                mock(GuideTeamMapper.class),
                scenicConfigMapper,
                mock(GuideAutoDisableConfigMapper.class),
                scenicSpotMapper,
                cityMapper,
                mock(PasswordEncoder.class));
 
        GuideUser guide = new GuideUser();
        guide.setId(12L);
        when(userMapper.selectById(12L)).thenReturn(guide);
    }
 
    @Test
    void addScenicConfigShouldUseEnabledOperationScenicData() {
        OperationScenicSpot scenicSpot = new OperationScenicSpot();
        scenicSpot.setId(21L);
        scenicSpot.setScenicName("青城山景区");
        scenicSpot.setCityId(31L);
        scenicSpot.setStatus(1);
        when(scenicSpotMapper.selectById(21L)).thenReturn(scenicSpot);
 
        OperationCity city = new OperationCity();
        city.setId(31L);
        city.setCityName("成都市");
        when(cityMapper.selectById(31L)).thenReturn(city);
        when(scenicConfigMapper.selectList(any())).thenAnswer(invocation -> {
            GuideScenicConfig saved = new GuideScenicConfig();
            saved.setId(41L);
            saved.setGuideId(12L);
            saved.setScenicName("青城山景区");
            saved.setCityName("成都市");
            return Collections.singletonList(saved);
        });
 
        List<GuideScenicConfigResponse> result = service.addScenicConfig(12L, 21L);
 
        ArgumentCaptor<GuideScenicConfig> captor = ArgumentCaptor.forClass(GuideScenicConfig.class);
        verify(scenicConfigMapper).upsert(captor.capture());
        assertThat(captor.getValue().getGuideId()).isEqualTo(12L);
        assertThat(captor.getValue().getScenicName()).isEqualTo("青城山景区");
        assertThat(captor.getValue().getCityName()).isEqualTo("成都市");
        assertThat(result).hasSize(1);
    }
 
    @Test
    void addScenicConfigShouldRejectDisabledScenicSpot() {
        OperationScenicSpot scenicSpot = new OperationScenicSpot();
        scenicSpot.setId(21L);
        scenicSpot.setStatus(0);
        when(scenicSpotMapper.selectById(21L)).thenReturn(scenicSpot);
 
        assertThatThrownBy(() -> service.addScenicConfig(12L, 21L))
                .hasMessage("景区不存在或未启用");
        verify(scenicConfigMapper, never()).upsert(any(GuideScenicConfig.class));
    }
 
    @Test
    void deleteScenicConfigShouldRejectAnotherGuidesConfig() {
        GuideScenicConfig config = new GuideScenicConfig();
        config.setId(41L);
        config.setGuideId(99L);
        when(scenicConfigMapper.selectById(41L)).thenReturn(config);
 
        assertThatThrownBy(() -> service.deleteScenicConfig(12L, 41L))
                .hasMessage("导游景区配置不存在");
        verify(scenicConfigMapper, never()).deleteById(41L);
    }
}