Skip to content
This repository was archived by the owner on Dec 27, 2024. It is now read-only.

Commit 4c3a62e

Browse files
AlexanderGarifullinAlexanderGarifullin
committed
dev/codeforces/test Написат unit тесты для PlayerService
1 parent 66a5249 commit 4c3a62e

File tree

4 files changed

+317
-22
lines changed

4 files changed

+317
-22
lines changed

‎src/main/java/com/cf/cfteam/exceptions/codeforces/PlayerAlreadyInTeamException.java‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
package com.cf.cfteam.exceptions.codeforces;
2+
3+
import lombok.Getter;
4+
5+
@Getter
6+
public class PlayerAlreadyInTeamException extends RuntimeException {
7+
private final String login;
8+
9+
public PlayerAlreadyInTeamException(String login) {
10+
super("player.already_in_team");
11+
this.login = login;
12+
}
13+
}

‎src/main/java/com/cf/cfteam/services/codeforces/PlayerService.java‎

Lines changed: 11 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
package com.cf.cfteam.services.codeforces;
22

3+
import com.cf.cfteam.exceptions.codeforces.PlayerAlreadyInTeamException;
34
import com.cf.cfteam.exceptions.codeforces.PlayerNotFoundException;
45
import com.cf.cfteam.exceptions.codeforces.PlayerNotFromTeamException;
56
import com.cf.cfteam.exceptions.codeforces.TeamNotFoundException;
@@ -22,6 +23,7 @@ public class PlayerService {
2223
private final PlayerRepository playerRepository;
2324
private final TeamRepository teamRepository;
2425
private final PlayerMapper playerMapper;
26+
private final TeamPlayerLinker teamPlayerLinker;
2527

2628
public List<PlayerResponse> getAllPlayersByTeam(Long teamId) {
2729
var team = teamRepository.findById(teamId)
@@ -45,7 +47,11 @@ public PlayerResponse addPlayerToTeam(Long teamId, PlayerPayload payload) {
4547

4648
var player = createPlayer(payload);
4749

48-
linkTeamAndPlayer(team, player);
50+
if (team.getPlayers().contains(player)) {
51+
throw new PlayerAlreadyInTeamException(player.getLogin());
52+
}
53+
54+
teamPlayerLinker.linkTeamAndPlayer(team, player);
4955

5056
return playerMapper.fromEntityToResponse(player);
5157
}
@@ -62,9 +68,9 @@ public PlayerResponse updatePlayerInTeam(Long playerId, Long teamId, PlayerPaylo
6268
throw new PlayerNotFromTeamException(teamId, playerId);
6369
}
6470

65-
unlinkTeamAndPlayer(team, player);
71+
teamPlayerLinker.unlinkTeamAndPlayer(team, player);
6672
player = createPlayer(payload);
67-
linkTeamAndPlayer(team, player);
73+
teamPlayerLinker.linkTeamAndPlayer(team, player);
6874

6975
return playerMapper.fromEntityToResponse(player);
7076
}
@@ -85,37 +91,20 @@ public void deletePlayerFromTeam(Long playerId, Long teamId) {
8591
var team = teamRepository.findById(teamId)
8692
.orElseThrow(() -> new TeamNotFoundException(teamId));
8793

88-
unlinkTeamAndPlayer(team, player);
94+
teamPlayerLinker.unlinkTeamAndPlayer(team, player);
8995
}
9096

9197

9298
public void deleteAllPlayersFromTeam(Long teamId) {
9399
var team = teamRepository.findById(teamId)
94100
.orElseThrow(() -> new TeamNotFoundException(teamId));
95101

96-
var players = team.getPlayers();
102+
var players = List.copyOf(team.getPlayers());
97103

98104
players.forEach(player -> player.getTeams().remove(team));
99105
team.getPlayers().clear();
100106

101107
teamRepository.save(team);
102108
players.forEach(playerRepository::save);
103109
}
104-
105-
private void unlinkTeamAndPlayer(Team team, Player player) {
106-
team.getPlayers().remove(player);
107-
player.getTeams().remove(team);
108-
saveTeamAndPlayer(team, player);
109-
}
110-
111-
private void linkTeamAndPlayer(Team team, Player player) {
112-
team.getPlayers().add(player);
113-
player.getTeams().add(team);
114-
saveTeamAndPlayer(team, player);
115-
}
116-
117-
private void saveTeamAndPlayer(Team team, Player player) {
118-
teamRepository.save(team);
119-
playerRepository.save(player);
120-
}
121110
}

‎src/main/java/com/cf/cfteam/services/codeforces/TeamPlayerLinker.java‎

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
package com.cf.cfteam.services.codeforces;
2+
3+
import com.cf.cfteam.models.entities.codeforces.Player;
4+
import com.cf.cfteam.models.entities.codeforces.Team;
5+
import com.cf.cfteam.repositories.jpa.codeforces.PlayerRepository;
6+
import com.cf.cfteam.repositories.jpa.codeforces.TeamRepository;
7+
import lombok.RequiredArgsConstructor;
8+
import org.springframework.stereotype.Service;
9+
10+
@Service
11+
@RequiredArgsConstructor
12+
public class TeamPlayerLinker {
13+
14+
private final TeamRepository teamRepository;
15+
private final PlayerRepository playerRepository;
16+
17+
public void unlinkTeamAndPlayer(Team team, Player player) {
18+
team.getPlayers().remove(player);
19+
player.getTeams().remove(team);
20+
saveTeamAndPlayer(team, player);
21+
}
22+
23+
public void linkTeamAndPlayer(Team team, Player player) {
24+
team.getPlayers().add(player);
25+
player.getTeams().add(team);
26+
saveTeamAndPlayer(team, player);
27+
}
28+
29+
public void saveTeamAndPlayer(Team team, Player player) {
30+
teamRepository.save(team);
31+
playerRepository.save(player);
32+
}
33+
}

‎src/test/java/com/cf/cfteam/services/codeforces/PlayerServiceTest.java‎

Lines changed: 260 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,260 @@
1+
package com.cf.cfteam.services.codeforces;
2+
3+
4+
import com.cf.cfteam.exceptions.codeforces.*;
5+
import com.cf.cfteam.models.entities.codeforces.Player;
6+
import com.cf.cfteam.models.entities.codeforces.Team;
7+
import com.cf.cfteam.repositories.jpa.codeforces.PlayerRepository;
8+
import com.cf.cfteam.repositories.jpa.codeforces.TeamRepository;
9+
import com.cf.cfteam.transfer.payloads.codeforces.PlayerPayload;
10+
import com.cf.cfteam.transfer.responses.codeforces.PlayerResponse;
11+
import com.cf.cfteam.utils.codeforces.mappers.PlayerMapper;
12+
import org.junit.jupiter.api.BeforeEach;
13+
import org.junit.jupiter.api.Test;
14+
import org.junit.jupiter.api.extension.ExtendWith;
15+
import org.mockito.InjectMocks;
16+
import org.mockito.Mock;
17+
import org.mockito.junit.jupiter.MockitoExtension;
18+
import org.springframework.test.context.ActiveProfiles;
19+
20+
import java.util.ArrayList;
21+
import java.util.List;
22+
import java.util.Optional;
23+
24+
import static org.assertj.core.api.Assertions.assertThat;
25+
import static org.assertj.core.api.Assertions.assertThatThrownBy;
26+
import static org.mockito.Mockito.*;
27+
28+
@ActiveProfiles("test")
29+
@ExtendWith(MockitoExtension.class)
30+
class PlayerServiceTest {
31+
32+
@InjectMocks
33+
private PlayerService playerService;
34+
35+
@Mock
36+
private PlayerRepository playerRepository;
37+
38+
@Mock
39+
private TeamRepository teamRepository;
40+
41+
@Mock
42+
private PlayerMapper playerMapper;
43+
44+
@Mock
45+
private TeamPlayerLinker teamPlayerLinker;
46+
47+
private Team team;
48+
private Player player;
49+
private PlayerPayload playerPayload;
50+
private PlayerResponse playerResponse;
51+
52+
@BeforeEach
53+
void setUp() {
54+
team = Team.builder()
55+
.id(1L)
56+
.name("team")
57+
.description("team description")
58+
.build();
59+
60+
player = Player.builder()
61+
.id(1L)
62+
.login("login")
63+
.teams(List.of())
64+
.build();
65+
66+
67+
playerPayload = PlayerPayload.builder()
68+
.login("login")
69+
.build();
70+
71+
playerResponse = PlayerResponse.builder()
72+
.login("login")
73+
.rating(1000.)
74+
.id(1L)
75+
.build();
76+
}
77+
78+
79+
@Test
80+
void getAllPlayersByTeam_ShouldReturnPlayers_WhenTeamExists() {
81+
team.setPlayers(List.of(player));
82+
when(teamRepository.findById(1L)).thenReturn(Optional.of(team));
83+
84+
when(playerMapper.fromEntityToResponse(player)).thenReturn(playerResponse);
85+
86+
var players = playerService.getAllPlayersByTeam(1L);
87+
88+
assertThat(players).hasSize(1)
89+
.contains(playerResponse);
90+
}
91+
92+
@Test
93+
void getAllPlayersByTeam_ShouldThrowTeamNotFoundException_WhenTeamDoesNotExist() {
94+
when(teamRepository.findById(1L)).thenReturn(Optional.empty());
95+
96+
assertThatThrownBy(() -> playerService.getAllPlayersByTeam(1L))
97+
.isInstanceOf(TeamNotFoundException.class)
98+
.hasMessageContaining("id.not_found");
99+
}
100+
101+
@Test
102+
void getPlayerById_ShouldReturnPlayer_WhenPlayerExists() {
103+
when(playerRepository.findById(1L)).thenReturn(Optional.of(player));
104+
when(playerMapper.fromEntityToResponse(player)).thenReturn(playerResponse);
105+
106+
var result = playerService.getPlayerById(1L);
107+
108+
assertThat(result).isEqualTo(playerResponse);
109+
}
110+
111+
@Test
112+
void getPlayerById_ShouldThrowPlayerNotFoundException_WhenPlayerDoesNotExist() {
113+
when(playerRepository.findById(1L)).thenReturn(Optional.empty());
114+
115+
assertThatThrownBy(() -> playerService.getPlayerById(1L))
116+
.isInstanceOf(PlayerNotFoundException.class)
117+
.hasMessageContaining("id.not_found");
118+
}
119+
120+
@Test
121+
void addPlayerToTeam_ShouldAddPlayer_WhenTeamExists() {
122+
when(teamRepository.findById(1L)).thenReturn(Optional.of(team));
123+
124+
when(playerRepository.findByLogin("login")).thenReturn(Optional.of(player));
125+
126+
doNothing().when(teamPlayerLinker).linkTeamAndPlayer(team, player);
127+
128+
doReturn(playerResponse).when(playerMapper).fromEntityToResponse(player);
129+
130+
var result = playerService.addPlayerToTeam(1L, playerPayload);
131+
132+
assertThat(result).isEqualTo(playerResponse);
133+
verify(teamPlayerLinker, times(1)).linkTeamAndPlayer(team, player);
134+
}
135+
136+
@Test
137+
void addPlayerToTeam_ShouldThrowTeamNotFoundException_WhenTeamDoesNotExist() {
138+
when(teamRepository.findById(1L)).thenReturn(Optional.empty());
139+
140+
assertThatThrownBy(() -> playerService.addPlayerToTeam(1L, playerPayload))
141+
.isInstanceOf(TeamNotFoundException.class)
142+
.hasMessageContaining("id.not_found");
143+
}
144+
145+
@Test
146+
void addPlayerToTeam_ShouldThrowPlayerAlreadyInTeamException_WhenPlayerAlreadyInTeamException() {
147+
when(teamRepository.findById(1L)).thenReturn(Optional.of(team));
148+
when(playerRepository.findByLogin("login")).thenReturn(Optional.of(player));
149+
150+
team.setPlayers(List.of(player));
151+
152+
assertThatThrownBy(() -> playerService.addPlayerToTeam(1L, playerPayload))
153+
.isInstanceOf(PlayerAlreadyInTeamException.class)
154+
.hasMessageContaining("player.already_in_team");
155+
}
156+
157+
@Test
158+
void updatePlayerInTeam_ShouldUpdatePlayer_WhenTeamAndPlayerExistsAndFromOneTeam() {
159+
team.setPlayers(List.of(player));
160+
161+
when(playerRepository.findById(1L)).thenReturn(Optional.of(player));
162+
when(teamRepository.findById(1L)).thenReturn(Optional.of(team));
163+
164+
doNothing().when(teamPlayerLinker).unlinkTeamAndPlayer(team, player);
165+
when(playerRepository.findByLogin("login")).thenReturn(Optional.of(player));
166+
doNothing().when(teamPlayerLinker).linkTeamAndPlayer(team, player);
167+
168+
when(playerRepository.findByLogin("login")).thenReturn(Optional.of(player));
169+
170+
doReturn(playerResponse).when(playerMapper).fromEntityToResponse(player);
171+
172+
var result = playerService.updatePlayerInTeam(1L, 1L, playerPayload);
173+
174+
assertThat(result).isEqualTo(playerResponse);
175+
verify(teamPlayerLinker, times(1)).unlinkTeamAndPlayer(team, player);
176+
verify(teamPlayerLinker, times(1)).linkTeamAndPlayer(team, player);
177+
}
178+
179+
@Test
180+
void updatePlayerInTeam_ShouldThrowPlayerNotFoundException_WhenPlayerDoesNotExist() {
181+
when(playerRepository.findById(1L)).thenReturn(Optional.empty());
182+
183+
assertThatThrownBy(() -> playerService.updatePlayerInTeam(1L, 1L, playerPayload))
184+
.isInstanceOf(PlayerNotFoundException.class)
185+
.hasMessageContaining("id.not_found");
186+
}
187+
188+
@Test
189+
void updatePlayerInTeam_ShouldThrowTeamNotFoundException_WhenTeamDoesNotExist() {
190+
when(playerRepository.findById(1L)).thenReturn(Optional.of(player));
191+
when(teamRepository.findById(1L)).thenReturn(Optional.empty());
192+
193+
assertThatThrownBy(() -> playerService.updatePlayerInTeam(1L, 1L, playerPayload))
194+
.isInstanceOf(TeamNotFoundException.class)
195+
.hasMessageContaining("id.not_found");
196+
}
197+
198+
@Test
199+
void updatePlayerInTeam_ShouldThrowPlayerNotFromTeamException_WhenPlayerNotFromTeam() {
200+
when(playerRepository.findById(1L)).thenReturn(Optional.of(player));
201+
when(teamRepository.findById(1L)).thenReturn(Optional.of(team));
202+
203+
assertThatThrownBy(() -> playerService.updatePlayerInTeam(1L, 1L, playerPayload))
204+
.isInstanceOf(PlayerNotFromTeamException.class)
205+
.hasMessageContaining("player.not_from_team");
206+
}
207+
208+
@Test
209+
void deletePlayerFromTeam_ShouldDeletePlayerFromTeam_WhenTeamNadPlayerExists() {
210+
when(playerRepository.findById(1L)).thenReturn(Optional.of(player));
211+
when(teamRepository.findById(1L)).thenReturn(Optional.of(team));
212+
213+
doNothing().when(teamPlayerLinker).unlinkTeamAndPlayer(team, player);
214+
playerService.deletePlayerFromTeam(1L, 1L);
215+
verify(teamPlayerLinker, times(1)).unlinkTeamAndPlayer(team, player);
216+
}
217+
218+
@Test
219+
void deletePlayerFromTeam_ShouldThrowPlayerNotFoundException_WhenPlayerNotFound() {
220+
when(playerRepository.findById(1L)).thenReturn(Optional.empty());
221+
222+
assertThatThrownBy(() -> playerService.deletePlayerFromTeam(1L, 1L))
223+
.isInstanceOf(PlayerNotFoundException.class)
224+
.hasMessageContaining("id.not_found");
225+
}
226+
227+
@Test
228+
void deletePlayerFromTeam_ShouldThrowTeamNotFoundException_WhenTeamNotFound() {
229+
when(playerRepository.findById(1L)).thenReturn(Optional.of(player));
230+
when(teamRepository.findById(1L)).thenReturn(Optional.empty());
231+
232+
assertThatThrownBy(() -> playerService.deletePlayerFromTeam(1L, 1L))
233+
.isInstanceOf(TeamNotFoundException.class)
234+
.hasMessageContaining("id.not_found");
235+
}
236+
237+
@Test
238+
void deleteAllPlayersFromTeam_ShouldDeleteAllPlayersFromTeam_WhenTeamPlayerExists() {
239+
when(teamRepository.findById(1L)).thenReturn(Optional.of(team));
240+
team.setPlayers(new ArrayList<>(List.of(player)));
241+
player.setTeams(new ArrayList<>(List.of(team)));
242+
243+
doReturn(team).when(teamRepository).save(team);
244+
doReturn(player).when(playerRepository).save(player);
245+
246+
playerService.deleteAllPlayersFromTeam(1L);
247+
248+
verify(teamRepository, times(1)).save(team);
249+
verify(playerRepository, times(1)).save(player);
250+
}
251+
252+
@Test
253+
void deleteAllPlayersFromTeam_ShouldThrowTeamNotFoundException_WhenTeamNotFound() {
254+
when(teamRepository.findById(1L)).thenReturn(Optional.empty());
255+
256+
assertThatThrownBy(() -> playerService.deleteAllPlayersFromTeam(1L))
257+
.isInstanceOf(TeamNotFoundException.class)
258+
.hasMessageContaining("id.not_found");
259+
}
260+
}

0 commit comments

Comments
 (0)