From e35c6ace5a49f9032d365c7b85b7af1ed9b68170 Mon Sep 17 00:00:00 2001 From: thuan Date: Thu, 28 Dec 2023 09:50:31 +0700 Subject: [PATCH] 28/12: write test for AlbumService --- .../java/com/spotify/app/model/Album.java | 9 + .../com/spotify/app/service/AlbumService.java | 38 ++-- .../spotify/app/album/AlbumServiceTest.java | 201 ++++++++++++++++-- 3 files changed, 209 insertions(+), 39 deletions(-) diff --git a/src/main/java/com/spotify/app/model/Album.java b/src/main/java/com/spotify/app/model/Album.java index 4726fc1..be35eb7 100644 --- a/src/main/java/com/spotify/app/model/Album.java +++ b/src/main/java/com/spotify/app/model/Album.java @@ -83,4 +83,13 @@ public void removeSong(Song song) { } } } + + public Album(Long id, String name) { + this.id = id; + this.name = name; + } + + public Album(String name) { + this.name = name; + } } diff --git a/src/main/java/com/spotify/app/service/AlbumService.java b/src/main/java/com/spotify/app/service/AlbumService.java index 7d2795d..b24b615 100644 --- a/src/main/java/com/spotify/app/service/AlbumService.java +++ b/src/main/java/com/spotify/app/service/AlbumService.java @@ -124,8 +124,14 @@ public void addSong(Long albumId, Long songId) { } public void removeSong(Long albumId, Long songId) { - Album album = get(albumId); - Song song = getSongBySongId(songId); + Album album = albumRepository. + findById(albumId). + orElseThrow(() -> + new ResourceNotFoundException(String.format("album with id [%d] not found", albumId))); + Song song = songRepository. + findById(songId). + orElseThrow(() -> + new ResourceNotFoundException(String.format("song with id %d not found", songId))) ; album.removeSong(song); albumRepository.save(album); } @@ -136,7 +142,9 @@ public List findAll() { public Long addAlbum(Long userId, AlbumRequest request) { - User user = getUserByUserId(userId); + User user = userRepository. + findById(userId). + orElseThrow(() -> new ResourceNotFoundException(String.format("user %d not found", userId))); Album album = albumRequestMapper.dtoToEntity(request); album.setReleaseDate(LocalDateTime.now()); album.setUser(user); @@ -145,7 +153,11 @@ public Long addAlbum(Long userId, AlbumRequest request) { } public void updateAlbum(Long albumId, AlbumRequest request) { - Album album = get(albumId); + Album album = albumRepository. + findById(albumId). + orElseThrow(() -> + new ResourceNotFoundException(String.format("album with id [%d] not found", albumId))); + if(!request.name().equals(album.getName())){ album.setName(request.name()); } @@ -157,19 +169,6 @@ public List findAlbumByUserId(Long userId) { return albums.stream().map(albumResponseMapper::albumToAlbumResponse).toList(); } - public User getUserByUserId(Long userId) { - return userRepository. - findById(userId). - orElseThrow(() -> new ResourceNotFoundException(String.format("user %d not found", userId))); - } - - - public Song getSongBySongId(Long songId) { - return songRepository. - findById(songId). - orElseThrow(() -> - new ResourceNotFoundException(String.format("song with id %d not found",songId))) ; - } public String convertTotalTime(List albumSongs) { long totalTime = albumSongs.stream() @@ -200,7 +199,10 @@ public AlbumResponse findByIdByAdmin(Long albumId) { } public String updateStatusAlbum(Long albumId) { - Album album = get(albumId); + Album album = albumRepository. + findById(albumId). + orElseThrow(() -> + new ResourceNotFoundException(String.format("album with id [%d] not found", albumId))); album.setStatus(!album.isStatus()); albumRepository.saveAndFlush(album); String status = !album.isStatus() ? "enabled" : "disabled"; diff --git a/src/test/java/com/spotify/app/album/AlbumServiceTest.java b/src/test/java/com/spotify/app/album/AlbumServiceTest.java index 8d1dd45..ed22bb4 100644 --- a/src/test/java/com/spotify/app/album/AlbumServiceTest.java +++ b/src/test/java/com/spotify/app/album/AlbumServiceTest.java @@ -2,8 +2,10 @@ import com.spotify.app.dto.AlbumDTO; +import com.spotify.app.dto.request.AlbumRequest; import com.spotify.app.dto.response.SongResponse; import com.spotify.app.dto.response.UserNoAssociationResponse; +import com.spotify.app.exception.ResourceNotFoundException; import com.spotify.app.mapper.AlbumMapper; import com.spotify.app.mapper.AlbumRequestMapper; import com.spotify.app.mapper.AlbumResponseMapper; @@ -22,6 +24,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.beans.factory.annotation.Autowired; @@ -31,7 +34,7 @@ import java.util.Optional; import static org.assertj.core.api.AssertionsForClassTypes.assertThat; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.*; @@ -126,46 +129,202 @@ void canGetAlbumById () { assertThat(actual).isEqualTo(album); } - // add song -// @Test -// public void canAddSong () { -// // given -// Long albumId = 2L; -// Long songId = 1L; -// Album album2 = new Album(albumId); -// Song song3 = new Song(songId); -// AlbumSong albumSong = new AlbumSong(album2, song3); -// -// List albumSongList = List.of(albumSong); -// album2.setAlbumSongList(albumSongList); -// // when -// when(albumRepository.findById(albumId)).thenReturn(Optional.of(album2)); -// when(songRepository.findById(songId)).thenReturn(Optional.of(song3)); -// albumService.addSong(albumId, songId); -// } + @Test + public void canAddSong () { + Long albumId = 1L; + Long songId = 2L; + + // Mocking the Album and Song + Album album = new Album(); + album.setId(albumId); + + Song song = new Song(); + song.setId(songId); + + // Mocking the repository responses + Mockito.when(albumRepository.findById(albumId)).thenReturn(Optional.of(album)); + Mockito.when(songRepository.findById(songId)).thenReturn(Optional.of(song)); + Mockito.when(albumRepository.save(Mockito.any(Album.class))).thenReturn(album); + + // Calling the service method + albumService.addSong(albumId, songId); + + // Verifying that the repository methods were called + Mockito.verify(albumRepository, Mockito.times(1)).findById(albumId); + Mockito.verify(songRepository, Mockito.times(1)).findById(songId); + Mockito.verify(albumRepository, Mockito.times(1)).save(album); + } + + @Test + public void shouldThrowExceptionWithNonexistentAlbum () { + Long albumId = 1L; + Long songId = 2L; + Mockito.when(albumRepository.findById(albumId)).thenReturn(Optional.empty()); + assertThrows(ResourceNotFoundException.class, () -> { + albumService.addSong(albumId, songId); + }); + Mockito.verify(albumRepository, Mockito.times(1)).findById(albumId); + Mockito.verify(songRepository, Mockito.never()).findById(albumId); + Mockito.verify(albumRepository, Mockito.never()).save(Mockito.any(Album.class)); + + } // remove song @Test - public void canRemoveSong () { + public void canRemoveSong() { + // Sample data + Long albumId = 1L; + Long songId = 2L; + + // Mocking the Album and Song + Album album = new Album(); + album.setId(albumId); + Song song = new Song(); + song.setId(songId); + + // Mocking the repository responses + Mockito.when(albumRepository.findById(albumId)).thenReturn(Optional.of(album)); + Mockito.when(songRepository.findById(songId)).thenReturn(Optional.of(song)); + Mockito.when(albumRepository.save(Mockito.any(Album.class))).thenReturn(album); + + // Calling the service method + albumService.removeSong(albumId, songId); + + // Verifying that the repository methods were called + Mockito.verify(albumRepository, Mockito.times(1)).findById(albumId); + Mockito.verify(songRepository, Mockito.times(1)).findById(songId); + Mockito.verify(albumRepository, Mockito.times(1)).save(album); + } + + @Test + public void cannotRemoveSongWithNonexistentAlbum() { + // Sample data + Long albumId = 1L; + Long songId = 2L; + + // Mocking the repository responses + Mockito.when(albumRepository.findById(albumId)).thenReturn(Optional.empty()); + + // Calling the service method and expecting an exception + assertThrows(ResourceNotFoundException.class, () -> { + albumService.removeSong(albumId, songId); + }); + + // Verifying that the repository methods were called + Mockito.verify(albumRepository, Mockito.times(1)).findById(albumId); + Mockito.verify(songRepository, Mockito.never()).findById(songId); + Mockito.verify(albumRepository, Mockito.never()).save(Mockito.any(Album.class)); } - // add album @Test public void canAddAlbum () { + // given + Long userId = 1L; + Long albumId= 1L; + AlbumRequest request = new AlbumRequest("album_name"); + Album album1 = new Album(albumId,"album_name"); + User user1 = new User(userId); + // when + Mockito.when(userRepository.findById(userId)).thenReturn(Optional.of(user1)); + Mockito.when(albumRequestMapper.dtoToEntity(request)).thenReturn(album1); + Mockito.when(albumRepository.save(album1)).thenReturn(album1); + var actualId = albumService.addAlbum(userId, request); + + // then + assertEquals(actualId, albumId); + Mockito.verify(userRepository, Mockito.times(1)).findById(userId); + Mockito.verify(albumRepository, Mockito.times(1)).save(Mockito.any(Album.class)); + } + + @Test + public void cannotAddAlbumWithNonexistentUser() { + // Sample data + Long userId = 1L; + String albumName = "albumName"; + AlbumRequest albumRequest = new AlbumRequest(albumName); + + // Mocking the UserRepository response + Mockito.when(userRepository.findById(userId)).thenReturn(Optional.empty()); + + // Calling the service method and expecting an exception + assertThrows(ResourceNotFoundException.class, () -> { + albumService.addAlbum(userId, albumRequest); + }); + + // Verifying that the repository methods were called + Mockito.verify(userRepository, Mockito.times(1)).findById(userId); + Mockito.verify(albumRequestMapper, Mockito.never()).dtoToEntity(Mockito.any(AlbumRequest.class)); + Mockito.verify(albumRepository, Mockito.never()).save(Mockito.any(Album.class)); } // remove album @Test - public void canRemoveAlbum () { + public void canUpdateAlbum () { + // given + Long albumId = 1L; + String updatedName = "Updated Album Name"; + Album existingAlbum = new Album(); + existingAlbum.setId(albumId); + existingAlbum.setName("Old Album Name"); + AlbumRequest request = new AlbumRequest(updatedName); + + // when + Mockito.when(albumRepository.findById(albumId)).thenReturn(Optional.of(existingAlbum)); + Mockito.when(albumRepository.save(Mockito.any(Album.class))).thenReturn(existingAlbum); + albumService.updateAlbum(albumId, request); + // then + Mockito.verify(albumRepository, Mockito.times(1)).findById(albumId); + Mockito.verify(albumRepository, Mockito.times(1)).save(existingAlbum); + assertEquals(updatedName, existingAlbum.getName()); + + } + + @Test + public void cannotUpdateAlbumWithNonexistentAlbum() { + // Sample data + Long albumId = 1L; + String updatedName = "Updated Album Name"; + + // Mocking the AlbumRepository response + Mockito.when(albumRepository.findById(albumId)).thenReturn(Optional.empty()); + // Calling the service method and expecting an exception + assertThrows(ResourceNotFoundException.class, () -> { + AlbumRequest updateRequest = new AlbumRequest(updatedName); + albumService.updateAlbum(albumId, updateRequest); + }); + + // Verifying that the repository methods were called + Mockito.verify(albumRepository, Mockito.times(1)).findById(albumId); + Mockito.verify(albumRepository, Mockito.never()).save(Mockito.any(Album.class)); } // update status @Test public void canUpdateStatus () { + Long albumId = 1L; + + // Mocking the AlbumRepository response + Album existingAlbum = new Album(); + existingAlbum.setId(albumId); + existingAlbum.setStatus(true); + + Mockito.when(albumRepository.findById(albumId)).thenReturn(Optional.of(existingAlbum)); + existingAlbum.setStatus(false); + Mockito.when(albumRepository.saveAndFlush(Mockito.any(Album.class))).thenAnswer(invocation -> invocation.getArgument(0)); + + // Calling the service method + String result = albumService.updateStatusAlbum(albumId); + + // Verifying that the repository methods were called + Mockito.verify(albumRepository, Mockito.times(1)).findById(albumId); + Mockito.verify(albumRepository, Mockito.times(1)).saveAndFlush(existingAlbum); + // Verifying the result + String expectedStatusMessage = "album with id: 1 is disabled"; // Assuming initial status is true + assertEquals(expectedStatusMessage, result); }