Post

대용량 트래픽 경험해보기(3/14) - 여행 테스트 코드 작성(TDD, Mockito) & API 자동화 문서(Swagger)

Posted By Dowon Lee

여행일정 테스트 케이스

기능 구분테스트 구분세부 테스트 구분
1. 홈 > 여행 정보1.1 여행정보 현황 테스트- 여행 정보 현황 회원정보 NULL 테스트
1.2 여행정보 조회 테스트
1.3 여행정보 일정 변경 테스트- 여행 정보 일정 수정 회원정보 NULL 테스트
1.4 여행정보 제목 변경 테스트- 여행 정보 제목 수정 회원정보 NULL 테스트
1.5 여행정보 추가 테스트 - 여행 정보 추가 실패 테스트
- 여행 정보 추가 회원정보 NULL 테스트
1.6 여행정보 삭제 테스트
2. 여행 지역2.1 여행 도시 조회 테스트
2.2 여행 도시 추가 테스트
2.3 여행 도시 변경 테스트
3. 여행 일정3.1 여행 일정 현황 테스트
3.2 여행 일정 추가 테스트
3.3 여행 일정 조회 테스트
3.4 여행 일정 수정 테스트
3.5 여행 일정 삭제 테스트
3.6 여행 일정 순서 변경 테스트
3.7 여행 일정 거리순 정렬 테스트

슬라이스 테스트 - 여행정보

여행정보 - Repository 테스트

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

@DisplayName("여행 Repository 테스트")
@ExtendWith(MockitoExtension.class)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TravelRepositoryMockTests {

  @Mock
  TravelRepository travelRepository;

  private DateTimeFormatter formatter;

  @BeforeEach
  public void setUp(){
    formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss", Locale.KOREA);
  }

  @Test
  @Order(1)
  @DisplayName("여행 리포지토리 여행정보 등록 오류 테스트")
  public void 여행_리포지토리_여행정보_등록_오류_테스트(){
    //given

    Travel travel = new Travel();
    travel.setTravelId(1L);
    travel.setMemberId(1L);
    travel.setStartDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    travel.setEndDate(LocalDateTime.parse("2024-06-03 23:59:59", formatter));
    travel.setCreatorId(1L);

    CommonException commonException = new CommonException(ResponseCode.TRAVEL_CREATED_FAIL);
    when(travelRepository.save(any(Travel.class))).thenThrow(commonException);

    //when

    assertThrows(CommonException.class, () -> {
      travelRepository.save(travel);
    });

    //then
  }

  @Test
  @Order(2)
  @DisplayName("여행 리포지토리 여행정보 등록 테스트")
  public void 여행_리포지토리_여행정보_등록_테스트(){
    //given
    Travel travel = new Travel(
        1L, 1L, null,
        LocalDateTime.parse("2024-06-01 00:00:00", formatter),
        LocalDateTime.parse("2024-06-03 23:59:59", formatter),
        1L
    );

    Travel savedTravel = new Travel(
        1L, 1L, null,
        LocalDateTime.parse("2024-06-01 00:00:00", formatter),
        LocalDateTime.parse("2024-06-03 23:59:59", formatter),
        1L
    );

    when(travelRepository.save(any(Travel.class))).thenReturn(savedTravel);

    //when
    Travel result = travelRepository.save(travel);

    //then
    assertEquals(1L, result.getTravelId());
    assertEquals(1L, result.getMemberId());
    assertEquals(null, result.getTravelName());
    assertEquals(LocalDateTime.parse("2024-06-01 00:00:00", formatter), result.getStartDate());
    assertEquals(LocalDateTime.parse("2024-06-03 23:59:59", formatter), result.getEndDate());
    assertEquals(1L, result.getCreatorId());
  }

  @Test
  @Order(3)
  @DisplayName("여행 리포지토리 선택 여행정보 조회 테스트")
  public void 여행_리포지토리_선택_여행정보_조회_테스트(){
    //given
    Long travelId = 1L;

    Travel findTravel = new Travel(
        1L, 1L, null,
        LocalDateTime.parse("2024-06-01 00:00:00", formatter),
        LocalDateTime.parse("2024-06-03 23:59:59", formatter),
        1L
    );

    when(travelRepository.findById(any(Long.class))).thenReturn(Optional.of(findTravel));

    //when
    Travel result = travelRepository.findById(travelId).get();

    //then
    assertEquals(1L, result.getTravelId());
    assertEquals(1L, result.getMemberId());
    assertEquals(null, result.getTravelName());
    assertEquals(LocalDateTime.parse("2024-06-01 00:00:00", formatter), result.getStartDate());
    assertEquals(LocalDateTime.parse("2024-06-03 23:59:59", formatter), result.getEndDate());
    assertEquals(1L, result.getCreatorId());
  }

  @Test
  @Order(4)
  @DisplayName("여행 리포지토리 선택 여행정보 조회 NULL 테스트")
  public void 여행_리포지토리_선택_여행정보_조회_NULL_테스트(){
    //given
    Long travelId = 1L;

    CommonException commonException = new CommonException(ResponseCode.TRAVEL_NOT_FOUND);
    when(travelRepository.findById(any(Long.class))).thenThrow(commonException);

    //when
    assertThrows(CommonException.class, () -> {
      travelRepository.findById(travelId).get();
    });

    //then
  }

  @Test
  @Order(5)
  @DisplayName("여행 리포지토리 여행일정 수정 테스트")
  public void 여행_리포지토리_여행일정_수정_테스트(){
    //given
    Long travelId = 1L, modifierId = 1L;
    TravelScheduleUpdateDto updateDto = new TravelScheduleUpdateDto();
    updateDto.setStartDate(LocalDateTime.parse("2024-06-02 00:00:00", formatter));
    updateDto.setEndDate(LocalDateTime.parse("2024-06-05 23:59:59", formatter));

    Long updateCount = 1L;
    when(travelRepository.modifyTravelSchedule(anyLong(), any(TravelScheduleUpdateDto.class), anyLong()))
        .thenReturn(updateCount);

    //when
    Long result = travelRepository.modifyTravelSchedule(travelId, updateDto, modifierId);

    //then
    assertEquals(1L, result);
  }

  @Test
  @Order(6)
  @DisplayName("여행 리포지토리 여행명 수정 테스트")
  public void 여행_리포지토리_여행명_수정_테스트(){
    //given
    Long travelId = 1L, modifierId = 1L;
    TravelNameUpdateDto updateDto = new TravelNameUpdateDto();
    updateDto.setTravelName("대학 친구들하고 대구 여행");

    Long updateCount = 1L;
    when(travelRepository.modifyTravelName(anyLong(), any(TravelNameUpdateDto.class), anyLong())).thenReturn(updateCount);

    //when
    Long result = travelRepository.modifyTravelName(travelId, updateDto, modifierId);

    //then
    assertEquals(1L, result);
  }

  @Test
  @Order(7)
  @DisplayName("여행 리포지토리 여행정보 삭제 테스트")
  public void 여행_리포지토리_여행정보_삭제_테스트(){
    //given
    Long travelId = 1L;

    doNothing().when(travelRepository).deleteById(anyLong());

    //when
    travelRepository.deleteById(travelId);

    //then
  }

  @Test
  @Order(8)
  @DisplayName("여행 리포지토리 여행정보 현황 페이징 테스트")
  public void 여행_리포지토리_여행정보_현황_페이징_테스트(){
    //given
    Long memberId = 1L;
    int pageNumber = 0, pageSize = 15;
    Pageable pageable = PageRequest.of(pageNumber, pageSize);

    List<TravelResponseDto> travels = new ArrayList<>();
    for(int i = 1 ; i <= 50 ; i++){
      TravelResponseDto travel = new TravelResponseDto();
      travel.setTravelId((long)i);
      travel.setTravelName("여행명"+i);
      travel.setStartDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter).plusDays((30*i)));
      travel.setEndDate(LocalDateTime.parse("2024-06-04 23:59:59", formatter).plusDays((30*i)));
      travels.add(travel);
    }

    Page<TravelResponseDto> savedTravels = new PageImpl<>(travels, pageable, travels.size());
    when(travelRepository.getTravels(anyLong(), any(Pageable.class))).thenReturn(savedTravels);

    //when
    Page<TravelResponseDto> result = travelRepository.getTravels(memberId, pageable);

    //then
    assertEquals(travels.size()/pageSize+1, result.getTotalPages());
    assertEquals(50, result.getTotalElements());
    assertFalse(result.hasPrevious());
    assertTrue(result.hasNext());
    assertEquals(pageNumber, result.getNumber());
  }
}

Travel Repository Test Result

여행정보 - Service 테스트

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287

@DisplayName("여행 정보 Service 테스트")
@ExtendWith(MockitoExtension.class)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TravelServiceMockTests {

  @InjectMocks
  TravelService travelService;

  @Mock
  TravelRepository travelRepository;

  @Mock
  TravelRegionService regionService;

  @Mock
  MemberRepository memberRepository;

  private DateTimeFormatter formatter;

  @BeforeEach
  public void setUp(){
    formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss", Locale.KOREA);
  }

  @Test
  @Order(1)
  @DisplayName("여행정보 서비스 여행정보 등록 회원정보 NULL 테스트")
  public void 여행정보_서비스_여행정보_등록_회원정보_NULL_테스트(){
    //given
    String[] countries = {"대구", "여수"};
    String memberEmail = "test1@gmail.com";

    TravelCreateDto createDto = new TravelCreateDto();
    createDto.setStartDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    createDto.setEndDate(LocalDateTime.parse("2024-06-03 23:59:59", formatter));

    Travel savedTravel = new Travel();
    savedTravel.setTravelId(1L);
    savedTravel.setMemberId(1L);
    savedTravel.setStartDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    savedTravel.setEndDate(LocalDateTime.parse("2024-06-03 23:59:59", formatter));
    savedTravel.setCreatorId(1L);

    CommonException memberNotFound = new CommonException(ResponseCode.MEMBER_NOT_FOUND);
    when(memberRepository.getMemberIdByEmail(anyString())).thenThrow(memberNotFound);

    //when
    assertThrows(CommonException.class, () -> {
      travelService.createTravel(createDto, memberEmail);
    });

    //then
    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(travelRepository, times(0)).save(any(Travel.class));
  }

  @Test
  @Order(2)
  @DisplayName("여행정보 서비스 여행정보 등록 테스트")
  public void 여행정보_서비스_여행정보_등록_테스트(){
    //given
    String[] countries = {"대구", "여수"};
    String memberEmail = "test1@gmail.com";

    TravelCreateDto createDto = new TravelCreateDto();
    createDto.setStartDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    createDto.setEndDate(LocalDateTime.parse("2024-06-03 23:59:59", formatter));

    Travel savedTravel = new Travel();
    savedTravel.setTravelId(1L);
    savedTravel.setMemberId(1L);
    savedTravel.setStartDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    savedTravel.setEndDate(LocalDateTime.parse("2024-06-03 23:59:59", formatter));
    savedTravel.setCreatorId(1L);

    when(memberRepository.getMemberIdByEmail(anyString())).thenReturn(1L);
    when(travelRepository.save(any(Travel.class))).thenReturn(savedTravel);

    //when
    travelService.createTravel(createDto, memberEmail);

    //then
    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(travelRepository, times(1)).save(any(Travel.class));
  }

  @Test
  @Order(3)
  @DisplayName("여행정보 서비스 여행일정 조회 테스트")
  public void 여행정보_서비스_여행일정_조회_테스트(){
    //given
    Long travelId = 1L;
    String memberEmail = "test1@gmail.com";

    Travel savedTravel = new Travel();
    savedTravel.setTravelId(1L);
    savedTravel.setTravelName(null);
    savedTravel.setStartDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    savedTravel.setEndDate(LocalDateTime.parse("2024-06-03 23:59:59", formatter));

    when(memberRepository.getMemberIdByEmail(anyString())).thenReturn(1L);
    when(travelRepository.findById(anyLong())).thenReturn(Optional.of(savedTravel));

    //when
    TravelResponseDto result = travelService.findTravel(travelId, memberEmail);

    //then
    assertEquals(1L, result.getTravelId());
    assertEquals(null, result.getTravelName());
    assertEquals(LocalDateTime.parse("2024-06-01 00:00:00", formatter), result.getStartDate());
    assertEquals(LocalDateTime.parse("2024-06-03 23:59:59", formatter), result.getEndDate());

    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(travelRepository, times(1)).findById(1L);
  }

  @Test
  @Order(4)
  @DisplayName("여행정보 서비스 여행일정 수정 회원정보 NULL 테스트")
  public void 여행정보_서비스_여행일정_수정_회원정보_NULL_테스트(){
    //given
    Long travelId = 1L;

    TravelScheduleUpdateDto updateDto = new TravelScheduleUpdateDto();
    updateDto.setStartDate(LocalDateTime.parse("2024-06-02 00:00:00", formatter));
    updateDto.setEndDate(LocalDateTime.parse("2024-06-05 23:59:59", formatter));
    String memberEmail = "test1@gmail.com";

    CommonException memberNotFound = new CommonException(ResponseCode.MEMBER_NOT_FOUND);
    when(memberRepository.getMemberIdByEmail(anyString())).thenThrow(memberNotFound);

    //when
    assertThrows(CommonException.class, () -> {
      travelService.modifyTravelSchedule(travelId, updateDto, memberEmail);
    });

    //then
    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(travelRepository, times(0)).modifyTravelSchedule(1L, updateDto, 1L);
  }

  @Test
  @Order(5)
  @DisplayName("여행정보 서비스 여행일정 수정 테스트")
  public void 여행정보_서비스_여행일정_수정_테스트(){
    //given
    Long travelId = 1L;

    TravelScheduleUpdateDto updateDto = new TravelScheduleUpdateDto();
    updateDto.setStartDate(LocalDateTime.parse("2024-06-02 00:00:00", formatter));
    updateDto.setEndDate(LocalDateTime.parse("2024-06-05 23:59:59", formatter));
    String memberEmail = "test1@gmail.com";

    when(memberRepository.getMemberIdByEmail(anyString())).thenReturn(1L);
    when(travelRepository.modifyTravelSchedule(anyLong(), any(TravelScheduleUpdateDto.class), anyLong())).thenReturn(1L);

    //when
    long result = travelService.modifyTravelSchedule(travelId, updateDto, memberEmail);

    //then
    assertEquals(1L, result);
    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(travelRepository, times(1)).modifyTravelSchedule(1L, updateDto, 1L);
  }

  @Test
  @Order(6)
  @DisplayName("여행정보 서비스 여행명 수정 회원정보 NULL 테스트")
  public void 여행정보_서비스_여행명_수정_회원정보_NULL_테스트(){
    //given
    Long travelId = 1L;

    TravelNameUpdateDto updateDto = new TravelNameUpdateDto();
    updateDto.setTravelName("친구들과 함께 여행");
    String memberEmail = "test1@gmail.com";

    CommonException memberNotFound = new CommonException(ResponseCode.MEMBER_NOT_FOUND);
    when(memberRepository.getMemberIdByEmail(anyString())).thenThrow(memberNotFound);

    //when
    assertThrows(CommonException.class, () -> {
      travelService.modifyTravelName(travelId, updateDto, memberEmail);
    });

    //then
    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(travelRepository, times(0)).modifyTravelName(1L, updateDto, 0L);
  }

  @Test
  @Order(7)
  @DisplayName("여행정보 서비스 여행명 수정 테스트")
  public void 여행정보_서비스_여행명_수정_테스트(){
    //given
    Long travelId = 1L;

    TravelNameUpdateDto updateDto = new TravelNameUpdateDto();
    updateDto.setTravelName("친구들과 함께 여행");
    String memberEmail = "test1@gmail.com";

    when(memberRepository.getMemberIdByEmail(anyString())).thenReturn(1L);
    when(travelRepository.modifyTravelName(anyLong(), any(TravelNameUpdateDto.class), anyLong())).thenReturn(1L);

    //when
    long result = travelService.modifyTravelName(travelId, updateDto, memberEmail);

    //then
    assertEquals(1L, result);
    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(travelRepository, times(1)).modifyTravelName(1L, updateDto, 1L);
  }

  @Test
  @Order(8)
  @DisplayName("여행정보 서비스 여행정보 삭제 테스트")
  public void 여행정보_서비스_여행정보_삭제_테스트(){
    //given
    Long travelId = 1L;

    doNothing().when(travelRepository).deleteById(anyLong());

    //when
    travelService.removeTravel(travelId);

    //then
    verify(travelRepository, times(1)).deleteById(1L);
  }

  @Test
  @Order(9)
  @DisplayName("여행정보 서비스 여행정보 현황 페이징 회원정보 NULL 테스트")
  public void 여행정보_서비스_여행정보_현황_페이징_회원정보_NULL_테스트(){
    //given
    String memberEmail = "test1@gmail.com";
    int pageNumber = 0, pageSize = 15;
    Pageable pageable = PageRequest.of(pageNumber, pageSize);

    CommonException memberNotFound = new CommonException(ResponseCode.MEMBER_NOT_FOUND);
    when(memberRepository.getMemberIdByEmail(anyString())).thenThrow(memberNotFound);

    //when
    assertThrows(CommonException.class, () -> {
      travelService.findTravels(memberEmail, pageable);
    });

    //then
    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(travelRepository, times(0)).getTravels(1L, pageable);
  }

  @Test
  @Order(10)
  @DisplayName("여행정보 서비스 여행정보 현황 페이징 테스트")
  public void 여행정보_서비스_여행정보_현황_페이징_테스트(){
    //given
    String memberEmail = "test1@gmail.com";
    int pageNumber = 0, pageSize = 15;
    Pageable pageable = PageRequest.of(pageNumber, pageSize);

    List<TravelResponseDto> travels = new ArrayList<>();
    for(int i = 1 ; i <= 50 ; i++){
      TravelResponseDto travel = new TravelResponseDto();
      travel.setTravelId((long)i);
      travel.setTravelName("여행명"+i);
      travel.setStartDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter).plusDays((30*i)));
      travel.setEndDate(LocalDateTime.parse("2024-06-04 23:59:59", formatter).plusDays((30*i)));
      travels.add(travel);
    }

    Page<TravelResponseDto> savedTravels = new PageImpl<>(travels, pageable, travels.size());
    when(memberRepository.getMemberIdByEmail(anyString())).thenReturn(1L);
    when(travelRepository.getTravels(anyLong(), any(Pageable.class))).thenReturn(savedTravels);

    //when
    Map<String, Object> result = travelService.findTravels(memberEmail, pageable);

    //then
    assertEquals(travels.size()/pageSize+1, result.get("totalPage"));
    assertEquals(50, (long)result.get("totalCount"));
    assertEquals(pageNumber, result.get("currentPage"));
    assertFalse((boolean)result.get("hasPrevious"));
    assertTrue((boolean)result.get("hasNext"));

    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(travelRepository, times(1)).getTravels(1L, pageable);
  }
}

Travel Service Test Result

여행정보 - Controller 테스트

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219

@DisplayName("여행정보 Controller 테스트")
@SpringBootTest
@ActiveProfiles("local")
@AutoConfigureMockMvc
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TravelControllerMockTests {

  @Autowired
  MockMvc mockMvc;

  @MockBean
  TravelService travelService;

  private DateTimeFormatter formatter;

  @Autowired
  ObjectMapper objectMapper;

  private String accessToken;
  private String memberEmail;

  @BeforeEach
  public void setUp(){
    formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss", Locale.KOREA);

    accessToken = "Bearer ";
    accessToken += "eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJ0ZXN0MUBnbWFpbC5jb20iLCJpYXQiOjE3MTcxMjQ4MjAsIkF1dGhvcml6YXRpb24iOiJVU0VSIiwiZXhwIjoxNzE3MTMyMDIwfQ.YUWeURkeaOdt0QKVCxdDpbc-nOhdm7HEIu4dr06achBWz4zXy8_Ifqf9dYUw7YoGed-6hF2XE71_rW1J2BY1RA";

    memberEmail = "test1@gmail.com";
  }

  @Test
  @Order(1)
  @DisplayName("여행정보 컨트롤러 여행현황 회원정보 NULL 테스트")
  public void 여행정보_컨트롤러_여행현황_회원정보_NULL_테스트() throws Exception {
    //given
    CommonException memberNotFound = new CommonException(ResponseCode.MEMBER_NOT_FOUND);
    when(travelService.findTravels(anyString(), any(Pageable.class))).thenThrow(memberNotFound);

    //when
    ResultActions actions = mockMvc.perform(
        get("/api/travel/travels")
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
            .contentType(MediaType.APPLICATION_JSON)
    );

    //then
    actions
        .andExpect(status().isNotFound());
  }

  @Test
  @Order(2)
  @DisplayName("여행정보 컨트롤러 여행현황 테스트")
  public void 여행정보_컨트롤러_여행현황_테스트() throws Exception {
    //given
    List<TravelResponseDto> content = new ArrayList<>();
    for(int i = 1 ; i <= 50 ; i++){
      TravelResponseDto travel = new TravelResponseDto();
      travel.setTravelId((long)i);
      travel.setTravelName("여행명"+i);
      travel.setStartDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter).plusDays((30*i)));
      travel.setEndDate(LocalDateTime.parse("2024-06-04 23:59:59", formatter).plusDays((30*i)));
      content.add(travel);
    }

    Map<String, Object> response = new HashMap<>();
    response.put("body", content);
    response.put("totalPage", 4);
    response.put("totalCount", 50);
    response.put("currentPage", 0);
    response.put("hasPrevious", false);
    response.put("hasNext", true);

    when(travelService.findTravels(anyString(), any(Pageable.class))).thenReturn(response);

    //when
    ResultActions actions = mockMvc.perform(
        get("/api/travel/travels")
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsString(content))
    );

    //then
    actions
        .andExpect(status().isOk());
  }

  @Test
  @Order(3)
  @DisplayName("여행정보 컨트롤러 여행정보 등록 테스트")
  public void 여행정보_컨트롤러_여행정보_등록_테스트() throws Exception {
    //given
    TravelCreateDto createDto = new TravelCreateDto();
    createDto.setStartDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    createDto.setEndDate(LocalDateTime.parse("2024-06-03 23:59:59", formatter));

    doNothing().when(travelService).createTravel(any(TravelCreateDto.class), anyString());

    //when
    ResultActions actions = mockMvc.perform(
        post("/api/travel")
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsString(createDto))
    );

    //then
    actions
        .andExpect(status().isCreated());
  }

  @Test
  @Order(4)
  @DisplayName("여행정보 컨트롤러 여행정보 조회 테스트")
  public void 여행정보_컨트롤러_여행정보_조회_테스트() throws Exception {
    //given
    Long travelId = 1L;

    TravelResponseDto responseDto = new TravelResponseDto();
    responseDto.setTravelId(travelId);
    responseDto.setTravelName("친구와 여행");
    responseDto.setStartDate(LocalDateTime.parse("2024-06-03 00:00:00", formatter));
    responseDto.setEndDate(LocalDateTime.parse("2024-06-05 23:59:59", formatter));

    when(travelService.findTravel(anyLong(), anyString())).thenReturn(responseDto);

    //when
    ResultActions actions = mockMvc.perform(
        get("/api/travel/"+travelId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
    );

    //then
    actions
        .andExpect(status().isOk());
  }

  @Test
  @Order(5)
  @DisplayName("여행정보 컨트롤러 여행일정 수정 테스트")
  public void 여행정보_컨트롤러_여행일정_수정_테스트() throws Exception {
    //given
    Long travelId = 1L;

    TravelScheduleUpdateDto updateDto = new TravelScheduleUpdateDto();
    updateDto.setStartDate(LocalDateTime.parse("2024-06-03 00:00:00", formatter));
    updateDto.setEndDate(LocalDateTime.parse("2024-06-05 23:59:59", formatter));

    when(travelService.modifyTravelSchedule(anyLong(), any(TravelScheduleUpdateDto.class), anyString())).thenReturn(1L);

    //when
    ResultActions actions = mockMvc.perform(
        patch("/api/travel/schedule/"+travelId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsString(updateDto))
    );

    //then
    actions
        .andExpect(status().isNoContent());
  }

  @Test
  @Order(6)
  @DisplayName("여행정보 컨트롤러 여행명 수정 테스트")
  public void 여행정보_컨트롤러_여행명_수정_테스트() throws Exception {
    //given
    Long travelId = 1L;

    TravelNameUpdateDto updateDto = new TravelNameUpdateDto();
    updateDto.setTravelName("대학 친구들과 여행");

    when(travelService.modifyTravelName(anyLong(), any(TravelNameUpdateDto.class), anyString())).thenReturn(1L);

    //when
    ResultActions actions = mockMvc.perform(
        patch("/api/travel/name/"+travelId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsString(updateDto))
    );

    //then
    actions
        .andExpect(status().isNoContent());
  }

  @Test
  @Order(7)
  @DisplayName("여행정보 컨트롤러 여행정보 삭제 테스트")
  public void 여행정보_컨트롤러_여행정보_삭제_테스트() throws Exception {
    //given
    Long travelId = 1L;

    doNothing().when(travelService).removeTravel(anyLong());

    //when
    ResultActions actions = mockMvc.perform(
        delete("/api/travel/"+travelId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
    );

    //then
    actions
        .andExpect(status().isNoContent());
  }

}

Travel Controller Test Result

슬라이스 테스트 - 여행지역

여행지역 - Repository 테스트

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

@DisplayName("여행지역 Repository 테스트")
@ExtendWith(MockitoExtension.class)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TravelRegionRepositoryMockTests {

  @Mock
  TravelRegionRepository travelCountryRepository;

  @Test
  @Order(1)
  @DisplayName("여행지역 리포지토리 등록 테스트")
  public void 여행지역_리포지토리_등록_테스트(){
    //given
    TravelRegion travelRegion = new TravelRegion();
    travelRegion.setTravelRegionId(1L);
    travelRegion.setTravelId(1L);
    travelRegion.setRegionName("대구");
    travelRegion.setCreatorId(1L);

    TravelRegion savedTravelRegion = new TravelRegion();
    savedTravelRegion.setTravelRegionId(1L);
    savedTravelRegion.setTravelId(1L);
    savedTravelRegion.setRegionName("대구");
    savedTravelRegion.setCreatorId(1L);

    when(travelCountryRepository.save(any(TravelRegion.class))).thenReturn(savedTravelRegion);

    //when
    TravelRegion result = travelCountryRepository.save(travelRegion);

    //then
    assertEquals(1L, result.getTravelRegionId());
    assertEquals(1L, result.getTravelId());
    assertEquals("대구", result.getRegionName());
    assertEquals(1L, result.getCreatorId());
  }

  @Test
  @Order(2)
  @DisplayName("여행지역 리포지토리 여행별_조회 테스트")
  public void 여행지역_리포지토리_여행별_조회_테스트(){
    //given
    Long travelId = 1L;
    Sort sort = Sort.by(Sort.Order.asc("region_order"));

    List<TravelRegion> findCountries = new ArrayList<>();
    TravelRegion savedTravelRegion = new TravelRegion();
    savedTravelRegion.setTravelRegionId(1L);
    savedTravelRegion.setTravelId(1L);
    savedTravelRegion.setRegionName("대구");
    savedTravelRegion.setCreatorId(1L);
    findCountries.add(savedTravelRegion);

    savedTravelRegion = new TravelRegion();
    savedTravelRegion.setTravelRegionId(2L);
    savedTravelRegion.setTravelId(1L);
    savedTravelRegion.setRegionName("여수");
    savedTravelRegion.setCreatorId(1L);
    findCountries.add(savedTravelRegion);

    when(travelCountryRepository.findAllByTravelId(any(Long.class), any(Sort.class))).thenReturn(findCountries);

    //when
    List<TravelRegion> result = travelCountryRepository.findAllByTravelId(travelId, sort);

    //then
    assertEquals(2, result.size());
  }

  @Test
  @Order(3)
  @DisplayName("여행지역 리포지토리 수정 테스트")
  public void 여행지역_리포지토리_수정_테스트(){
    //given
    Long countryId = 1L;
    String countryName = "여수";
    Long modifierId = 1L;

    TravelRegionUpdateDto updateDto = new TravelRegionUpdateDto("여수", 1);

    Long updateCount = 1L;
    when(travelCountryRepository.modifyTravelRegion(any(Long.class), any(TravelRegionUpdateDto.class), any(Long.class)))
        .thenReturn(updateCount);

    //when
    Long result = travelCountryRepository.modifyTravelRegion(countryId, updateDto, modifierId);

    //then
    assertEquals(1L, result);
  }

  @Test
  @Order(4)
  @DisplayName("여행지역 리포지토리 삭제 테스트")
  public void 여행지역_리포지토리_삭제_테스트(){
    //given
    Long countryId = 1L;

    doNothing().when(travelCountryRepository).deleteById(any(Long.class));

    //when
    travelCountryRepository.deleteById(countryId);

    //then
    verify(travelCountryRepository).deleteById(any(Long.class));
  }
}

TravelRegion Repositoy Test Result

여행지역 - Service 테스트

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

@DisplayName("여행 지역 Service 테스트")
@ExtendWith(MockitoExtension.class)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TravelRegionServiceMockTests {

  @InjectMocks
  TravelRegionService travelRegionService;

  @Mock
  TravelRegionRepository regionRepository;

  @Mock
  MemberRepository memberRepository;

  @Test
  @Order(1)
  @DisplayName("여행지역 서비스 여행정보별 지역 현황 테스트")
  public void 여행지역_서비스_여행정보별_지역_현황_테스트(){
    //given
    Long travelId = 1L;

    TravelRegion savedRegion1 = new TravelRegion();
    savedRegion1.setTravelRegionId(1L);
    savedRegion1.setRegionName("대구");
    savedRegion1.setRegionOrder(1);

    TravelRegion savedRegion2 = new TravelRegion();
    savedRegion2.setTravelRegionId(2L);
    savedRegion2.setRegionName("서울");
    savedRegion2.setRegionOrder(2);

    List<TravelRegion> savedRegions = new ArrayList<>();
    savedRegions.add(savedRegion1);
    savedRegions.add(savedRegion2);

    when(regionRepository.findAllByTravelId(anyLong(), any(Sort.class))).thenReturn(savedRegions);

    //when
    List<TravelRegionResponseDto> result = travelRegionService.findTravelRegionsByTravelId(travelId);

    //then
    assertEquals(2, result.size());
    verify(regionRepository, times(1))
        .findAllByTravelId(1L, Sort.by(Sort.Order.asc("region_order")));
  }

  @Test
  @Order(2)
  @DisplayName("여행지역 서비스 지역 등록 테스트1")
  public void 여행지역_서비스_지역_등록_테스트1(){
    //given
    Long travelId = 1L;
    String[] regions = {"대구", "서울"};
    Long creatorId = 1L;

    //when
    travelRegionService.createTravelRegions(travelId, regions, creatorId);

    //then
    verify(regionRepository, times(2)).save(any(TravelRegion.class));
  }

  @Test
  @Order(3)
  @DisplayName("여행지역 서비스 지역 등록 테스트2")
  public void 여행지역_서비스_지역_등록_테스트2(){
    //given
    Long travelId = 1L;
    String memberEmail = "test1@gmail.com";

    TravelRegionsCreateDto createDto = new TravelRegionsCreateDto();
    createDto.setRegionNames(new String[]{"서울", "대전", "대구", "부산"});

    when(memberRepository.getMemberIdByEmail(anyString())).thenReturn(1L);

    //when
    travelRegionService.createTravelRegions(travelId, createDto, memberEmail);

    //then
    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(regionRepository, times(4)).save(any(TravelRegion.class));
  }

  @Test
  @Order(4)
  @DisplayName("여행지역 서비스 지역 수정 테스트")
  public void 여행지역_서비스_지역_수정_테스트(){
    //given
    Long travelId = 1L;
    String memberEmail = "test1@gmail.com";

    TravelRegionsUpdateDto updateDto = new TravelRegionsUpdateDto();
    updateDto.setRegionNames(new String[]{"대구", "인천", "여수"});

    when(memberRepository.getMemberIdByEmail(anyString())).thenReturn(1L);

    //when
    travelRegionService.modifyTravelRegions(travelId, updateDto, memberEmail);

    //then
    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(regionRepository, times(1)).deleteByTravelId(1L);
    verify(regionRepository, times(3)).save(any(TravelRegion.class));
  }

}

TravelRegion Service Test Result

여행지역 - Controller 테스트

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

@DisplayName("여행지역 Controller 테스트")
@SpringBootTest
@ActiveProfiles("local")
@AutoConfigureMockMvc
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TravelRegionControllerMockTests {

  @Autowired
  MockMvc mockMvc;

  @MockBean
  TravelRegionService travelRegionService;

  @Autowired
  ObjectMapper objectMapper;

  private String accessToken;

  @BeforeEach
  public void setUp(){
    accessToken = "Bearer ";
    accessToken += "eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJ0ZXN0MUBnbWFpbC5jb20iLCJpYXQiOjE3MTcyMTM1MTksIkF1dGhvcml6YXRpb24iOiJVU0VSIiwiZXhwIjoxNzE3Mjk5OTE5fQ.o3HxOPYp2LyGrCRATvI74juqotBOp9k8VtkkHSShq987w5AmDk2ZzNoTmF82wy0h1yd0j59iMMlcQ7BjlfuNcQ";
  }

  @Test
  @Order(1)
  @DisplayName("여행지역 컨트롤러 여행지역 현황 테스트")
  public void 여행지역_컨트롤러_여행지역_현황_테스트() throws Exception {
    //given
    Long travelId = 1L;

    List<TravelRegionResponseDto> savedRegions = new ArrayList<>();
    TravelRegionResponseDto savedRegion1 = new TravelRegionResponseDto();
    savedRegion1.setTravelRegionId(1L);
    savedRegion1.setRegionName("대구");
    savedRegion1.setRegionOrder(1);
    savedRegions.add(savedRegion1);

    TravelRegionResponseDto savedRegion2 = new TravelRegionResponseDto();
    savedRegion2.setTravelRegionId(2L);
    savedRegion2.setRegionName("서울");
    savedRegion2.setRegionOrder(2);
    savedRegions.add(savedRegion2);

    when(travelRegionService.findTravelRegionsByTravelId(anyLong())).thenReturn(savedRegions);

    //when
    ResultActions actions = mockMvc.perform(
        get("/api/travel-region/regions/"+travelId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
    );

    //then
    actions
        .andExpect(status().isOk());
  }

  @Test
  @Order(2)
  @DisplayName("여행지역 컨트롤러 여행지역 등록 테스트")
  public void 여행지역_컨트롤러_여행지역_등록_테스트() throws Exception {
    //given
    Long travelId = 1L;

    TravelRegionsCreateDto createDto = new TravelRegionsCreateDto();
    createDto.setRegionNames(new String[]{"대구", "서울"});

    doNothing().when(travelRegionService).createTravelRegions(anyLong(), any(TravelRegionsCreateDto.class), anyString());

    //when
    ResultActions actions = mockMvc.perform(
        post("/api/travel-region/regions/"+travelId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsString(createDto))
    );

    //then
    actions
        .andExpect(status().isCreated());
  }

  @Test
  @Order(3)
  @DisplayName("여행지역 컨트롤러 여행지역 수정 테스트")
  public void 여행지역_컨트롤러_여행지역_수정_테스트() throws Exception {
    //given
    Long travelId = 1L;

    TravelRegionsUpdateDto updateDto = new TravelRegionsUpdateDto();
    updateDto.setRegionNames(new String[]{"대구", "서울"});

    doNothing().when(travelRegionService).modifyTravelRegions(anyLong(), any(TravelRegionsUpdateDto.class), anyString());

    //when
    ResultActions actions = mockMvc.perform(
        put("/api/travel-region/regions/"+travelId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsString(updateDto))
    );

    //then
    actions
        .andExpect(status().isNoContent());
  }
}

TravelRegion Service Test Result

슬라이스 테스트 - 여행계획

여행계획 - Repository 테스트

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

@DisplayName("여행계획 리포지토리 테스트")
@ExtendWith(MockitoExtension.class)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TravelPlanRepositoryMockTests {

  @Mock
  TravelPlanRepository planRepository;

  private DateTimeFormatter formatter;

  private TravelPlan savedPlan;

  private TravelPlan savedPlan2;

  @BeforeEach
  public void setUp(){
    formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss", Locale.KOREA);

    Point point = GeometryUtils.createLocationPoint(128.583052, 35.798838);

    savedPlan = new TravelPlan();
    savedPlan.setPlanId(1L);
    savedPlan.setTravelId(1L);
    savedPlan.setLocationName("식당1");
    savedPlan.setLocationPoint(GeometryUtils.createLocationPoint(128.583052, 35.798838));
    savedPlan.setLocationCategory("식당");
    savedPlan.setLocationAddress("대구 남구 대명동 OOO");
    savedPlan.setLocationRoadAddress("대구 남구 대명로 OOO");
    savedPlan.setLocationTelephone("070-0000-0000");
    savedPlan.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    savedPlan.setPlanOrder(1);
    savedPlan.setCreatorId(1L);
    savedPlan.setCreateDate(LocalDateTime.parse("2024-05-20 00:00:00", formatter));

    savedPlan2 = new TravelPlan();
    savedPlan2.setPlanId(2L);
    savedPlan2.setTravelId(1L);
    savedPlan2.setLocationName("식당2");
    savedPlan2.setLocationPoint(point);
    savedPlan2.setLocationCategory("식당");
    savedPlan2.setLocationAddress("대구 남구 대명동 OOO");
    savedPlan2.setLocationRoadAddress("대구 남구 대명로 OOO");
    savedPlan2.setLocationTelephone("070-0000-0000");
    savedPlan2.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    savedPlan2.setPlanOrder(2);
    savedPlan2.setCreatorId(1L);
    savedPlan2.setCreateDate(LocalDateTime.parse("2024-05-20 00:00:00", formatter));
  }

  @Test
  @Order(1)
  @DisplayName("여행계획 리포지토리 여행정보별 계획 현황 테스트")
  public void 여행계획_리포지토리_여행정보별_계획_현황_테스트(){
    //given
    Long travelId = 1L;
    Sort sort = Sort.by(Sort.Order.asc("plan_date"), Sort.Order.asc("plan_order"));

    List<TravelPlan> plans = new ArrayList<>();
    plans.add(savedPlan);
    plans.add(savedPlan2);

    when(planRepository.findTravelPlansByTravelId(anyLong(), any(Sort.class))).thenReturn(plans);

    //when
    List<TravelPlan> result = planRepository.findTravelPlansByTravelId(travelId, sort);

    //then
    assertEquals(2, result.size());
  }

  @Test
  @Order(2)
  @DisplayName("여행계획 리포지토리 계획 등록 테스트")
  public void 여행계획_리포지토리_계획_등록_테스트(){
    //given

    when(planRepository.save(any(TravelPlan.class))).thenReturn(savedPlan);

    //when
    TravelPlan result = planRepository.save(savedPlan);

    //then
    assertEquals(1L, result.getPlanId());
    assertEquals(1L, result.getTravelId());
    assertEquals("식당1", result.getLocationName());
    assertEquals(128.583052, result.getLocationPoint().getX());
    assertEquals(35.798838, result.getLocationPoint().getY());
    assertEquals("식당", result.getLocationCategory());
    assertEquals("대구 남구 대명동 OOO", result.getLocationAddress());
    assertEquals("대구 남구 대명로 OOO", result.getLocationRoadAddress());
    assertEquals("070-0000-0000", result.getLocationTelephone());
    assertEquals(1, result.getPlanOrder());
    assertEquals(1L, result.getCreatorId());
    assertEquals(LocalDateTime.parse("2024-06-01 00:00:00", formatter), result.getPlanDate());
    assertEquals(LocalDateTime.parse("2024-05-20 00:00:00", formatter), result.getCreateDate());
  }

  @Test
  @Order(3)
  @DisplayName("여행계획 리포지토리 계획 조회 테스트")
  public void 여행계획_리포지토리_계획_조회_테스트(){
    //given
    Long planId = 1L;

    when(planRepository.findById(anyLong())).thenReturn(Optional.of(savedPlan));

    //when
    TravelPlan result = planRepository.findById(planId).get();

    //then
    assertEquals(1L, result.getPlanId());
    assertEquals(1L, result.getTravelId());
    assertEquals("식당1", result.getLocationName());
    assertEquals(128.583052, result.getLocationPoint().getX());
    assertEquals(35.798838, result.getLocationPoint().getY());
    assertEquals("식당", result.getLocationCategory());
    assertEquals("대구 남구 대명동 OOO", result.getLocationAddress());
    assertEquals("대구 남구 대명로 OOO", result.getLocationRoadAddress());
    assertEquals("070-0000-0000", result.getLocationTelephone());
    assertEquals(1, result.getPlanOrder());
    assertEquals(1L, result.getCreatorId());
    assertEquals(LocalDateTime.parse("2024-06-01 00:00:00", formatter), result.getPlanDate());
    assertEquals(LocalDateTime.parse("2024-05-20 00:00:00", formatter), result.getCreateDate());
  }

  @Test
  @Order(4)
  @DisplayName("여행계획 리포지토리 계획 순서변경 테스트")
  public void 여행계획_리포지토리_계획_순서변경_테스트(){
    //given
    Long planId = 1L, travelId = 1L;
    Integer planOrder = 2;

    when(planRepository.findById(anyLong())).thenReturn(Optional.of(savedPlan));
    when(planRepository.findByTravelIdAndPlanOrder(anyLong(), anyInt())).thenReturn(Optional.of(savedPlan2));

    //when
    TravelPlan result = planRepository.findById(planId).get();
    result.modifyPlanOrder(planOrder, 1L);
    TravelPlan result2 = planRepository.findByTravelIdAndPlanOrder(travelId, planOrder).get();
    result2.modifyPlanOrder(result.getPlanOrder(), 1L);

    //then
    verify(planRepository, times(1)).findById(1L);
    verify(planRepository, times(1)).findByTravelIdAndPlanOrder(1L, 2);
  }

  @Test
  @Order(5)
  @DisplayName("여행계획 리포지토리 계획 수정 테스트")
  public void 여행계획_리포지토리_계획_수정_테스트(){
    //given
    Long planId = 1L;
    Long modifierId = 1L;

    TravelPlanUpdateDto updateDto = new TravelPlanUpdateDto();
    updateDto.setLocationName("OOO 박물관");
    updateDto.setLatitude(35.798838);
    updateDto.setLongitude(128.583052);
    updateDto.setLocationCategory("관광");
    updateDto.setLocationAddress("대구 달성군 OOO");
    updateDto.setLocationRoadAddress("대구 달성군 달성로 OOO");
    updateDto.setLocationTelephone("070-0000-0000");
    updateDto.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));

    when(planRepository.modifyTravelPlan(anyLong(), any(TravelPlanUpdateDto.class), anyLong())).thenReturn(1L);

    //when
    Long result = planRepository.modifyTravelPlan(planId, updateDto, modifierId);

    //then
    assertEquals(1, result);
  }

  @Test
  @Order(6)
  @DisplayName("여행계획 리포지토리 계획 삭제 테스트")
  public void 여행계획_리포지토리_계획_삭제_테스트(){
    //given
    Long planId = 1L;

    doNothing().when(planRepository).deleteById(anyLong());

    //when
    planRepository.deleteById(planId);

    //then
    verify(planRepository).deleteById(1L);
  }
}

TravelPlan Repository Test Result

여행계획 - Service 테스트

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

@DisplayName("여행계획 서비스 테스트")
@ExtendWith(MockitoExtension.class)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TravelPlanServiceMockTests {

  @InjectMocks
  TravelPlanService planService;

  @Mock
  TravelPlanRepository planRepository;

  @Mock
  MemberRepository memberRepository;

  private DateTimeFormatter formatter;

  private TravelPlan savedPlan;
  private TravelPlan savedPlan2;

  @BeforeEach
  public void setUp(){
    formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss", Locale.KOREA);

    Point point = GeometryUtils.createLocationPoint(128.583052, 35.798838);

    savedPlan = new TravelPlan();
    savedPlan.setPlanId(1L);
    savedPlan.setTravelId(1L);
    savedPlan.setLocationName("식당1");
    savedPlan.setLocationPoint(GeometryUtils.createLocationPoint(128.583052, 35.798838));
    savedPlan.setLocationCategory("식당");
    savedPlan.setLocationAddress("대구 남구 대명동 OOO");
    savedPlan.setLocationRoadAddress("대구 남구 대명로 OOO");
    savedPlan.setLocationTelephone("070-0000-0000");
    savedPlan.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    savedPlan.setPlanOrder(1);
    savedPlan.setCreatorId(1L);
    savedPlan.setCreateDate(LocalDateTime.parse("2024-05-20 00:00:00", formatter));

    savedPlan2 = new TravelPlan();
    savedPlan2.setPlanId(2L);
    savedPlan2.setTravelId(1L);
    savedPlan2.setLocationName("식당2");
    savedPlan2.setLocationPoint(point);
    savedPlan2.setLocationCategory("식당");
    savedPlan2.setLocationAddress("대구 남구 대명동 OOO");
    savedPlan2.setLocationRoadAddress("대구 남구 대명로 OOO");
    savedPlan2.setLocationTelephone("070-0000-0000");
    savedPlan2.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    savedPlan2.setPlanOrder(2);
    savedPlan2.setCreatorId(1L);
    savedPlan2.setCreateDate(LocalDateTime.parse("2024-05-20 00:00:00", formatter));
  }

  @Test
  @Order(1)
  @DisplayName("여행계획 리포지토리 여행정보별 계획 현황 테스트")
  public void 여행계획_리포지토리_여행정보별_계획_현황_테스트(){
    //given
    Long travelId = 1L;
    Sort sort = Sort.by(Sort.Order.asc("plan_date"), Sort.Order.asc("plan_order"));

    List<TravelPlan> savedPlans = new ArrayList<>();
    savedPlans.add(savedPlan);
    savedPlans.add(savedPlan2);

    when(planRepository.findTravelPlansByTravelId(anyLong(), any(Sort.class))).thenReturn(savedPlans);

    //when
    List<TravelPlanResponseDto> result = planService.findTravelPlansByTravelId(travelId);

    //then
    assertEquals(2, result.size());
    verify(planRepository, times(1)).findTravelPlansByTravelId(1L, sort);
  }

  @Test
  @Order(2)
  @DisplayName("여행계획 리포지토리 여행정보별 계획 등록 테스트")
  public void 여행계획_리포지토리_여행정보별_계획_등록_테스트(){
    //given
    Long travelId = 1L;
    String planDate = DateUtils.convertString(LocalDateTime.parse("2024-06-01 00:00:00", formatter), "yyyy-MM-dd");
    String memberEmail = "test1@gmail.com";

    TravelPlanCreateDto createDto = new TravelPlanCreateDto();
    createDto.setLocationName("식당1");
    createDto.setLongitude(35.798838);
    createDto.setLatitude(128.583052);
    createDto.setLocationCategory("식당");
    createDto.setLocationAddress("대구 남구 대명동 OOO");
    createDto.setLocationRoadAddress("대구 남구 대명로 OOO");
    createDto.setLocationTelephone("070-0000-0000");
    createDto.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));

    when(memberRepository.getMemberIdByEmail(anyString())).thenReturn(1L);
    when(planRepository.getMaxTravelPlanOrder(anyLong(), anyString())).thenReturn((int) 0);
    when(planRepository.save(any(TravelPlan.class))).thenReturn(savedPlan);

    //when
    Long result = planService.createTravelPlan(travelId, createDto, memberEmail);

    //then
    assertEquals(1L, result);
    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(planRepository, times(1)).getMaxTravelPlanOrder(1L, planDate);
    verify(planRepository, times(1)).save(any(TravelPlan.class));
  }

  @Test
  @Order(3)
  @DisplayName("여행계획 리포지토리 여행정보별 계획 조회 테스트")
  public void 여행계획_리포지토리_여행정보별_계획_조회_테스트(){
    //given
    Long planId = 1L;

    TravelPlanCreateDto createDto = new TravelPlanCreateDto();
    createDto.setLocationName("식당1");
    createDto.setLongitude(128.583052);
    createDto.setLatitude(35.798838);
    createDto.setLocationCategory("식당");
    createDto.setLocationAddress("대구 남구 대명동 OOO");
    createDto.setLocationRoadAddress("대구 남구 대명로 OOO");
    createDto.setLocationTelephone("070-0000-0000");
    createDto.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));

    when(planRepository.findById(anyLong())).thenReturn(Optional.ofNullable(savedPlan));

    //when
    TravelPlanResponseDto result = planService.findTravelPlan(planId);

    //then
    assertEquals(1L, result.getPlanId());
    assertEquals("식당1", result.getLocationName());
    assertEquals(128.583052, result.getLongitude());
    assertEquals(35.798838, result.getLatitude());
    assertEquals("식당", result.getLocationCategory());
    assertEquals("대구 남구 대명동 OOO", result.getLocationAddress());
    assertEquals("대구 남구 대명로 OOO", result.getLocationRoadAddress());
    assertEquals("070-0000-0000", result.getLocationTelephone());
    assertEquals(LocalDateTime.parse("2024-06-01 00:00:00", formatter), result.getPlanDate());
    assertEquals(1, result.getPlanOrder());

    verify(planRepository, times(1)).findById(1L);
  }

  @Test
  @Order(4)
  @DisplayName("여행계획 리포지토리 여행계획 수정 테스트")
  public void 여행계획_리포지토리_여행계획_수정_테스트(){
    //given
    Long travelId = 1L;
    String memberEmail = "test1@gmail.com";

    TravelPlanUpdateDto updateDto = new TravelPlanUpdateDto();
    updateDto.setLocationName("식당1");
    updateDto.setLongitude(128.583052);
    updateDto.setLatitude(35.798838);
    updateDto.setLocationCategory("식당");
    updateDto.setLocationAddress("대구 남구 대명동 OOO");
    updateDto.setLocationRoadAddress("대구 남구 대명로 OOO");
    updateDto.setLocationTelephone("070-0000-0000");
    updateDto.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));

    when(memberRepository.getMemberIdByEmail(anyString())).thenReturn(1L);
    when(planRepository.modifyTravelPlan(anyLong(), any(TravelPlanUpdateDto.class), anyLong())).thenReturn(1L);

    //when
    Long result = planService.modifyTravelPlan(travelId, updateDto, memberEmail);

    //then
    assertEquals(1L, result);
    verify(memberRepository, times(1)).getMemberIdByEmail("test1@gmail.com");
    verify(planRepository, times(1)).modifyTravelPlan(1L, updateDto, 1L);
  }
}

TravelPlan Service Test Result

여행계획 - Controller 테스트

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199

@DisplayName("여행계획 Controller 테스트")
@SpringBootTest
@ActiveProfiles("local")
@AutoConfigureMockMvc
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class TravelPlanControllerMockTests {

  @Autowired
  MockMvc mockMvc;

  @MockBean
  TravelPlanService planService;

  @Autowired
  ObjectMapper objectMapper;

  private DateTimeFormatter formatter;
  private TravelPlanResponseDto savedPlan;
  private TravelPlanResponseDto savedPlan2;

  private TravelPlanCreateDto createDto;

  private String accessToken;

  @BeforeEach
  public void setUp(){
    accessToken = "Bearer ";
    accessToken += "eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJ0ZXN0MUBnbWFpbC5jb20iLCJpYXQiOjE3MTcyMTM1MTksIkF1dGhvcml6YXRpb24iOiJVU0VSIiwiZXhwIjoxNzE3Mjk5OTE5fQ.o3HxOPYp2LyGrCRATvI74juqotBOp9k8VtkkHSShq987w5AmDk2ZzNoTmF82wy0h1yd0j59iMMlcQ7BjlfuNcQ";

    formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss", Locale.KOREA);

    savedPlan = new TravelPlanResponseDto();
    savedPlan.setPlanId(1L);
    savedPlan.setLocationName("식당1");
    savedPlan.setLongitude(128.583052);
    savedPlan.setLatitude(35.798838);
    savedPlan.setLocationCategory("식당");
    savedPlan.setLocationAddress("대구 남구 대명동 OOO");
    savedPlan.setLocationRoadAddress("대구 남구 대명로 OOO");
    savedPlan.setLocationTelephone("070-0000-0000");
    savedPlan.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    savedPlan.setPlanOrder(1);

    savedPlan2 = new TravelPlanResponseDto();
    savedPlan2.setPlanId(2L);
    savedPlan2.setLocationName("식당2");
    savedPlan.setLongitude(128.583052);
    savedPlan.setLatitude(35.798838);
    savedPlan2.setLocationCategory("식당");
    savedPlan2.setLocationAddress("대구 남구 대명동 OOO");
    savedPlan2.setLocationRoadAddress("대구 남구 대명로 OOO");
    savedPlan2.setLocationTelephone("070-0000-0000");
    savedPlan2.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
    savedPlan2.setPlanOrder(2);

    createDto = new TravelPlanCreateDto();
    createDto.setLocationName("식당1");
    createDto.setLongitude(128.583052);
    createDto.setLatitude(35.798838);
    createDto.setLocationCategory("식당");
    createDto.setLocationAddress("대구 남구 대명동 OOO");
    createDto.setLocationRoadAddress("대구 남구 대명로 OOO");
    createDto.setLocationTelephone("070-0000-0000");
    createDto.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));
  }

  @Test
  @Order(1)
  @DisplayName("여행계획 컨트롤러 여행정보별 현황 조회 테스트")
  public void 여행계획_컨트롤러_여행정보별_현황_조회_테스트() throws Exception {
    //given
    Long travelId = 1L;

    List<TravelPlanResponseDto> savedPlans = new ArrayList<>();
    savedPlans.add(savedPlan);
    savedPlans.add(savedPlan2);

    when(planService.findTravelPlansByTravelId(anyLong())).thenReturn(savedPlans);

    //when
    ResultActions actions = mockMvc.perform(
        get("/api/travel-plan/plans/"+travelId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
    );

    //then
    actions
        .andExpect(status().isOk());
  }

  @Test
  @Order(2)
  @DisplayName("여행계획 컨트롤러 여행정보별 등록 테스트")
  public void 여행계획_컨트롤러_여행정보별_등록_테스트() throws Exception {
    //given
    Long travelId = 1L;

    List<TravelPlanResponseDto> savedPlans = new ArrayList<>();
    savedPlans.add(savedPlan);
    savedPlans.add(savedPlan2);

    when(planService.createTravelPlan(anyLong(), any(TravelPlanCreateDto.class), anyString())).thenReturn(1L);

    //when
    ResultActions actions = mockMvc.perform(
        post("/api/travel-plan/"+travelId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsString(createDto))
    );

    //then
    actions
        .andExpect(status().isCreated());
  }

  @Test
  @Order(3)
  @DisplayName("여행계획 컨트롤러 여행계획 조회 테스트")
  public void 여행계획_컨트롤러_여행계획_조회_테스트() throws Exception {
    //given
    Long planId = 1L;

    when(planService.findTravelPlan(anyLong())).thenReturn(savedPlan);

    //when
    ResultActions actions = mockMvc.perform(
        get("/api/travel-plan/"+planId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
            .contentType(MediaType.APPLICATION_JSON)
    );

    //then
    actions
        .andExpect(status().isOk());
  }

  @Test
  @Order(4)
  @DisplayName("여행계획 컨트롤러 여행계획 수정 테스트")
  public void 여행계획_컨트롤러_여행계획_수정_테스트() throws Exception {
    //given
    Long planId = 1L;

    TravelPlanUpdateDto updateDto = new TravelPlanUpdateDto();
    updateDto.setLocationName("식당1");
    updateDto.setLongitude(128.583052);
    updateDto.setLatitude(35.798838);
    updateDto.setLocationCategory("식당");
    updateDto.setLocationAddress("대구 남구 대명동 OOO");
    updateDto.setLocationRoadAddress("대구 남구 대명로 OOO");
    updateDto.setLocationTelephone("070-0000-0000");
    updateDto.setPlanDate(LocalDateTime.parse("2024-06-01 00:00:00", formatter));

    when(planService.modifyTravelPlan(anyLong(), any(TravelPlanUpdateDto.class), anyString())).thenReturn(1L);

    //when
    ResultActions actions = mockMvc.perform(
        put("/api/travel-plan/"+planId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsString(updateDto))
    );

    //then
    actions
        .andExpect(status().isNoContent());
  }

  @Test
  @Order(5)
  @DisplayName("여행계획 컨트롤러 여행계획 순서변경 테스트")
  public void 여행계획_컨트롤러_여행계획_순서변경_테스트() throws Exception {
    //given
    Long planId = 1L;

    TravelPlanOrderUpdateDto updateDto = new TravelPlanOrderUpdateDto();
    updateDto.setPlanOrder(2);

    doNothing().when(planService).modifyTravelPlanOrder(anyLong(), any(TravelPlanOrderUpdateDto.class), anyString());

    //when
    ResultActions actions = mockMvc.perform(
        patch("/api/travel-plan/plan-order/"+planId)
            .accept(MediaType.APPLICATION_JSON)
            .header("access-token", accessToken)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsString(updateDto))
    );

    //then
    actions
        .andExpect(status().isNoContent());
  }
}

TravelPlan Controller Test Result

자동화 문서 도구 - Swagger (Spring Doc)

Travel Swagger UI 1

Travel Swagger UI 2

대용량 트래픽
대용량 트래픽 JUnit TDD Mockito Swagger SpringDoc
This post is licensed under CC BY 4.0 by the author.