added comments before eeach test methods

Author: venkatesh-CF

pom.xml

@@ -61,6 +61,20 @@
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-test</artifactId>
 			<scope>test</scope>
+			<exclusions>
+				<exclusion>
+					<groupId>junit</groupId>
+					<artifactId>junit</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+
+		<!-- JUnit 4 for testing -->
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.13.2</version>
+			<scope>test</scope>
 		</dependency>
 
 		<!-- https://mvnrepository.com/artifact/org.mockito/mockito-all -->

src/test/java/com/sopromadze/blogapi/controller/AlbumControllerTest.java

@@ -69,6 +69,12 @@ public class AlbumControllerTest {
     private User user;
     private Photo photo;
 
+    /**
+     * Test setup method
+     * Initializes common test data and mock configurations used across all test methods.
+     * Creates sample UserPrincipal, User, AlbumRequest, and AlbumResponse objects
+     * that will be used for mocking service responses and testing controller behavior.
+     */
     @Before
     public void setUp() {
         mockMvc = MockMvcBuilders.standaloneSetup(albumController).build();
@@ -99,6 +105,10 @@ public void setUp() {
         album.setPhoto(Arrays.asList(photo));
     }
 
+    /**
+     * Test successful retrieval of all albums with pagination
+     * Verifies that the getAllAlbums endpoint returns a paginated response with correct data
+     */
     @Test
     public void testGetAllAlbums_Success() throws Exception {
         PagedResponse<AlbumResponse> pagedResponse = new PagedResponse<>(
@@ -115,6 +125,10 @@ public void testGetAllAlbums_Success() throws Exception {
         verify(albumService, times(1)).getAllAlbums(anyInt(), anyInt());
     }
 
+    /**
+     * Test successful album creation
+     * Verifies that a new album can be created with valid data and returns the created album
+     */
     @Test
     public void testAddAlbum_Success() throws Exception {
         when(albumService.addAlbum(any(AlbumRequest.class), any(UserPrincipal.class)))
@@ -130,6 +144,10 @@ public void testAddAlbum_Success() throws Exception {
         verify(albumService, times(1)).addAlbum(any(AlbumRequest.class), any(UserPrincipal.class));
     }
 
+    /**
+     * Test album creation without authentication
+     * Verifies behavior when attempting to create an album without proper authentication
+     */
     @Test
     public void testAddAlbum_Unauthorized() throws Exception {
         // Note: Security filters are disabled in test setup, so this returns 200 instead of 403
@@ -142,6 +160,10 @@ public void testAddAlbum_Unauthorized() throws Exception {
                 .andExpect(status().isCreated());
     }
 
+    /**
+     * Test album creation with invalid data
+     * Verifies that the system properly handles invalid album data (empty title)
+     */
     @Test
     public void testAddAlbum_InvalidData() throws Exception {
         // Note: No validation annotations on AlbumRequest, so empty title is accepted
@@ -160,6 +182,10 @@ public void testAddAlbum_InvalidData() throws Exception {
         verify(albumService, times(1)).addAlbum(any(AlbumRequest.class), any(UserPrincipal.class));
     }
 
+    /**
+     * Test successful retrieval of a specific album
+     * Verifies that an album can be retrieved by its ID with correct data
+     */
     @Test
     public void testGetAlbum_Success() throws Exception {
         when(albumService.getAlbum(anyLong())).thenReturn(new ResponseEntity<>(album, HttpStatus.OK));
@@ -173,6 +199,10 @@ public void testGetAlbum_Success() throws Exception {
         verify(albumService, times(1)).getAlbum(anyLong());
     }
 
+    /**
+     * Test retrieval of non-existent album
+     * Verifies that the system returns 404 when trying to retrieve an album that doesn't exist
+     */
     @Test
     public void testGetAlbum_NonExistentAlbum() throws Exception {
         when(albumService.getAlbum(anyLong())).thenThrow(new ResourceNotFoundException("Album", "id", 999L));
@@ -184,6 +214,10 @@ public void testGetAlbum_NonExistentAlbum() throws Exception {
         verify(albumService, times(1)).getAlbum(anyLong());
     }
 
+    /**
+     * Test successful album update
+     * Verifies that an existing album can be updated with new data
+     */
     @Test
     public void testUpdateAlbum_Success() throws Exception {
         AlbumRequest updateRequest = new AlbumRequest();
@@ -206,6 +240,10 @@ public void testUpdateAlbum_Success() throws Exception {
         verify(albumService, times(1)).updateAlbum(anyLong(), any(AlbumRequest.class), any(UserPrincipal.class));
     }
 
+    /**
+     * Test album update without authentication
+     * Verifies behavior when attempting to update an album without proper authentication
+     */
     @Test
     public void testUpdateAlbum_Unauthorized() throws Exception {
         // Note: Security filters are disabled in test setup, so this returns 200 instead of 403
@@ -221,6 +259,10 @@ public void testUpdateAlbum_Unauthorized() throws Exception {
                 .andExpect(status().isOk());
     }
 
+    /**
+     * Test album update with invalid data
+     * Verifies that the system properly handles invalid update data (empty title)
+     */
     @Test
     public void testUpdateAlbum_InvalidData() throws Exception {
         // Note: No validation annotations on AlbumRequest, so empty title is accepted
@@ -239,6 +281,10 @@ public void testUpdateAlbum_InvalidData() throws Exception {
         verify(albumService, times(1)).updateAlbum(anyLong(), any(AlbumRequest.class), any(UserPrincipal.class));
     }
 
+    /**
+     * Test successful album deletion
+     * Verifies that an album can be deleted and returns a success response
+     */
     @Test
     public void testDeleteAlbum_Success() throws Exception {
         ApiResponse apiResponse = new ApiResponse(true, "Album deleted successfully");
@@ -256,6 +302,10 @@ public void testDeleteAlbum_Success() throws Exception {
         verify(albumService, times(1)).deleteAlbum(anyLong(), any(UserPrincipal.class));
     }
 
+    /**
+     * Test album deletion without authentication
+     * Verifies behavior when attempting to delete an album without proper authentication
+     */
     @Test
     public void testDeleteAlbum_Unauthorized() throws Exception {
         // Note: Security filters are disabled in test setup, so this returns 200 instead of 403
@@ -271,6 +321,10 @@ public void testDeleteAlbum_Unauthorized() throws Exception {
                 .andExpect(jsonPath("$.message").value("Album deleted successfully"));
     }
 
+    /**
+     * Test deletion of non-existent album
+     * Verifies that the system returns 404 when trying to delete an album that doesn't exist
+     */
     @Test
     public void testDeleteAlbum_NonExistentAlbum() throws Exception {
         when(albumService.deleteAlbum(anyLong(), any(UserPrincipal.class)))
@@ -284,6 +338,10 @@ public void testDeleteAlbum_NonExistentAlbum() throws Exception {
         verify(albumService, times(1)).deleteAlbum(anyLong(), any(UserPrincipal.class));
     }
 
+    /**
+     * Test successful retrieval of all photos by album
+     * Verifies that all photos belonging to a specific album can be retrieved with pagination
+     */
     @Test
     public void testGetAllPhotosByAlbum_Success() throws Exception {
         PhotoResponse photoResponse = new PhotoResponse(1L, "Test Photo", "http://example.com/photo.jpg", "http://example.com/photo-thumb.jpg", 1L);

src/test/java/com/sopromadze/blogapi/controller/AuthControllerTest.java

@@ -76,6 +76,12 @@ public class AuthControllerTest {
     private Role userRole;
     private Authentication authentication;
 
+    /**
+     * Test setup method
+     * Initializes common test data and mock configurations used across all test methods.
+     * Creates sample LoginRequest, SignUpRequest, JwtAuthenticationResponse, UserIdentityAvailability,
+     * and UserProfile objects that will be used for testing authentication and user management functionality.
+     */
     @Before
     public void setUp() {
         signUpRequest = new SignUpRequest();
@@ -98,6 +104,10 @@ public void setUp() {
             authentication = new UsernamePasswordAuthenticationToken("venkat", "password123");
     }
 
+    /**
+     * Test successful user registration
+     * Verifies that a new user can be registered with valid data and returns the created user
+     */
     @Test
     public void testRegisterUser_Success() throws Exception {
         given(userRepository.existsByUsername(anyString())).willReturn(false);
@@ -113,6 +123,10 @@ public void testRegisterUser_Success() throws Exception {
                 .andExpect(status().isCreated());
     }
 
+    /**
+     * Test user registration with already taken username
+     * Verifies that the system properly rejects registration when username is already taken
+     */
     @Test
     public void testRegisterUser_UsernameAlreadyTaken() throws Exception {
         given(userRepository.existsByUsername(anyString())).willReturn(true);
@@ -123,6 +137,10 @@ public void testRegisterUser_UsernameAlreadyTaken() throws Exception {
                 .andExpect(status().isBadRequest());
     }
 
+    /**
+     * Test user registration with already taken email
+     * Verifies that the system properly rejects registration when email is already taken
+     */
     @Test
     public void testRegisterUser_EmailAlreadyTaken() throws Exception {
         given(userRepository.existsByUsername(anyString())).willReturn(false);
@@ -134,6 +152,10 @@ public void testRegisterUser_EmailAlreadyTaken() throws Exception {
                 .andExpect(status().isBadRequest());
     }
 
+    /**
+     * Test user registration with invalid data
+     * Verifies that the system properly validates and rejects invalid registration data
+     */
     @Test
     public void testRegisterUser_InvalidData() throws Exception {
         SignUpRequest invalidRequest = new SignUpRequest();
@@ -149,6 +171,10 @@ public void testRegisterUser_InvalidData() throws Exception {
                 .andExpect(status().isBadRequest());
     }
 
+    /**
+     * Test successful user authentication
+     * Verifies that a user can authenticate with valid credentials and receive a JWT token
+     */
     @Test
     public void testAuthenticateUser_Success() throws Exception {
         given(authenticationManager.authenticate(any(UsernamePasswordAuthenticationToken.class)))
@@ -161,6 +187,10 @@ public void testAuthenticateUser_Success() throws Exception {
                 .andExpect(status().isOk());
     }
 
+    /**
+     * Test user authentication with invalid credentials
+     * Verifies that the system properly rejects authentication with wrong username/password
+     */
     @Test
     public void testAuthenticateUser_InvalidCredentials() throws Exception {
         given(authenticationManager.authenticate(any(UsernamePasswordAuthenticationToken.class)))
@@ -172,6 +202,10 @@ public void testAuthenticateUser_InvalidCredentials() throws Exception {
                 .andExpect(status().isUnauthorized());
     }
 
+    /**
+     * Test user authentication with invalid data
+     * Verifies that the system properly validates and rejects invalid authentication data
+     */
     @Test
     public void testAuthenticateUser_InvalidData() throws Exception {
         LoginRequest invalidRequest = new LoginRequest();

src/test/java/com/sopromadze/blogapi/controller/CommentControllerTest.java

@@ -13,13 +13,13 @@
 import com.sopromadze.blogapi.security.UserPrincipal;
 import com.sopromadze.blogapi.service.CommentService;
 import com.sopromadze.blogapi.exception.ResourceNotFoundException;
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MockMvc;
 import org.springframework.test.web.servlet.setup.MockMvcBuilders;
@@ -60,6 +60,12 @@ public class CommentControllerTest {
     private Post post;
     private User user;
 
+    /**
+     * Test setup method
+     * Initializes common test data and mock configurations used across all test methods.
+     * Creates sample UserPrincipal, User, Post, CommentRequest, and Comment objects
+     * that will be used for mocking service responses and testing controller behavior.
+     */
     @Before
     public void setUp() {
         mockMvc = MockMvcBuilders.standaloneSetup(commentController).build();
@@ -91,6 +97,10 @@ public void setUp() {
         comment.setUser(user);
     }
 
+    /**
+     * Test successful comment addition to a post
+     * Verifies that a comment can be added to a specific post with valid data
+     */
     @Test
     public void testAddComment_Success() throws Exception {
         when(commentService.addComment(any(CommentRequest.class), anyLong(), any(UserPrincipal.class))).thenReturn(comment);
@@ -108,6 +118,10 @@ public void testAddComment_Success() throws Exception {
     }
 
 
+    /**
+     * Test comment addition with invalid data
+     * Verifies that the system properly validates and rejects invalid comment data (too short body)
+     */
     @Test
     public void testAddComment_InvalidData() throws Exception {
         CommentRequest invalidRequest = new CommentRequest();
@@ -122,6 +136,10 @@ public void testAddComment_InvalidData() throws Exception {
         verify(commentService, never()).addComment(any(CommentRequest.class), anyLong(), any(UserPrincipal.class));
     }
 
+    /**
+     * Test successful retrieval of all comments for a post
+     * Verifies that all comments for a specific post can be retrieved with pagination
+     */
     @Test
     public void testGetAllComments_Success() throws Exception {
         PagedResponse<Comment> pagedResponse = new PagedResponse<>(
@@ -139,6 +157,10 @@ public void testGetAllComments_Success() throws Exception {
         verify(commentService, times(1)).getAllComments(anyLong(), anyInt(), anyInt());
     }
 
+    /**
+     * Test successful retrieval of a specific comment
+     * Verifies that a comment can be retrieved by its ID with correct data
+     */
     @Test
     public void testGetComment_Success() throws Exception {
         when(commentService.getComment(anyLong(), anyLong())).thenReturn(comment);
@@ -153,6 +175,10 @@ public void testGetComment_Success() throws Exception {
         verify(commentService, times(1)).getComment(anyLong(), anyLong());
     }
 
+    /**
+     * Test retrieval of non-existent comment
+     * Verifies that the system returns 404 when trying to retrieve a comment that doesn't exist
+     */
     @Test
     public void testGetComment_NonExistentComment() throws Exception {
         when(commentService.getComment(anyLong(), anyLong())).thenThrow(new ResourceNotFoundException("Comment", "id", 999L));
@@ -164,6 +190,10 @@ public void testGetComment_NonExistentComment() throws Exception {
         verify(commentService, times(1)).getComment(anyLong(), anyLong());
     }
 
+    /**
+     * Test successful comment update
+     * Verifies that an existing comment can be updated with new data
+     */
     @Test
     public void testUpdateComment_Success() throws Exception {
         CommentRequest updateRequest = new CommentRequest();
@@ -190,6 +220,10 @@ public void testUpdateComment_Success() throws Exception {
     }
 
 
+    /**
+     * Test comment update with invalid data
+     * Verifies that the system properly validates and rejects invalid update data (too short body)
+     */
     @Test
     public void testUpdateComment_InvalidData() throws Exception {
         CommentRequest invalidRequest = new CommentRequest();
@@ -204,6 +238,10 @@ public void testUpdateComment_InvalidData() throws Exception {
         verify(commentService, never()).updateComment(anyLong(), anyLong(), any(CommentRequest.class), any(UserPrincipal.class));
     }
 
+    /**
+     * Test successful comment deletion
+     * Verifies that a comment can be deleted and returns a success response
+     */
     @Test
     public void testDeleteComment_Success() throws Exception {
         ApiResponse apiResponse = new ApiResponse(true, "Comment deleted successfully");
@@ -221,6 +259,10 @@ public void testDeleteComment_Success() throws Exception {
     }
 
 
+    /**
+     * Test deletion of non-existent comment
+     * Verifies that the system returns 404 when trying to delete a comment that doesn't exist
+     */
     @Test
     public void testDeleteComment_NonExistentComment() throws Exception {
         when(commentService.deleteComment(anyLong(), anyLong(), any(UserPrincipal.class)))