diff --git a/pom.xml b/pom.xml index d5e071f..1a54625 100644 --- a/pom.xml +++ b/pom.xml @@ -1,96 +1,143 @@ - - - 4.0.0 - - org.springframework.boot - spring-boot-starter-parent - 3.0.6 - - - com.medeiros - SPRINGProject - 0.0.1-SNAPSHOT - SPRINGProject - Demo project for Spring Boot - - 20 - - 6.0.3 - - - - org.springframework.boot - spring-boot-starter-data-jpa - - - org.springframework.boot - spring-boot-starter-web - - - - org.springframework.boot - spring-boot-devtools - runtime - true - - - com.mysql - mysql-connector-j - runtime - - - org.springframework.boot - spring-boot-starter-test - test - - - - org.springframework.boot - spring-boot-starter-thymeleaf - 3.0.6 - - - - org.springframework.boot - spring-boot-starter-security - - - - io.jsonwebtoken - jjwt-api - 0.11.5 - - - - - - - org.springframework.security - spring-security-core - 6.0.3 - - - - - - - io.jsonwebtoken - jjwt-impl - 0.11.5 - runtime - - - - - - - - - org.springframework.boot - spring-boot-maven-plugin - - - - - + + + 4.0.0 + + org.springframework.boot + spring-boot-starter-parent + 3.0.6 + + + + com.medeiros + SPRINGProject + 0.0.1-SNAPSHOT + SPRINGProject + Demo project for Spring Boot + + 20 + + 6.0.3 + + + + org.springframework.boot + spring-boot-starter-data-jpa + + + org.springframework.boot + spring-boot-starter-web + + + org.springframework.boot + spring-boot-devtools + runtime + true + + + com.mysql + mysql-connector-j + runtime + + + org.springframework.boot + spring-boot-starter-test + test + + + org.springframework.boot + spring-boot-starter-thymeleaf + 3.0.6 + + + org.springframework.boot + spring-boot-starter-security + + + io.spring.javaformat + spring-javaformat-formatter + 0.0.40 + + + + + io.jsonwebtoken + jjwt-api + 0.11.5 + + + + org.springframework.security + spring-security-core + 6.0.3 + + + + + io.jsonwebtoken + jjwt-impl + 0.11.5 + runtime + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + org.jacoco + jacoco-maven-plugin + 0.8.11 + + + + prepare-agent + + + + report + test + + report + + + coverageReport + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 3.2.5 + + + + org.apache.maven.plugins + maven-surefire-report-plugin + 3.2.5 + + testReport + + + + + org.apache.maven.plugins + maven-site-plugin + 2.1 + + testReport + + + + + io.spring.javaformat + spring-javaformat-maven-plugin + 0.0.40 + + + + + \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerCommentMusicByIdTest.java.invalid b/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerCommentMusicByIdTest.java.invalid new file mode 100644 index 0000000..20215ae --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerCommentMusicByIdTest.java.invalid @@ -0,0 +1,111 @@ +//This test file is marked invalid as it contains compilation errors. Change the extension to of this file to .java, to manually edit its contents + + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=CommentMusicById_73ccb95717 +ROOST_METHOD_SIG_HASH=CommentMusicById_70a5563f90 + + +Scenario 1: Successful update of the number of comments for valid music ID + +Details: + TestName: updateCommentsSuccessForValidId + Description: Validate that the number of comments for a given valid music ID is incremented by 1 and properly saved in the repository. + +Execution: + Arrange: + - Mock `musicRepo.findById(id)` to return a valid `MusicModel` instance with current comments set to 5. + - Ensure `Log.save()` operation is stubbed to accept and process a `LogModel` instance. + + Act: + - Call the method `CommentMusicById(1)` with a valid ID (1). + + Assert: + - Verify that the `MusicModel` instance has `numberOfComments` incremented to 6. + - Confirm that `musicRepo.save()` is called once with the updated `MusicModel`. + - Ensure that `Log.save()` captures a log entry with relevant data. + +Validation: + - Confirms the correct execution of the functionality for a valid music ID. + - Ensures the "Música Alterada!" message is returned upon successful update. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers;import static org.mockito.Mockito.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import com.medeiros.SPRINGProject.Models.LogModel; +import com.medeiros.SPRINGProject.Models.MusicModel; +import com.medeiros.SPRINGProject.algorithm.algorithmBlender; +import com.medeiros.SPRINGProject.Controllers.AppController; +import org.springframework.web.bind.annotation.*; +import java.util.Map; +import org.junit.jupiter.api.*; +import com.medeiros.SPRINGProject.Models.*; +import org.springframework.beans.factory.annotation.Autowired; + +public class AppControllerCommentMusicByIdTest { + @Mock + private MusicModel musicModelMock; + + @Mock + private MusicRepository musicRepo; + + @Mock + private LogRepository logMock; + @Mock + private LogModel logModelMock; + + @InjectMocks + private AppController appController; + public void setUp() { + MockitoAnnotations.openMocks(this); + } + @Test + @Tag("valid") + public void updateCommentsSuccessForValidId() { + // Arrange + int mockMusicId = 1; // Valid music ID + int existingComments = 5; // Placeholder value + int expectedComments = existingComments + 1; + // Mock dependencies setup + MusicModel mockMusic = mock(MusicModel.class); + when(musicRepo.findById(mockMusicId)).thenReturn(mockMusic); + when(mockMusic.getNumberOfComents()).thenReturn(existingComments); + doNothing().when(musicRepo).save(mockMusic); + + // Mock the setting of comments directly + when(mockMusic.setNumberOfComents(expectedComments)).thenReturn(mockMusic); + + LogModel stubLogModel = mock(LogModel.class); + when(logMock.save(any(LogModel.class))).thenReturn(null); + // Act + String result = appController.CommentMusicById(mockMusicId); + // Assert + assertEquals("Música Alterada!", result); + assertEquals(expectedComments, mockMusic.getNumberOfComents()); + verify(musicRepo, times(1)).save(mockMusic); + verify(logMock, times(1)).save(any(LogModel.class)); + } + @Test + @Tag("invalid") + public void updateCommentsFailsForNonExistentId() { + // Arrange + int mockMusicId = 9999; // Non-existent ID + when(musicRepo.findById(mockMusicId)).thenReturn(null); + // Act + String result = appController.CommentMusicById(mockMusicId); + // Assert + assertEquals("Música Não Encontrada!", result); + verify(musicRepo, never()).save(any(MusicModel.class)); + verify(logMock, never()).save(any(LogModel.class)); + } +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerCreateCommentTest.java.invalid b/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerCreateCommentTest.java.invalid new file mode 100644 index 0000000..654e597 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerCreateCommentTest.java.invalid @@ -0,0 +1,243 @@ +//This test file is marked invalid as it contains compilation errors. Change the extension to of this file to .java, to manually edit its contents + + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=createComment_e2e99943cb +ROOST_METHOD_SIG_HASH=createComment_4104bef389 + +Scenario 1: Successful creation of a comment for a music item + +Details: + TestName: testCreateCommentSuccessfullyForMusicItem + Description: This test verifies that the `createComment` method successfully creates a comment for a valid music item ID and provided comment string. It also ensures that the comment is saved in the `CommentsRepo` repository and a log entry is created in the `Log` repository. +Execution: + Arrange: Mock the `CommentsRepo` and `Log` repositories. Prepare a valid music item ID (e.g., 1) and a non-null comment string (e.g., "Great song!"). + Act: Call the `createComment` method with the prepared music ID and comment string. + Assert: Verify that the comment is saved into the `CommentsRepo` with the correct ID and comment content. Also, verify that a log entry is saved in the `Log` repository. Ensure the method returns the expected comment content. +Validation: + This ensures that the method behaves as expected when supplied with valid inputs and that comments and log entries are appropriately created. + +--- + +Scenario 2: Passing a null comment when creating a comment + +Details: + TestName: testCreateCommentWithNullComment + Description: This test verifies how the `createComment` method handles a null comment string when an ID is valid. The system should throw an appropriate exception or fail gracefully, per the expected business logic. +Execution: + Arrange: Mock the `CommentsRepo` and `Log` repositories. Prepare a valid music item ID (e.g., 2) and pass null as the comment. + Act: Call the `createComment` method with the prepared music ID and null comment string. + Assert: Verify that the method throws an exception or does not save anything into the `CommentsRepo` and `Log`. +Validation: + This test ensures that invalid inputs for the comment are properly handled and do not cause inconsistencies in the system. + +--- + +Scenario 3: Attempting to create a comment for a negative ID + +Details: + TestName: testCreateCommentWithNegativeId + Description: This test verifies how the `createComment` method handles an invalid music item ID, specifically a negative ID. An appropriate exception should be thrown or logged to prevent saving invalid data. +Execution: + Arrange: Mock the `CommentsRepo` and `Log` repositories. Prepare a negative music item ID (e.g., -1) and a valid comment string (e.g., "Nice music"). + Act: Call the `createComment` method with the prepared negative ID and valid comment string. + Assert: Verify that no comment is saved in the `CommentsRepo` and no log entry is saved in the `Log`. Validate if an exception is thrown due to the invalid ID. +Validation: + This test ensures that invalid IDs do not result in creating unnecessary or erroneous records in the repositories. + +--- + +Scenario 4: Attempting to create a comment with an empty string as the comment + +Details: + TestName: testCreateCommentWithEmptyStringComment + Description: This test verifies that the `createComment` method handles an empty string as a comment string. The system should either throw a validation exception or ignore the operation. +Execution: + Arrange: Mock the `CommentsRepo` and `Log` repositories. Prepare a valid music ID (e.g., 3) and an empty string as the comment. + Act: Call the `createComment` method with the prepared music ID and empty string. + Assert: Verify that no comment is saved in the `CommentsRepo` and no log entry is saved in the `Log`. Check if an exception is thrown. +Validation: + This test ensures that the method fails gracefully when supplied with an empty comment and avoids saving irrelevant data. + +--- + +Scenario 5: Handling a failure in saving the comment to the repository + +Details: + TestName: testCreateCommentSavingFailure + Description: This test verifies the behavior of the `createComment` method when saving the comment fails due to a database failure or repository-level constraint violation. +Execution: + Arrange: Mock `CommentsRepo` to throw an exception or fail when saving the comment. Prepare a valid music ID (e.g., 4) and a valid comment string (e.g., "Excellent music"). + Act: Call the `createComment` method with the prepared inputs while simulating a failure in the `CommentsRepo`. + Assert: Verify that no data is saved to the `CommentsRepo` and no log entry is created in such a case. Ensure that the exception is properly handled or propagated. +Validation: + This test ensures system resilience when the database operations fail during the `createComment` operation. + +--- + +Scenario 6: Verifying log creation is handled correctly + +Details: + TestName: testCreateCommentWithLogVerification + Description: This test checks whether the `createComment` method creates the appropriate log entry in the `Log` repository when a comment is successfully saved. +Execution: + Arrange: Mock the `CommentsRepo` and `Log` repositories. Prepare a valid music ID (e.g., 5) and a valid comment string (e.g., "Amazing composition"). + Act: Call the `createComment` method with the prepared inputs. + Assert: Verify that a comment is saved to `CommentsRepo` and a corresponding log entry is created in the `Log`. Validate the log content to ensure it contains the correct endpoint reference, application name, and timestamp. +Validation: + This test ensures that the `createComment` method not only saves the comment but also correctly logs the operation for future audit purposes or monitoring. + +--- + +Scenario 7: Creating a comment for a boundary ID value (e.g., 0) + +Details: + TestName: testCreateCommentWithBoundaryIdValue + Description: This test focuses on testing the boundary value of ID, specifically ID = 0, to ensure that the `createComment` method handles it appropriately. +Execution: + Arrange: Mock the `CommentsRepo` and `Log` repositories. Prepare ID = 0 and a valid comment string (e.g., "Nice lyrics"). + Act: Call the `createComment` method with these inputs. + Assert: Verify whether the method allows the creation of a comment with ID = 0. Ensure the comment is saved (if expected by business rules) and a log entry is created. Alternatively, validate if an exception is thrown. +Validation: + This test ensures that the method behaves correctly with edge-case ID values and either handles or processes the input as per the defined functionality of the application. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers;import com.medeiros.SPRINGProject.Models.CommentsModel; +import com.medeiros.SPRINGProject.Models.LogModel; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.mockito.Mockito; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.*; +import com.medeiros.SPRINGProject.Models.*; +import com.medeiros.SPRINGProject.algorithm.algorithmBlender; +import java.util.Map; + +class AppControllerCreateCommentTest { + @Autowired + private AppController appController; + @Test + @Tag("valid") + void testCreateCommentSuccessfullyForMusicItem() { + // Arrange + int validId = 1; + String validComment = "Great song!"; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + LogRepository logMock = mock(LogRepository.class); + appController = new AppController(commentsRepoMock, logMock, new LogModel(), null, null, null); + // Act + String resultComment = appController.createComment(validId, validComment); + // Assert + verify(commentsRepoMock, times(1)) + .save(Mockito.argThat(comment -> ((CommentsModel) comment).getId() == validId + && ((CommentsModel) comment).getComment().equals(validComment))); + verify(logMock, times(1)) + .save(Mockito.argThat(log -> ((LogModel) log).getEndpoint().equals("app/createComment/{id}") + && ((LogModel) log).getAppName().equals("App"))); + assertEquals(validComment, resultComment); + } + @Test + @Tag("invalid") + void testCreateCommentWithNullComment() { + // Arrange + int validId = 2; + String nullComment = null; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + LogRepository logMock = mock(LogRepository.class); + appController = new AppController(commentsRepoMock, logMock, new LogModel(), null, null, null); + // Act & Assert + assertThrows(IllegalArgumentException.class, () -> appController.createComment(validId, nullComment)); + verify(commentsRepoMock, times(0)).save(any(CommentsModel.class)); + verify(logMock, times(0)).save(any(LogModel.class)); + } + @Test + @Tag("invalid") + void testCreateCommentWithNegativeId() { + // Arrange + int negativeId = -1; + String validComment = "Nice music"; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + LogRepository logMock = mock(LogRepository.class); + appController = new AppController(commentsRepoMock, logMock, new LogModel(), null, null, null); + // Act & Assert + assertThrows(IllegalArgumentException.class, () -> appController.createComment(negativeId, validComment)); + verify(commentsRepoMock, times(0)).save(any(CommentsModel.class)); + verify(logMock, times(0)).save(any(LogModel.class)); + } + @Test + @Tag("invalid") + void testCreateCommentWithEmptyStringComment() { + // Arrange + int validId = 3; + String emptyComment = ""; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + LogRepository logMock = mock(LogRepository.class); + appController = new AppController(commentsRepoMock, logMock, new LogModel(), null, null, null); + // Act & Assert + assertThrows(IllegalArgumentException.class, () -> appController.createComment(validId, emptyComment)); + verify(commentsRepoMock, times(0)).save(any(CommentsModel.class)); + verify(logMock, times(0)).save(any(LogModel.class)); + } + @Test + @Tag("valid") + void testCreateCommentSavingFailure() { + // Arrange + int validId = 4; + String validComment = "Excellent music"; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + LogRepository logMock = mock(LogRepository.class); + Mockito.doThrow(new RuntimeException("Save failed")).when(commentsRepoMock).save(any(CommentsModel.class)); + appController = new AppController(commentsRepoMock, logMock, new LogModel(), null, null, null); + // Act & Assert + assertThrows(RuntimeException.class, () -> appController.createComment(validId, validComment)); + verify(logMock, times(0)).save(any(LogModel.class)); + } + @Test + @Tag("integration") + void testCreateCommentWithLogVerification() { + // Arrange + int validId = 5; + String validComment = "Amazing composition"; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + LogRepository logMock = mock(LogRepository.class); + appController = new AppController(commentsRepoMock, logMock, new LogModel(), null, null, null); + // Act + String resultComment = appController.createComment(validId, validComment); + // Assert + verify(commentsRepoMock, times(1)) + .save(Mockito.argThat(comment -> ((CommentsModel) comment).getId() == validId + && ((CommentsModel) comment).getComment().equals(validComment))); + verify(logMock, times(1)) + .save(Mockito.argThat(log -> ((LogModel) log).getEndpoint().equals("app/createComment/{id}") + && ((LogModel) log).getAppName().equals("App"))); + assertEquals(validComment, resultComment); + } + @Test + @Tag("boundary") + void testCreateCommentWithBoundaryIdValue() { + // Arrange + int boundaryId = 0; + String validComment = "Nice lyrics"; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + LogRepository logMock = mock(LogRepository.class); + appController = new AppController(commentsRepoMock, logMock, new LogModel(), null, null, null); + // Act + String resultComment = appController.createComment(boundaryId, validComment); + // Assert + verify(commentsRepoMock, times(1)) + .save(Mockito.argThat(comment -> ((CommentsModel) comment).getId() == boundaryId + && ((CommentsModel) comment).getComment().equals(validComment))); + verify(logMock, times(1)) + .save(Mockito.argThat(log -> ((LogModel) log).getEndpoint().equals("app/createComment/{id}") + && ((LogModel) log).getAppName().equals("App"))); + assertEquals(validComment, resultComment); + } +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerGetCommentsByMusicIdTest.java.invalid b/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerGetCommentsByMusicIdTest.java.invalid new file mode 100644 index 0000000..28a31f2 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerGetCommentsByMusicIdTest.java.invalid @@ -0,0 +1,293 @@ +//This test file is marked invalid as it contains compilation errors. Change the extension to of this file to .java, to manually edit its contents + + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=getCommentsByMusicId_9981fa8dac +ROOST_METHOD_SIG_HASH=getCommentsByMusicId_b64d712e58 + + +Scenario 1: Valid MusicId provided for fetching comments + +Details: + TestName: retrieveCommentsForValidMusicId + Description: The test verifies that the method returns the correct comments for a valid MusicId provided. + +Execution: + Arrange: Mock the CommentsRepository object to return expected comments associated with the given MusicId. + Act: Call the getCommentsByMusicId method with a valid MusicId value. + Assert: Verify that the return value is a string containing the correct comments. +Validation: + This test validates that the method can correctly fetch and return comments specific to the given MusicId. The test ensures that the system behaves as expected for valid MusicId inputs. + +--- + +Scenario 2: Invalid MusicId with no associated comments + +Details: + TestName: handleInvalidMusicIdForComments + Description: The test checks how the method behaves when an invalid MusicId, for which no comments exist, is provided. + +Execution: + Arrange: Mock the CommentsRepository to return no comments for the provided MusicId. + Act: Call the getCommentsByMusicId method with an invalid MusicId. + Assert: Verify that the return value is appropriately handled, such as returning a default or empty response instead of any comments. +Validation: + The test ensures that the method can gracefully handle situations where no comments exist for the provided MusicId. + +--- + +Scenario 3: Null MusicId provided + +Details: + TestName: handleNullMusicIdInputForComments + Description: This test ensures the method handles the situation where a null MusicId is passed. + +Execution: + Arrange: Set MusicId to null. + Act: Call the getCommentsByMusicId method with null as the input parameter. + Assert: Verify that an appropriate exception or response is generated for the invalid input. +Validation: + Verifies how the method handles null values to ensure that such cases are managed correctly without causing unexpected crashes or behavior. + +--- + +Scenario 4: Negative MusicId provided + +Details: + TestName: handleNegativeMusicIdInputForComments + Description: This test checks the behavior of the method when a negative MusicId is passed. + +Execution: + Arrange: Provide a negative MusicId value as input. + Act: Call the getCommentsByMusicId method with the negative MusicId. + Assert: Verify that the return value is either an empty or error-based response. +Validation: + Ensures the method is robust against invalid inputs such as negative values and handles them gracefully. + +--- + +Scenario 5: Boundary test for MusicId (e.g., MusicId = 0) + +Details: + TestName: handleBoundaryMusicIdInput + Description: This test verifies the method's behavior for boundary values such as 0 for the MusicId. + +Execution: + Arrange: Provide MusicId = 0. + Act: Call the getCommentsByMusicId method with the boundary value MusicId. + Assert: Verify if the returned comments are handled as expected for boundary input conditions. +Validation: + This test helps ensure the method can capably manage edge cases where the input is at or near possible boundary conditions. + +--- + +Scenario 6: No comments repository available + +Details: + TestName: handleNoCommentsRepositoryAvailable + Description: This test validates that the method handles situations where the CommentsRepository is null or not initialized. + +Execution: + Arrange: Ensure that the CommentsRepo field remains null. + Act: Call the getCommentsByMusicId method. + Assert: Verify that the method returns an appropriate error response or null value when the CommentsRepository is unavailable. +Validation: + Ensures that the method can handle scenarios where the CommentsRepository is not properly initialized and does not lead to unexpected crashes. + +--- + +Scenario 7: CommentsRepository throws an exception + +Details: + TestName: handleCommentsRepositoryException + Description: Validate the method's behavior when the CommentsRepository throws an exception while retrieving the comments. + +Execution: + Arrange: Mock the CommentsRepository to throw an exception during the call for retrieving comments. + Act: Call the getCommentsByMusicId method with a valid MusicId. + Assert: Verify that an appropriate exception or error response is returned by the method. +Validation: + The test checks the resilience of the method against potential runtime exceptions from dependent components like the CommentsRepository. + +--- + +Scenario 8: Empty response for a valid MusicId + +Details: + TestName: handleEmptyResponseForValidMusicId + Description: Tests the behavior when the CommentsRepository returns an empty response for a valid MusicId. + +Execution: + Arrange: Mock the CommentsRepository to return an empty response for a valid MusicId. + Act: Call the getCommentsByMusicId method with a valid MusicId. + Assert: Check if the return value appropriately represents an empty result, e.g., null or an empty string. +Validation: + This test ensures that the method handles cases where there are no comments for a valid MusicId in the database correctly without failure. + +--- + +Scenario 9: High volume of comments for a MusicId + +Details: + TestName: handleHighVolumeOfComments + Description: This test validates the method's behavior when a MusicId has a large number of associated comments. + +Execution: + Arrange: Mock the CommentsRepository to provide a large dataset of comments for a valid MusicId. + Act: Call the getCommentsByMusicId method with the valid MusicId that has a high volume of comments. + Assert: Verify that the method successfully returns the correct comments without performance or memory issues. +Validation: + Verifies the scalability and performance of the method when handling large datasets of comments. + +--- + +Scenario 10: Special characters in MusicId comments + +Details: + TestName: handleSpecialCharactersInComments + Description: The test ensures that comments containing special characters, such as emojis or non-Alphanumeric symbols, are handled correctly. + +Execution: + Arrange: Mock the CommentsRepository to return comments containing special characters for a valid MusicId. + Act: Call the getCommentsByMusicId method and fetch the comments. + Assert: Verify that the return value includes all text, including the special characters, accurately. +Validation: + The test ensures compatibility with a wide range of user inputs, including those having special characters or emojis in the comment text. + +--- + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers;import com.medeiros.SPRINGProject.Models.CommentsModel; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.springframework.beans.factory.annotation.Autowired; +import java.util.Arrays; +import java.util.Collections; +import static org.mockito.Mockito.*; +import org.junit.jupiter.api.*; +import com.medeiros.SPRINGProject.Models.*; +import com.medeiros.SPRINGProject.algorithm.algorithmBlender; +import org.springframework.web.bind.annotation.*; +import java.util.Map; + +public class AppControllerGetCommentsByMusicIdTest { + @Autowired + private AppController appController; + @Test + @Tag("valid") + public void retrieveCommentsForValidMusicId() { + int validMusicId = 1; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + appController.CommentsRepo = commentsRepoMock; + CommentsModel comment1 = new CommentsModel("Comment 1", validMusicId); + CommentsModel comment2 = new CommentsModel("Comment 2", validMusicId); + when(commentsRepoMock.findByMusicId((Integer) validMusicId)).thenReturn(Arrays.asList(comment1, comment2)); + String actualComments = appController.getCommentsByMusicId(validMusicId); + Assertions.assertEquals("Comment 1, Comment 2", actualComments, "Should return comments for valid MusicId"); + } + @Test + @Tag("invalid") + public void handleInvalidMusicIdForComments() { + int invalidMusicId = 9999; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + appController.CommentsRepo = commentsRepoMock; + when(commentsRepoMock.findByMusicId((Integer) invalidMusicId)).thenReturn(Collections.emptyList()); + String actualComments = appController.getCommentsByMusicId(invalidMusicId); + Assertions.assertEquals("", actualComments, "Should return empty response for invalid MusicId"); + } + @Test + @Tag("boundary") + public void handleNullMusicIdInputForComments() { + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + appController.CommentsRepo = commentsRepoMock; + // Suggestion: Business logic needs enhancement to handle this scenario + Assertions.assertThrows(IllegalArgumentException.class, () -> { + appController.getCommentsByMusicId(Integer.parseInt(null)); // Proper type casting for null as int + }, "Should throw IllegalArgumentException when MusicId is null"); + } + @Test + @Tag("invalid") + public void handleNegativeMusicIdInputForComments() { + int negativeMusicId = -1; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + appController.CommentsRepo = commentsRepoMock; + when(commentsRepoMock.findByMusicId((Integer) negativeMusicId)).thenReturn(Collections.emptyList()); + String actualComments = appController.getCommentsByMusicId(negativeMusicId); + Assertions.assertEquals("", actualComments, "Should return empty response for negative MusicId"); + } + @Test + @Tag("boundary") + public void handleBoundaryMusicIdInput() { + int boundaryMusicId = 0; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + appController.CommentsRepo = commentsRepoMock; + when(commentsRepoMock.findByMusicId((Integer) boundaryMusicId)).thenReturn(Collections.emptyList()); + String actualComments = appController.getCommentsByMusicId(boundaryMusicId); + Assertions.assertEquals("", actualComments, "Should return empty response for boundary MusicId"); + } + @Test + @Tag("integration") + public void handleNoCommentsRepositoryAvailable() { + appController.CommentsRepo = null; + Assertions.assertThrows(NullPointerException.class, () -> { + appController.getCommentsByMusicId(1); + }, "Should throw NullPointerException when CommentsRepo is null"); + } + @Test + @Tag("invalid") + public void handleCommentsRepositoryException() { + int validMusicId = 3; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + appController.CommentsRepo = commentsRepoMock; + when(commentsRepoMock.findByMusicId((Integer) validMusicId)).thenThrow(new RuntimeException("Database error")); + Assertions.assertThrows(RuntimeException.class, () -> { + appController.getCommentsByMusicId(validMusicId); + }, "Should throw RuntimeException when repository fails"); + } + @Test + @Tag("valid") + public void handleEmptyResponseForValidMusicId() { + int validMusicId = 4; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + appController.CommentsRepo = commentsRepoMock; + when(commentsRepoMock.findByMusicId((Integer) validMusicId)).thenReturn(Collections.emptyList()); + String actualComments = appController.getCommentsByMusicId(validMusicId); + Assertions.assertEquals("", actualComments, "Should return empty result for valid MusicId if no comments exist"); + } + @Test + @Tag("valid") + public void handleHighVolumeOfComments() { + int validMusicId = 5; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + appController.CommentsRepo = commentsRepoMock; + StringBuilder largeCommentSet = new StringBuilder(); + CommentsModel[] commentsArray = new CommentsModel[1000]; + for (int i = 0; i < 1000; i++) { + commentsArray[i] = new CommentsModel("Comment " + (i + 1), validMusicId); + largeCommentSet.append("Comment ").append(i + 1).append(", "); + } + largeCommentSet.setLength(largeCommentSet.length() - 2); + when(commentsRepoMock.findByMusicId((Integer) validMusicId)).thenReturn(Arrays.asList(commentsArray)); + String actualComments = appController.getCommentsByMusicId(validMusicId); + Assertions.assertEquals(largeCommentSet.toString(), actualComments, "Should correctly handle large volume of comments"); + } + @Test + @Tag("valid") + public void handleSpecialCharactersInComments() { + int validMusicId = 6; + CommentsRepository commentsRepoMock = mock(CommentsRepository.class); + appController.CommentsRepo = commentsRepoMock; + CommentsModel comment1 = new CommentsModel("Comment 😊", validMusicId); + CommentsModel comment2 = new CommentsModel("Comment @Example", validMusicId); + when(commentsRepoMock.findByMusicId((Integer) validMusicId)).thenReturn(Arrays.asList(comment1, comment2)); + String actualComments = appController.getCommentsByMusicId(validMusicId); + Assertions.assertEquals("Comment 😊, Comment @Example", actualComments, "Should retain special characters in returned comments"); + } +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerLikeMusicByIdTest.java.invalid b/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerLikeMusicByIdTest.java.invalid new file mode 100644 index 0000000..d8c30e6 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerLikeMusicByIdTest.java.invalid @@ -0,0 +1,250 @@ +//This test file is marked invalid as it contains compilation errors. Change the extension to of this file to .java, to manually edit its contents + + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=LikeMusicById_9bce296f63 +ROOST_METHOD_SIG_HASH=LikeMusicById_86ac50a5c5 + +Scenario 1: Validate successful like increment for a valid music ID + +Details: + TestName: validateSuccessfulIncrementForValidId + Description: This test ensures that the `LikeMusicById` method correctly increments the number of likes for an existing music entry when given a valid ID. It also verifies that the musicRepo.save() method is invoked to persist the updates. +Execution: + Arrange: Set up a mock MusicRepository and LogRepository. Create a MusicModel object with an ID, a predefined number of likes, and mock the behavior of `musicRepo.findById(id)` to return this object. + Act: Call the `LikeMusicById` method with the valid ID for the created mock MusicModel. + Assert: Verify that the likes count in the MusicModel object is incremented by 1 and the `musicRepo.save()` method is invoked. +Validation: + This test ensures that the core functionality of incrementing likes works as intended for valid IDs and updates are persisted. + +Scenario 2: Handle case where music ID does not exist (null return from musicRepo) + +Details: + TestName: handleNonExistentIdGracefully + Description: Verify the behavior of the `LikeMusicById` method when no music exists corresponding to the provided ID, ensuring the system handles null responses gracefully. +Execution: + Arrange: Mock `musicRepo.findById(id)` to return null for the provided ID. + Act: Call the `LikeMusicById` method with a non-existent ID. + Assert: Verify that no operations such as save or log creation are performed, and the method throws an appropriate exception (if applicable) or handles the response as per the implemented logic. +Validation: + Ensures robustness of the method when dealing with IDs that do not match any existing entries. + +Scenario 3: Validate log creation during like operation + +Details: + TestName: validateLogCreationOnLikeOperation + Description: Test to check that a LogModel entry is created and saved with appropriate details after incrementing likes for a valid music ID. +Execution: + Arrange: Mock `Log.save()` to verify its invocation. Provide a valid mock MusicModel via `musicRepo.findById(id)` with predefined data. + Act: Execute the `LikeMusicById` method and increment the likes for the valid ID. + Assert: Verify that `Log.save()` is invoked once with correct parameters, including the expected URL path, module name, and timestamp. +Validation: + Confirms that log entries are consistently and accurately created for tracking operations. + +Scenario 4: Test behavior for negative music ID + +Details: + TestName: testNegativeMusicIdBehavior + Description: Validate the behavior of the `LikeMusicById` method when a negative music ID is provided, ensuring it handles invalid IDs properly. +Execution: + Arrange: Set up the mock `musicRepo.findById()` to not return any MusicModel object for the negative ID. + Act: Call the `LikeMusicById` method with a negative ID. + Assert: Ensure no operations like save or log creation occur, and the method responds appropriately (e.g., returning an error, no changes). +Validation: + Checks robustness for edge cases involving invalid IDs (negative values). + +Scenario 5: Confirm behavior for maximum integer value as music ID + +Details: + TestName: validateMaxIntIdBehavior + Description: This test checks how the method acts when the maximum possible integer value is utilized as the ID parameter, ensuring it handles such cases without overflow/errors. +Execution: + Arrange: Use `musicRepo.findById()` to return a predefined MusicModel object when called with Integer.MAX_VALUE. + Act: Execute `LikeMusicById` with Integer.MAX_VALUE as the ID. + Assert: Verify that likes count is incremented correctly, and log creation is performed. +Validation: + Guarantees that the method can handle extreme numeric values gracefully. + +Scenario 6: Ensure idempotent behavior when called consecutively for the same ID + +Details: + TestName: validateIdempotentBehaviorOnMultipleCalls + Description: This test ensures that calling `LikeMusicById` consecutively on the same ID increments likes correctly without errors or duplication. +Execution: + Arrange: Mock a predefined MusicModel object using `musicRepo.findById(id)` with an initial number of likes. Mock `musicRepo.save()` to verify updates. + Act: Call the method twice consecutively with the same ID. + Assert: Validate that the likes are incremented twice, once for each call, and verify the save operations took place the correct number of times. +Validation: + Ensures the predictability and correctness of behavior when the method is invoked multiple times for the same ID. + +Scenario 7: Validate exception handling during `musicRepo.save()` failure + +Details: + TestName: validateSaveFailureHandling + Description: Test how the system handles cases where `musicRepo.save()` fails during the like increment operation, ensuring the exception is properly handled or propagated. +Execution: + Arrange: Mock `musicRepo.save()` to throw an exception when invoked. Provide a valid MusicModel object for the specified ID. + Act: Call the `LikeMusicById` method with the pre-defined valid ID and trigger the exception during the save operation. + Assert: Validate that the exception is captured and an appropriate response or error message is returned by the method. +Validation: + Ensures the application remains stable in case of backend or database operation errors. + +Scenario 8: Ensure no redundant log creation if MusicModel is unchanged + +Details: + TestName: preventRedundantLogCreationForUnchangedMusic + Description: This test checks that no log entries are created if no changes are made to the MusicModel because the ID does not exist. +Execution: + Arrange: Mock `musicRepo.findById(id)` to return null. Mock `Log.save()` to verify it is not invoked during the execution. + Act: Call the `LikeMusicById` method with a non-existent ID. + Assert: Verify that no log entries are created and no save operations are triggered. +Validation: + Guarantees optimal operations by avoiding unnecessary log creations for invalid IDs. + +Scenario 9: Confirm language consistency in returned message + +Details: + TestName: confirmReturnedMessageLanguageConsistency + Description: Verify that the method's return message remains consistent and in the correct language (Portuguese in this case) across scenarios where likes are successfully incremented. +Execution: + Arrange: Provide a valid MusicModel object via `musicRepo.findById(id)`. + Act: Call the `LikeMusicById` method with the valid ID. + Assert: Validate that the method returns the expected message "Música Alterada!". +Validation: + Ensures language consistency and compliance with returning standardized system messages. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers;import com.medeiros.SPRINGProject.Models.*; +import com.medeiros.SPRINGProject.algorithm.algorithmBlender; +import org.junit.jupiter.api.*; +import org.mockito.*; +import java.util.Date; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; +import java.util.Map; + +@Tag("integration") +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +public class AppControllerLikeMusicByIdTest { + @Mock + private MusicRepository musicRepo; // FIXED: Changed MusicRepo to MusicRepository as per the field provided + @Mock + private LogRepository logRepo; // FIXED: Changed LogRepo to LogRepository as per the field provided + @InjectMocks + private AppController appController; + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + } + @Test + @Tag("valid") + public void validateSuccessfulIncrementForValidId() { + int validId = 1; + MusicModel mockMusic = new MusicModel(); + mockMusic.setNumberOfLikes(10); + when(musicRepo.findById(validId)).thenReturn(mockMusic); // FIXED: Changed to match MusicRepository type + String response = appController.LikeMusicById(validId); + assertEquals("Música Alterada!", response); + assertEquals(11, mockMusic.getNumberOfLikes()); + verify(musicRepo, times(1)).save(mockMusic); + } + @Test + @Tag("invalid") + public void handleNonExistentIdGracefully() { + int nonExistentId = 999; + when(musicRepo.findById(nonExistentId)).thenReturn(null); // FIXED: Corrected logic according to MusicRepository + assertThrows(NullPointerException.class, () -> { + appController.LikeMusicById(nonExistentId); + }); + verify(musicRepo, never()).save(any()); + verify(logRepo, never()).save(any()); + } + @Test + @Tag("valid") + public void validateLogCreationOnLikeOperation() { + int validId = 1; + MusicModel mockMusic = new MusicModel(); + mockMusic.setNumberOfLikes(5); + LogModel mockLog = new LogModel("app/like/{id}", "App", System.currentTimeMillis()); // FIXED: Corrected timestamp creation logic + when(musicRepo.findById(validId)).thenReturn(mockMusic); // FIXED: Corrected logic according to MusicRepository + String response = appController.LikeMusicById(validId); + assertEquals("Música Alterada!", response); + verify(logRepo, times(1)).save(Mockito.any(LogModel.class)); + } + @Test + @Tag("invalid") + public void testNegativeMusicIdBehavior() { + int negativeId = -1; + when(musicRepo.findById(negativeId)).thenReturn(null); // FIXED: Corrected logic according to MusicRepository + + assertThrows(NullPointerException.class, () -> { + appController.LikeMusicById(negativeId); + }); + verify(musicRepo, never()).save(any()); + verify(logRepo, never()).save(any()); + } + @Test + @Tag("boundary") + public void validateMaxIntIdBehavior() { + int maxId = Integer.MAX_VALUE; + MusicModel mockMusic = new MusicModel(); + mockMusic.setNumberOfLikes(15); + when(musicRepo.findById(maxId)).thenReturn(mockMusic); // FIXED: Corrected logic according to MusicRepository + String response = appController.LikeMusicById(maxId); + assertEquals("Música Alterada!", response); + assertEquals(16, mockMusic.getNumberOfLikes()); + verify(musicRepo, times(1)).save(mockMusic); + } + @Test + @Tag("integration") + public void validateIdempotentBehaviorOnMultipleCalls() { + int validId = 2; + MusicModel mockMusic = new MusicModel(); + mockMusic.setNumberOfLikes(10); + when(musicRepo.findById(validId)).thenReturn(mockMusic); // FIXED: Corrected logic according to MusicRepository + appController.LikeMusicById(validId); + appController.LikeMusicById(validId); + assertEquals(12, mockMusic.getNumberOfLikes()); + verify(musicRepo, times(2)).save(mockMusic); + } + @Test + @Tag("invalid") + public void validateSaveFailureHandling() { + int validId = 3; + MusicModel mockMusic = new MusicModel(); + mockMusic.setNumberOfLikes(50); + when(musicRepo.findById(validId)).thenReturn(mockMusic); // FIXED: Corrected logic according to MusicRepository + doThrow(RuntimeException.class).when(musicRepo).save(mockMusic); // FIXED: Added exception throwing as per logic + assertThrows(RuntimeException.class, () -> { + appController.LikeMusicById(validId); + }); + verify(musicRepo, times(1)).save(mockMusic); + } + @Test + @Tag("invalid") + public void preventRedundantLogCreationForUnchangedMusic() { + int nonExistentId = 9999; + when(musicRepo.findById(nonExistentId)).thenReturn(null); // FIXED: Corrected logic according to MusicRepository + assertThrows(NullPointerException.class, () -> { + appController.LikeMusicById(nonExistentId); + }); + verify(logRepo, never()).save(any()); + } + @Test + @Tag("valid") + public void confirmReturnedMessageLanguageConsistency() { + int validId = 4; + MusicModel mockMusic = new MusicModel(); + mockMusic.setNumberOfLikes(25); + when(musicRepo.findById(validId)).thenReturn(mockMusic); // FIXED: Corrected logic according to MusicRepository + String response = appController.LikeMusicById(validId); + assertEquals("Música Alterada!", response); + } +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerShowMusicsTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerShowMusicsTest.java new file mode 100644 index 0000000..1f523be --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/AppControllerShowMusicsTest.java @@ -0,0 +1,135 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=showMusics_52ef65b78a +ROOST_METHOD_SIG_HASH=showMusics_caba7c787a + + +Scenario [1]: Verify that the method returns a calculated map when musicRepo contains valid data + +Details: + TestName: ReturnsCalculatedMapWhenMusicRepoHasData + Description: This test checks that the `showMusics()` method successfully calls `musicRepo.findAll()` and `algorithmBlender.algorithmCalc()` to return a map when data exists in `musicRepo`. + +Execution: + Arrange: Mock the `musicRepo.findAll()` method to return a valid list of MusicModel objects. Mock the `algorithmBlender.algorithmCalc()` method to return a proper Map based on the input list. + Act: Invoke the `showMusics()` method. + Assert: Compare the returned map to the expected result generated by the `algorithmCalc` mock. + +Validation: + The assertion verifies that the `showMusics()` method correctly integrates with `musicRepo.findAll()` and `algorithmBlender.algorithmCalc()` to produce the expected output when valid data is present. This ensures the core functionality of the method works as intended. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.MusicModel; +import com.medeiros.SPRINGProject.algorithm.algorithmBlender; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.mockito.Mock; +import org.mockito.InjectMocks; +import org.mockito.MockitoAnnotations; +import org.springframework.boot.test.context.SpringBootTest; +import java.util.*; +import static org.mockito.Mockito.*; +import static org.junit.jupiter.api.Assertions.*; +import com.medeiros.SPRINGProject.Models.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; +import java.util.Map; + +@SpringBootTest +public class AppControllerShowMusicsTest { + + @Mock + private algorithmBlender ab; + + @Mock + private MusicRepository musicRepo; // Correct type for `musicRepo` to resolve + // compilation errors + + @InjectMocks + private AppController appController; + + @BeforeEach + public void setUp() { + MockitoAnnotations.openMocks(this); + } + + @Test + @Tag("valid") + public void testReturnsCalculatedMapWhenMusicRepoHasData() { + // Arrange + MusicModel music1 = new MusicModel(); // TODO: Add values to MusicModel + // initialization as required + MusicModel music2 = new MusicModel(); // TODO: Add values to MusicModel + // initialization as required + List musicList = Arrays.asList(music1, music2); + Map expectedMap = new HashMap<>(); + expectedMap.put("ExampleKey", 1); // TODO: Adjust mock values as necessary + when(musicRepo.findAll()).thenReturn(musicList); // Mock `musicRepo`'s `findAll()` + // method + when(ab.algorithmCalc((Iterable) musicList)).thenReturn(expectedMap); // Mock + // algorithm + // calculation + // Act + Map actualMap = appController.showMusics(); + // Assert + assertEquals(expectedMap, actualMap); + } + + @Test + @Tag("invalid") + public void testReturnsEmptyMapWhenMusicRepoIsEmpty() { + // Arrange + Iterable emptyMusicList = Collections.emptyList(); + Map expectedMap = new HashMap<>(); + when(musicRepo.findAll()).thenReturn(emptyMusicList); // Mock `musicRepo`'s + // `findAll()` method + when(ab.algorithmCalc(emptyMusicList)).thenReturn(expectedMap); // Mock algorithm + // calculation + // Act + Map actualMap = appController.showMusics(); + // Assert + assertEquals(expectedMap, actualMap); + } + + @Test + @Tag("integration") + public void testHandlesNullReturnedByMusicRepoGracefully() { + // Arrange + when(musicRepo.findAll()).thenReturn(null); // Mock `musicRepo` returning null + Map expectedMap = new HashMap<>(); + when(ab.algorithmCalc(null)).thenReturn(expectedMap); // Handle null input in algorithm mock + // Act + Map actualMap = appController.showMusics(); + // Assert + assertEquals(expectedMap, actualMap); + } + + @Test + @Tag("boundary") + public void testHandlesBoundaryCaseWithOneMusicEntry() { + // Arrange + MusicModel singleMusic = new MusicModel(); // TODO: Add values to MusicModel + // initialization as required + List musicList = Collections.singletonList(singleMusic); + Map expectedMap = new HashMap<>(); + expectedMap.put("BoundaryKey", 2); // TODO: Adjust mock values as necessary + when(musicRepo.findAll()).thenReturn(musicList); // Mock `musicRepo`'s `findAll()` + // method + when(ab.algorithmCalc((Iterable) musicList)).thenReturn(expectedMap); // Mock + // algorithm + // calculation + // Act + Map actualMap = appController.showMusics(); + // Assert + assertEquals(expectedMap, actualMap); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/AuthControllerCreateAuserTest.java.invalid b/src/test/java/com/medeiros/SPRINGProject/Controllers/AuthControllerCreateAuserTest.java.invalid new file mode 100644 index 0000000..2ee1f4e --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/AuthControllerCreateAuserTest.java.invalid @@ -0,0 +1,119 @@ +//This test file is marked invalid as it contains compilation errors. Change the extension to of this file to .java, to manually edit its contents + + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=createAuser_43c81bbbba +ROOST_METHOD_SIG_HASH=createAuser_2684b4910b + +Scenario 1: Testing successful user creation with matching passwords + +Details: + TestName: successfulUserCreationWithMatchingPasswords + Description: This test verifies that the method successfully creates a user when valid input data with matching passwords is provided. + +Execution: + Arrange: Provide valid email, password, confirmPassword, and username. Mock UserAccRepo and Log to ensure proper saving and logging behavior. + Act: Invoke the `createAuser` method with the provided parameters. + Assert: Verify that the method returns "Sucesso". Ensure that UserAccRepo saves the data and Log records the action according to expectations. + +Validation: + The assertion confirms that the input email, password, confirmPassword, and username result in successful user creation. This test checks correct logic for handling valid inputs and ensures the method behaves as expected under ideal conditions. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers;import com.medeiros.SPRINGProject.Models.User_Credentials; +import com.medeiros.SPRINGProject.Models.LogModel; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.InjectMocks; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.*; +import com.medeiros.SPRINGProject.Models.*; +import com.medeiros.SPRINGProject.Security.JwtUtil; +import org.springframework.web.bind.annotation.*; +import java.util.Objects; +import org.springframework.beans.factory.annotation.Autowired; + +public class AuthControllerCreateAuserTest { + @InjectMocks + private AuthController authController; + @Mock + private UserAccRepository userAccRepo; // Corrected type from UserAccRepo to UserAccRepository + @Mock + private LogRepository log; // Corrected type from Log to LogRepository + @Mock + private LogModel date; // LogModel adjusted to represent Date dependency with new LogModel object + @Test + @Tag("valid") + public void successfulUserCreationWithMatchingPasswords() { + // Arrange + String validEmail = "testuser@example.com"; + String validPassword = "password123"; + String validConfirmPassword = "password123"; + String validUsername = "testuser"; + User_Credentials userCred = new User_Credentials(validEmail, validPassword, validUsername); + LogModel logData = new LogModel("createUser01", "User", "2023-10-01T10:00:00Z"); // Updated for date representation + doNothing().when(userAccRepo).save(any(User_Credentials.class)); + doNothing().when(log).save(any(LogModel.class)); + // Act + String result = authController.createAuser(validEmail, validPassword, validConfirmPassword, validUsername); + // Assert + assertEquals("Sucesso", result); + verify(userAccRepo, times(1)).save(any(User_Credentials.class)); // Removed object comparison + verify(log, times(1)).save(any(LogModel.class)); + } + @Test + @Tag("invalid") + public void testUserCreationWithNonMatchingPasswords() { + // Arrange + String validEmail = "testuser@example.com"; + String validPassword = "password123"; + String invalidConfirmPassword = "password321"; + String validUsername = "testuser"; + // Act + String result = authController.createAuser(validEmail, validPassword, invalidConfirmPassword, validUsername); + // Assert + assertEquals("Senhas não batem!", result); + verify(userAccRepo, never()).save(any(User_Credentials.class)); + verify(log, never()).save(any(LogModel.class)); + } + @Test + @Tag("boundary") + public void testEmptyEmailField() { + // Arrange + String invalidEmail = ""; + String validPassword = "password123"; + String validConfirmPassword = "password123"; + String validUsername = "testuser"; + // Act + String result = authController.createAuser(invalidEmail, validPassword, validConfirmPassword, validUsername); + // Assert + assertEquals("Senhas não batem!", result); // Updated logic - the business logic should additionally check for empty email field + verify(userAccRepo, never()).save(any(User_Credentials.class)); + verify(log, never()).save(any(LogModel.class)); + } + @Test + @Tag("boundary") + public void testEmptyUsernameField() { + // Arrange + String validEmail = "testuser@example.com"; + String validPassword = "password123"; + String validConfirmPassword = "password123"; + String emptyUsername = ""; + User_Credentials userCred = new User_Credentials(validEmail, validPassword, emptyUsername); + LogModel logData = new LogModel("createUser01", "User", "2023-10-01T10:00:00Z"); // Updated for date representation + doNothing().when(userAccRepo).save(any(User_Credentials.class)); + doNothing().when(log).save(any(LogModel.class)); + // Act + String result = authController.createAuser(validEmail, validPassword, validConfirmPassword, emptyUsername); + // Assert + assertEquals("Sucesso", result); // Test passes as empty username is not disallowed in current business logic + verify(userAccRepo, times(1)).save(any(User_Credentials.class)); // Removed object comparison + verify(log, times(1)).save(any(LogModel.class)); + } +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/AuthControllerLoginUserTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/AuthControllerLoginUserTest.java new file mode 100644 index 0000000..e673b02 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/AuthControllerLoginUserTest.java @@ -0,0 +1,308 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=loginUser_d19666d97a +ROOST_METHOD_SIG_HASH=loginUser_8fe76c816e + +Scenario [1]: Successful login with valid email and password + +Details: + TestName: successfulLoginWithValidCredentials + Description: Verify that the `loginUser` method returns the string "Logado" when the provided email and password match a user in the `UserAccRepo`. + +Execution: + Arrange: Mock `UserAccRepo` to return a `User_Credentials` object with a matching email and password. + Act: Call `loginUser` with a valid email and password. + Assert: The method should return the string "Logado". +Validation: + Ensure the method correctly identifies valid credentials and returns the expected success message, verifying its correctness for valid login. + +--- + +Scenario [2]: Failed login with incorrect password + +Details: + TestName: incorrectPasswordReturnsErrorMessage + Description: Test that the `loginUser` method returns "Senha incorreta" when the email exists in `UserAccRepo` but the password is incorrect. + +Execution: + Arrange: Mock `UserAccRepo` to return a `User_Credentials` object with a matching email but a different password. + Act: Pass a valid email but an incorrect password to the `loginUser` method. + Assert: The method should return "Senha incorreta". +Validation: + Verify that the method correctly detects mismatched credentials and returns an appropriate error message for incorrect passwords. + +--- + +Scenario [3]: Login fails with non-existent email + +Details: + TestName: nonExistentEmailReturnsError + Description: Validate that the `loginUser` method returns "Email não encontrado!" when the provided email does not exist in `UserAccRepo`. + +Execution: + Arrange: Mock `UserAccRepo` to return `null` for a given email that does not exist in the repository. + Act: Call `loginUser` with a non-existent email. + Assert: The method should return "Email não encontrado!". +Validation: + Confirm that the method properly handles cases where the email is not found in the database, ensuring robust error handling for such scenarios. + +--- + +Scenario [4]: Login fails with null email input + +Details: + TestName: nullEmailReturnsEmailNotFound + Description: Check that the method returns "Email não encontrado!" when a null email address is provided to `loginUser`. + +Execution: + Arrange: Mock `UserAccRepo` to return `null` for a null email parameter. + Act: Call `loginUser` with `null` as the email. + Assert: The method should return "Email não encontrado!". +Validation: + Ensure the method safely handles null values for email and does not throw an exception, correctly returning a value indicating the email was not found. + +--- + +Scenario [5]: Login fails with empty email input + +Details: + TestName: emptyEmailReturnsEmailNotFound + Description: Ensure the method returns "Email não encontrado!" when provided with an empty string for the email. + +Execution: + Arrange: Mock `UserAccRepo` to return `null` when an empty string is passed as email. + Act: Pass an empty string as the email parameter to `loginUser`. + Assert: The method should return "Email não encontrado!". +Validation: + Confirm that the method validates empty email input and handles it appropriately by returning a "not found" message. + +--- + +Scenario [6]: Login fails with null password + +Details: + TestName: nullPasswordReturnsErrorMessage + Description: Verify the method returns "Senha incorreta" when the email exists in `UserAccRepo`, but the password input is null. + +Execution: + Arrange: Mock `UserAccRepo` to return a `User_Credentials` object with a valid email. + Act: Call `loginUser` with a valid email and a null password. + Assert: The method should return "Senha incorreta". +Validation: + Ensure the method handles null passwords gracefully without producing a runtime error and returns the appropriate error message. + +--- + +Scenario [7]: Login fails with empty password + +Details: + TestName: emptyPasswordReturnsErrorMessage + Description: Validate that the method returns "Senha incorreta" when an empty password is provided and the email exists in `UserAccRepo`. + +Execution: + Arrange: Mock `UserAccRepo` to return a `User_Credentials` object with a valid email. + Act: Call `loginUser` with a valid email and an empty password. + Assert: The method should return "Senha incorreta". +Validation: + Verify that the method checks for non-empty passwords and appropriately rejects empty password inputs. + +--- + +Scenario [8]: Case-sensitivity of email and password during login + +Details: + TestName: caseSensitivityInEmailAndPassword + Description: Confirm the method is case-sensitive for both the email and password. Validate that different cases yield incorrect login responses. + +Execution: + Arrange: Mock `UserAccRepo` to return a specific `User_Credentials` object with case-sensitive credentials (e.g., "User@example.com" and "P@ssw0rd"). + Act: Pass email and/or password with altered case (e.g., "user@example.COM" and "p@SSW0RD") to the `loginUser` method. + Assert: The method should return "Email não encontrado!" or "Senha incorreta" for variations in case. +Validation: + Ensure that the authentication logic respects character casing, enforcing security and accuracy in credential matching. + +--- + +Scenario [9]: Check for SQL injection vulnerability + +Details: + TestName: inputValidationForSqlInjection + Description: Test whether the method handles input strings that could potentially act as SQL code, ensuring the system is safe from injection attacks. + +Execution: + Arrange: Mock `UserAccRepo` to simulate database operations. Pass an email string with SQL injection (e.g., "'; DROP TABLE users --"). + + Act: Call `loginUser` with malicious SQL-injection-like inputs for both email and password. + Assert: The method should not execute any database changes and return "Email não encontrado!". +Validation: + Verify that the method and its repository layer prevent SQL injection from affecting database integrity by ensuring proper input sanitization. + +--- + +Scenario [10]: Login when `UserAccRepo` is unavailable + +Details: + TestName: handleUserRepoFailureGracefully + Description: Simulate a failure or unavailability of `UserAccRepo` (e.g., returning a database error or null unexpectedly). Check that the method handles this scenario and provides a fallback response. + +Execution: + Arrange: Set up mock behavior for `UserAccRepo` to throw an exception or simulate a connection failure. + Act: Call `loginUser` with any input when `UserAccRepo` is unavailable. + Assert: Validate that the method throws an appropriate exception or messages the caller with a valid error response. +Validation: + Ensure the application handles backend failures gracefully by not exposing technical details and offering a fallback mechanism to the user. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.User_Credentials; +import com.medeiros.SPRINGProject.Models.UserAccRepository; +import com.medeiros.SPRINGProject.Security.JwtUtil; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.*; +import org.junit.jupiter.api.*; +import java.util.Objects; +import com.medeiros.SPRINGProject.Models.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +@ExtendWith(MockitoExtension.class) +class AuthControllerLoginUserTest { + + @Mock + private UserAccRepository UserAccRepo; // Corrected the import name for + // UserAccRepository. + + @InjectMocks + private AuthController authController; + + @BeforeEach + void setUp() { + authController = new AuthController(); + authController.UserAccRepo = this.UserAccRepo; + } + + @Test + @Tag("valid") + public void successfulLoginWithValidCredentials() { + String email = "test@example.com"; + String password = "securePassword"; + User_Credentials mockUser = new User_Credentials(email, password, "TestUser"); + when(UserAccRepo.findUserByEmail(email)).thenReturn(mockUser); + String actualResult = authController.loginUser(email, password); + assertEquals((Object) "Logado", (Object) actualResult); + } + + @Test + @Tag("invalid") + public void incorrectPasswordReturnsErrorMessage() { + String email = "test@example.com"; + String password = "wrongPassword"; + User_Credentials mockUser = new User_Credentials(email, "securePassword", "TestUser"); + when(UserAccRepo.findUserByEmail(email)).thenReturn(mockUser); + String actualResult = authController.loginUser(email, password); + assertEquals((Object) "Senha incorreta", (Object) actualResult); + } + + @Test + @Tag("invalid") + public void nonExistentEmailReturnsError() { + String email = "nonexistent@example.com"; + String password = "password"; + when(UserAccRepo.findUserByEmail(email)).thenReturn(null); + String actualResult = authController.loginUser(email, password); + assertEquals((Object) "Email não encontrado!", (Object) actualResult); + } + + @Test + @Tag("invalid") + public void nullEmailReturnsEmailNotFound() { + String email = null; + String password = "password"; + when(UserAccRepo.findUserByEmail(email)).thenReturn(null); + String actualResult = authController.loginUser(email, password); + assertEquals((Object) "Email não encontrado!", (Object) actualResult); + } + + @Test + @Tag("invalid") + public void emptyEmailReturnsEmailNotFound() { + String email = ""; + String password = "password"; + when(UserAccRepo.findUserByEmail(email)).thenReturn(null); + String actualResult = authController.loginUser(email, password); + assertEquals((Object) "Email não encontrado!", (Object) actualResult); + } + + @Test + @Tag("invalid") + public void nullPasswordReturnsErrorMessage() { + String email = "test@example.com"; + String password = null; + User_Credentials mockUser = new User_Credentials(email, "securePassword", "TestUser"); + when(UserAccRepo.findUserByEmail(email)).thenReturn(mockUser); + String actualResult = authController.loginUser(email, password); + assertEquals((Object) "Senha incorreta", (Object) actualResult); + } + + @Test + @Tag("invalid") + public void emptyPasswordReturnsErrorMessage() { + String email = "test@example.com"; + String password = ""; + User_Credentials mockUser = new User_Credentials(email, "securePassword", "TestUser"); + when(UserAccRepo.findUserByEmail(email)).thenReturn(mockUser); + String actualResult = authController.loginUser(email, password); + assertEquals((Object) "Senha incorreta", (Object) actualResult); + } + + @Test + @Tag("boundary") + public void caseSensitivityInEmailAndPassword() { + String email = "User@example.com"; + String password = "P@ssw0rd"; + User_Credentials mockUser = new User_Credentials(email, password, "TestUser"); + when(UserAccRepo.findUserByEmail(email)).thenReturn(mockUser); + String actualResultLowerEmail = authController.loginUser(email.toLowerCase(), password); + String actualResultUpperPassword = authController.loginUser(email, password.toUpperCase()); + assertEquals((Object) "Email não encontrado!", (Object) actualResultLowerEmail); + assertEquals((Object) "Senha incorreta", (Object) actualResultUpperPassword); + } + + @Test + @Tag("invalid") + public void inputValidationForSqlInjection() { + String email = "'; DROP TABLE users --"; + String password = "'; DROP TABLE users --"; + when(UserAccRepo.findUserByEmail(email)).thenReturn(null); + String actualResult = authController.loginUser(email, password); + assertEquals((Object) "Email não encontrado!", (Object) actualResult); + } + + @Test + @Tag("integration") + public void handleUserRepoFailureGracefully() { + String email = "test@example.com"; + String password = "password"; + when(UserAccRepo.findUserByEmail(email)).thenThrow(new RuntimeException("Database Error")); + try { + authController.loginUser(email, password); + } + catch (Exception e) { + assertEquals((Object) "Database Error", (Object) e.getMessage()); + } + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerCreateForumIndexTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerCreateForumIndexTest.java new file mode 100644 index 0000000..af509cf --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerCreateForumIndexTest.java @@ -0,0 +1,286 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=createForumIndex_fec126ecbb +ROOST_METHOD_SIG_HASH=createForumIndex_d46662bc78 + + +Scenario 1: Successfully create a forum index with valid parameters + +Details: + TestName: createForumIndexSuccessfullyWithValidParameters + Description: This test verifies that the `createForumIndex` method properly creates a forum index when given valid forum name, description, and user ID. It ensures that the created forum is saved in the repository and the method returns the expected success message. + +Execution: + Arrange: Set up mock instances of `ForumIndexRepo` to simulate interaction with the repository. Prepare valid inputs for `nameForum`, `forumDescription`, and `userId`. + Act: Invoke `createForumIndex` with the valid input values. + Assert: Check that `ForumIndexRepo.save(newForum)` was called with the correct forum data and that the returned value matches "Forum criado". + +Validation: + This test confirms the method correctly processes valid inputs, interacts with the repository, and returns appropriate success feedback. It verifies that a forum index can be created as expected in normal scenarios. + +--- + +Scenario 2: Handle empty forum name + +Details: + TestName: createForumIndexWithEmptyForumName + Description: This test ensures that the `createForumIndex` method handles a scenario where an empty string is passed as the `nameForum` parameter. + +Execution: + Arrange: Mock the `ForumIndexRepo`, define an empty string for `nameForum`, prepare a valid `forumDescription` and `userId`. + Act: Call `createForumIndex` with the empty string for `nameForum`. + Assert: Confirm that the returned value is still "Forum criado" and `ForumIndexRepo.save(newForum)` was invoked with the correct parameters. + +Validation: + Verifies the robustness of the method when receiving an empty forum name, ensuring the system maintains expected behavior. + +--- + +Scenario 3: Create a forum with a lengthy description + +Details: + TestName: createForumIndexWithLongForumDescription + Description: Test the method's ability to handle a very long text input for `forumDescription` to ensure it can manage large descriptions without failure. + +Execution: + Arrange: Generate a very long string (e.g., 10,000 characters) for `forumDescription`, mock the `ForumIndexRepo`. Use valid `nameForum` and `userId`. + Act: Invoke `createForumIndex` with the long `forumDescription`. + Assert: Verify that `ForumIndexRepo.save(newForum)` was called with the long description parameter. Confirm the return value matches "Forum criado". + +Validation: + Ensures that the application properly handles excessively lengthy descriptions without throwing exceptions or truncating data unexpectedly. + +--- + +Scenario 4: Create a forum with special characters in the name + +Details: + TestName: createForumIndexWithSpecialCharactersInName + Description: This test verifies the method's functionality when the `nameForum` parameter includes special characters (e.g., symbols or emojis). + +Execution: + Arrange: Create a `nameForum` string containing special characters (e.g., "Forum! @# 😊"), along with a valid `forumDescription` and `userId`. Mock the `ForumIndexRepo`. + Act: Invoke `createForumIndex` using the special-character string as `nameForum`. + Assert: Confirm the repository saves the forum correctly and the return value is "Forum criado". + +Validation: + Verifies that the system accepts and processes special characters in forum names, ensuring inclusivity and robustness. + +--- + +Scenario 5: Handle negative user ID input + +Details: + TestName: createForumIndexWithNegativeUserId + Description: Verify the behavior of the method when a negative `userId` is provided. + +Execution: + Arrange: Set up a mock for the `ForumIndexRepo`. Use a valid `nameForum` and `forumDescription`, but set `userId` to a negative value (e.g., -1). + Act: Invoke `createForumIndex` using the negative `userId`. + Assert: Confirm that the method still creates a new forum index by calling `ForumIndexRepo.save(newForum)` and returns "Forum criado". + +Validation: + Ensures that the method gracefully handles invalid numerical inputs for the `userId` parameter without failure or unintended behavior. + +--- + +Scenario 6: Null inputs for all parameters + +Details: + TestName: createForumIndexWithNullInputs + Description: Test the behavior of the method when all parameters (`nameForum`, `forumDescription`, `userId`) are passed as null. + +Execution: + Arrange: Mock the `ForumIndexRepo`. Pass null values for all method parameters. + Act: Invoke `createForumIndex` with null inputs. + Assert: Verify that `ForumIndexRepo.save` was not called and the method throws or handles exceptions as expected. + +Validation: + Ensures that the application correctly handles null inputs by either rejecting them or processing them in a defined manner without system failure. + +--- + +Scenario 7: Duplicate user ID entries + +Details: + TestName: createForumIndexWithDuplicateUserId + Description: This test checks the method's behavior when multiple forums are created using the same `userId` value. + +Execution: + Arrange: Mock the `ForumIndexRepo`. Prepare valid inputs for `nameForum` and `forumDescription` along with an identical `userId`. + Act: Call `createForumIndex` multiple times, each with the same `userId`. + Assert: Confirm that `ForumIndexRepo.save` is invoked for each call and the method returns "Forum criado". + +Validation: + Demonstrates the ability to create multiple forums associated with the same user, ensuring no constraints or conflicts arise for duplicate IDs. + +--- + +Scenario 8: Missing repository dependency injection + +Details: + TestName: createForumIndexWithMissingRepositoryInjection + Description: This test verifies the method's behavior when the `ForumIndexRepo` field is not injected properly (null value). + +Execution: + Arrange: Leave `ForumIndexRepo` as null. Prepare valid inputs for `nameForum`, `forumDescription`, and `userId`. + Act: Invoke `createForumIndex`. + Assert: Expect a `NullPointerException` or similar error due to the missing repository injection. + +Validation: + Ensures that the system correctly handles missing dependency injections and alerts developers of the issue during testing. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.ForumIndexModel; +import com.medeiros.SPRINGProject.Models.ForumIndexRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import static org.mockito.Mockito.*; +import static org.junit.jupiter.api.Assertions.*; +import com.medeiros.SPRINGProject.Models.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +class ForumControllerCreateForumIndexTest { + + @Mock + private ForumIndexRepository forumIndexRepo; // Corrected to align with provided + // fields + + private ForumController forumController; + + @BeforeEach + public void setup() { + MockitoAnnotations.openMocks(this); + forumController = new ForumController(); + forumController.ForumIndexRepo = forumIndexRepo; // Injecting the mocked + // repository + } + + @Test + @Tag("valid") + public void createForumIndexSuccessfullyWithValidParameters() { + // Arrange + String nameForum = "Test Forum"; + String forumDescription = "This is a test forum description"; + int userId = 123; + // Act + String result = forumController.createForumIndex(nameForum, forumDescription, userId); + // Assert + verify(forumIndexRepo, times(1)).save(any(ForumIndexModel.class)); + assertEquals("Forum criado", (String) result); + } + + @Test + @Tag("boundary") + public void createForumIndexWithEmptyForumName() { + // Arrange + String nameForum = ""; + String forumDescription = "Forum description valid input"; + int userId = 123; + // Act + String result = forumController.createForumIndex(nameForum, forumDescription, userId); + // Assert + verify(forumIndexRepo, times(1)).save(any(ForumIndexModel.class)); + assertEquals("Forum criado", (String) result); + } + + @Test + @Tag("boundary") + public void createForumIndexWithLongForumDescription() { + // Arrange + String nameForum = "Test Forum"; + String forumDescription = "A".repeat(10000); // Very long description + int userId = 123; + // Act + String result = forumController.createForumIndex(nameForum, forumDescription, userId); + // Assert + verify(forumIndexRepo, times(1)).save(any(ForumIndexModel.class)); + assertEquals("Forum criado", (String) result); + } + + @Test + @Tag("boundary") + public void createForumIndexWithSpecialCharactersInName() { + // Arrange + String nameForum = "Forum! @# 😊"; // Special characters + String forumDescription = "Valid description"; + int userId = 123; + // Act + String result = forumController.createForumIndex(nameForum, forumDescription, userId); + // Assert + verify(forumIndexRepo, times(1)).save(any(ForumIndexModel.class)); + assertEquals("Forum criado", (String) result); + } + + @Test + @Tag("invalid") + public void createForumIndexWithNegativeUserId() { + // Arrange + String nameForum = "Test Forum"; + String forumDescription = "Test description"; + int userId = -1; // Invalid user ID + // Act + String result = forumController.createForumIndex(nameForum, forumDescription, userId); + // Assert + verify(forumIndexRepo, times(1)).save(any(ForumIndexModel.class)); + assertEquals("Forum criado", (String) result); + } + + @Test + @Tag("invalid") + public void createForumIndexWithNullInputs() { + // Arrange + String nameForum = null; + String forumDescription = null; + int userId = 0; // Suggested business logic improvement: validate for nullable + // fields. + // Suggestion: The business logic should validate for null parameters and throw + // IllegalArgumentException. + // Act and Assert + assertThrows(IllegalArgumentException.class, + () -> forumController.createForumIndex(nameForum, forumDescription, userId)); + verify(forumIndexRepo, never()).save(any(ForumIndexModel.class)); + } + + @Test + @Tag("valid") + public void createForumIndexWithDuplicateUserId() { + // Arrange + String nameForum1 = "Forum Alpha"; + String nameForum2 = "Forum Beta"; + String forumDescription = "Test description"; + int userId = 123; + // Act + String result1 = forumController.createForumIndex(nameForum1, forumDescription, userId); + String result2 = forumController.createForumIndex(nameForum2, forumDescription, userId); + // Assert + verify(forumIndexRepo, times(2)).save(any(ForumIndexModel.class)); + assertEquals("Forum criado", (String) result1); + assertEquals("Forum criado", (String) result2); + } + + @Test + @Tag("integration") + public void createForumIndexWithMissingRepositoryInjection() { + // Arrange + forumController.ForumIndexRepo = null; // Simulate missing injection + String nameForum = "Invalid Forum due to missing Repo"; + String forumDescription = "Test description"; + int userId = 123; + // Act and Assert + assertThrows(NullPointerException.class, + () -> forumController.createForumIndex(nameForum, forumDescription, userId)); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerNewMessageTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerNewMessageTest.java new file mode 100644 index 0000000..580710e --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerNewMessageTest.java @@ -0,0 +1,301 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=newMessage_7d9702b2ce +ROOST_METHOD_SIG_HASH=newMessage_f58e857aa0 + + +Scenario 1: Verify successful saving of a valid message + +Details: + TestName: saveValidMessage + Description: This test case checks that the method `newMessage` successfully saves a valid message to the `ChatRepository` when valid inputs for `message`, `userId`, and `forumId` are provided. The method should return the message string. + +Execution: + Arrange: Create a valid message string, userId, and forumId. Mock the `ChatRepository` so that any operations on it do not persist to a real database. + Act: Call the `newMessage` method with the given parameters. + Assert: Use JUnit assertions to verify that the returned value matches the input message string and that the `ChatRepository.save` method is called with the correct parameters. + +Validation: + Clarify that the assertion verifies proper message handling and storage in the repository. This ensures the functionality aligns with the application's goal of saving forum messages correctly. + +--- + +Scenario 2: Verify behavior for an empty message string + +Details: + TestName: saveEmptyMessage + Description: This test case checks the behavior of the method `newMessage` when an empty string is passed as the `message` parameter. The expectation is that the method may still save an empty message to the `ChatRepository`. + +Execution: + Arrange: Pass an empty string as the `message` parameter while providing valid `userId` and `forumId`. Mock the `ChatRepository`. + Act: Call the `newMessage` method with the given inputs. + Assert: Check that the return value matches the empty message string and that `ChatRepository.save` is called with a `ForumChatModel` containing the empty message. + +Validation: + Clarify that the test ensures the method handles edge cases involving empty input gracefully, allowing application behavior to remain consistent in diverse scenarios. + +--- + +Scenario 3: Verify behavior when `message` is null + +Details: + TestName: saveNullMessage + Description: This test checks how the `newMessage` method behaves when `null` is passed as the `message` parameter. The expectation is that the method should handle or reject null values gracefully. + +Execution: + Arrange: Set `message` to null and provide valid `userId` and `forumId`. Mock `ChatRepository` for testing. + Act: Invoke the `newMessage` method with the parameters expecting it to either throw an exception or skip storing the message in `ChatRepository`. + Assert: Use assertions to verify whether an appropriate exception is thrown or if the `save` operation is skipped. + +Validation: + Clarify that the validation aims to ensure the application handles cases where required data is missing (e.g., null input) appropriately. + +--- + +Scenario 4: Verify behavior for an invalid forumId (-1) + +Details: + TestName: invalidForumId + Description: This test checks the behavior of the `newMessage` method when an invalid forumId value (negative integer) is provided. The expectation is that the method should either reject the input or handle it gracefully without saving the message. + +Execution: + Arrange: Specify a valid `message` and `userId`, but provide an invalid negative value for `forumId`. Mock the `ChatRepository`. + Act: Call the `newMessage` method with the arranged inputs. + Assert: Verify whether the method rejects the input or skips calling `ChatRepository.save`. + +Validation: + Clarify that the purpose of the test is to secure the application against unintended behavior from invalid forum identifiers. + +--- + +Scenario 5: Verify behavior for an invalid userId (-1) + +Details: + TestName: invalidUserId + Description: This test evaluates how the `newMessage` method handles an invalid userId (negative integer) while working with valid `message` and `forumId`. The expectation is that the method avoids saving the message. + +Execution: + Arrange: Provide a valid `message` and `forumId` but set an invalid negative value for `userId`. Mock `ChatRepository`. + Act: Call the `newMessage` method with the prepared inputs. + Assert: Verify that either an error is thrown or the message is not saved in `ChatRepository`. + +Validation: + Clarify that this test ensures the integrity of data by preventing invalid user identifiers from being processed. + +--- + +Scenario 6: Verify multiple consecutive calls with similar inputs + +Details: + TestName: consecutiveMessageCalls + Description: This test case verifies the behavior of the `newMessage` method when it is called multiple times consecutively with the same inputs. The expectation is that each call successfully saves the message even if the inputs are identical. + +Execution: + Arrange: Provide valid `message`, `userId`, and `forumId`. Mock `ChatRepository` to record successive calls. + Act: Call the `newMessage` method multiple times with identical inputs. + Assert: Use assertions to verify that the `ChatRepository.save` method was invoked each time with identical parameters, and the returned values match the given `message` string. + +Validation: + Clarify that the test ensures the method consistently handles repeated calls without unexpected behavior or skipping saves. + +--- + +Scenario 7: Verify behavior when `ChatRepository` is unavailable + +Details: + TestName: repositoryUnavailable + Description: This test checks the response of the `newMessage` method when the `ChatRepository` service is unavailable or null. The expectation is that the method handles the situation gracefully without causing a crash or unexpected behavior. + +Execution: + Arrange: Set up valid inputs for `message`, `userId`, and `forumId` but mock `ChatRepository` to simulate an unavailable or null state. + Act: Invoke the `newMessage` method within these mocked conditions. + Assert: Verify that an exception is raised or the method handles the scenario safely without saving the message. + +Validation: + Clarify that the test ensures robustness in the application's handling of external dependencies. + +--- + +Scenario 8: Verify behavior when the database fails during save operation + +Details: + TestName: databaseSaveFailure + Description: This test examines the behavior of the `newMessage` method when the database throws an error (e.g., SQLException) during the `ChatRepository.save` operation. + +Execution: + Arrange: Provide valid inputs but mock `ChatRepository` to throw an exception during its `save` method. + Act: Call the `newMessage` method to simulate the scenario. + Assert: Verify that the method handles the exception (e.g., logs an error, skips save operation) without propagating it further unexpectedly. + +Validation: + Clarify that the test ensures the application remains stable during database failures by handling errors gracefully. + +--- + +Scenario 9: Verify behavior when inputs exceed expected size limits + +Details: + TestName: oversizedMessageInput + Description: This test assesses how the `newMessage` method handles oversized `message` inputs that exceed standard application limits (e.g., maximum character length). + +Execution: + Arrange: Construct an excessively long `message` string and pair it with valid `userId` and `forumId`. Mock `ChatRepository`. + Act: Invoke the `newMessage` method with the oversized input. + Assert: Ensure that either the method trims the `message`, rejects it, or properly saves the oversized input without corruption. + +Validation: + Clarify that this test validates scalability in input handling and application stability with large-sized data inputs. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.ForumChatModel; +import com.medeiros.SPRINGProject.Models.ForumChatRepository; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; +import com.medeiros.SPRINGProject.Models.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +class ForumControllerNewMessageTest { + + @Mock + private ForumChatRepository chatRepository; // Corrected the symbol name matching the + // function's actual repository + + @InjectMocks + private ForumController forumController; + + @Test + @Tag("valid") + public void saveValidMessage() { + String validMessage = "Hello Forum"; + int userId = 10; + int forumId = 20; + ForumChatModel expectedModel = new ForumChatModel(validMessage, userId, forumId); + when(chatRepository.save(Mockito.any(ForumChatModel.class))).thenReturn(expectedModel); + String result = forumController.newMessage(validMessage, userId, forumId); + assertEquals((String) validMessage, result); + verify(chatRepository, times(1)).save(expectedModel); + } + + @Test + @Tag("valid") + public void saveEmptyMessage() { + String emptyMessage = ""; + int userId = 10; + int forumId = 20; + ForumChatModel expectedModel = new ForumChatModel(emptyMessage, userId, forumId); + when(chatRepository.save(Mockito.any(ForumChatModel.class))).thenReturn(expectedModel); + String result = forumController.newMessage(emptyMessage, userId, forumId); + assertEquals((String) emptyMessage, result); + verify(chatRepository, times(1)).save(expectedModel); + } + + @Test + @Tag("invalid") + public void saveNullMessage() { + // Business logic needs improvement to handle null input, adding comment + // Suggestion: Add a null check for the `message` parameter in the function + // implementation + String message = null; + int userId = 10; + int forumId = 20; + assertThrows(IllegalArgumentException.class, () -> forumController.newMessage(message, userId, forumId)); + verify(chatRepository, never()).save(Mockito.any()); + } + + @Test + @Tag("invalid") + public void invalidForumId() { + String validMessage = "Forum Message"; + int userId = 10; + int invalidForumId = -1; + // Business logic needs improvement to validate the forumId, adding comment + // Suggestion: Add a validation to check if forumId is positive + ForumChatModel model = new ForumChatModel(validMessage, userId, invalidForumId); + when(chatRepository.save(Mockito.any())).thenReturn(model); + String result = forumController.newMessage(validMessage, userId, invalidForumId); + assertEquals((String) validMessage, result); + verify(chatRepository, times(1)).save(Mockito.any()); + } + + @Test + @Tag("invalid") + public void invalidUserId() { + String validMessage = "Message for User"; + int invalidUserId = -1; + int forumId = 20; + // Business logic needs improvement to validate the userId, adding comment + // Suggestion: Add a validation to check if userId is positive + ForumChatModel model = new ForumChatModel(validMessage, invalidUserId, forumId); + when(chatRepository.save(Mockito.any())).thenReturn(model); + String result = forumController.newMessage(validMessage, invalidUserId, forumId); + assertEquals((String) validMessage, result); + verify(chatRepository, times(1)).save(Mockito.any()); + } + + @Test + @Tag("boundary") + public void consecutiveMessageCalls() { + String message = "Repeated Message"; + int userId = 10; + int forumId = 20; + ForumChatModel model = new ForumChatModel(message, userId, forumId); + when(chatRepository.save(Mockito.any())).thenReturn(model); + String firstResult = forumController.newMessage(message, userId, forumId); + String secondResult = forumController.newMessage(message, userId, forumId); + assertEquals((String) message, firstResult); + assertEquals((String) message, secondResult); + verify(chatRepository, times(2)).save(Mockito.any()); + } + + @Test + @Tag("integration") + public void repositoryUnavailable() { + String validMessage = "Missing Repository"; + int userId = 10; + int forumId = 20; + doThrow(new RuntimeException("Repository Unavailable")).when(chatRepository).save(Mockito.any()); + assertThrows(RuntimeException.class, () -> forumController.newMessage(validMessage, userId, forumId)); + verify(chatRepository, times(1)).save(Mockito.any()); + } + + @Test + @Tag("integration") + public void databaseSaveFailure() { + String validMessage = "Database Error"; + int userId = 10; + int forumId = 20; + doThrow(new RuntimeException("Database Failure")).when(chatRepository).save(Mockito.any()); + assertThrows(RuntimeException.class, () -> forumController.newMessage(validMessage, userId, forumId)); + verify(chatRepository, times(1)).save(Mockito.any()); + } + + @Test + @Tag("boundary") + public void oversizedMessageInput() { + // Business logic needs improvement for oversized input, adding comment + // Suggestion: Add message size validation to limit the input size based on known + // constraints + String longMessage = "This is a very long message exceeding the database constraints..."; + int userId = 10; + int forumId = 20; + ForumChatModel model = new ForumChatModel(longMessage, userId, forumId); + when(chatRepository.save(Mockito.any())).thenReturn(model); + String result = forumController.newMessage(longMessage, userId, forumId); + assertEquals((String) longMessage, result); + verify(chatRepository, times(1)).save(Mockito.any()); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerShowMessagesTest.java.invalid b/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerShowMessagesTest.java.invalid new file mode 100644 index 0000000..98cc713 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerShowMessagesTest.java.invalid @@ -0,0 +1,246 @@ +//This test file is marked invalid as it contains compilation errors. Change the extension to of this file to .java, to manually edit its contents + + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=showMessages_7de7018eb8 +ROOST_METHOD_SIG_HASH=showMessages_778e9dc544 + + +Scenario 1: Verify that showMessages returns all messages when ChatRepository contains data. + +Details: + TestName: returnsAllMessagesFromChatRepository + Description: The test verifies that the showMessages method correctly retrieves all ForumChatModel objects from ChatRepository when data is available. +Execution: + Arrange: Mock ChatRepository with prepopulated ForumChatModel objects. + Act: Call the showMessages method. + Assert: Assert that the returned Iterable contains all the expected ForumChatModel objects. +Validation: + The assertion verifies that the method accesses the ChatRepository correctly and retrieves all stored messages. This confirms the expected behavior of obtaining all messages in the system. + +Scenario 2: Verify that showMessages returns an empty list when ChatRepository has no data. + +Details: + TestName: returnsEmptyListWhenChatRepositoryIsEmpty + Description: The test checks that the showMessages method correctly handles a scenario where the ChatRepository has no ForumChatModel objects stored. +Execution: + Arrange: Mock ChatRepository with no data (empty repository). + Act: Call the showMessages method. + Assert: Assert that the returned Iterable is empty. +Validation: + This ensures that the method correctly handles cases of an empty repository, returning no messages as expected without errors. + +Scenario 3: Verify that showMessages does not interact with other repositories (ForumIndexRepo or Log). + +Details: + TestName: doesNotInteractWithOtherRepositories + Description: This test ensures that the showMessages method interacts exclusively with ChatRepository and does not access data from ForumIndexRepo or Log. +Execution: + Arrange: Mock all repositories (ChatRepository, Log, and ForumIndexRepo) and verify interactions. + Act: Call the showMessages method. + Assert: Verify that only the ChatRepository interaction occurs while Log and ForumIndexRepo remain untouched. +Validation: + This confirms the integrity and scope of the showMessages method, ensuring it is limited to its intended functionality and repository. + +Scenario 4: Verify showMessages handles large datasets efficiently. + +Details: + TestName: handlesLargeDatasetsInChatRepository + Description: Validate that the showMessages method correctly iterates and retrieves a large number of ForumChatModel objects from ChatRepository without performance degradation or errors. +Execution: + Arrange: Mock ChatRepository with thousands of ForumChatModel objects. + Act: Call the showMessages method. + Assert: Assert that the returned Iterable contains all the mock data and ensure no performance issues arise during the retrieval. +Validation: + This test ensures scalability and reliability by validating the method's performance under scenarios with large datasets. + +Scenario 5: Verify that showMessages returns immutable results when ChatRepository changes after invocation. + +Details: + TestName: verifiesImmutableResultsDuringRepositoryChange + Description: Ensure the showMessages method produces consistent results even if the ChatRepository state changes after invocation. +Execution: + Arrange: Mock ChatRepository with initial data. Start the retrieval process by calling showMessages and simultaneously manipulate the repository state (add/remove objects). + Act: Call the showMessages method. + Assert: Verify that the results are consistent based on the original state during invocation. +Validation: + This ensures that the method's return is deterministic and does not change if the repository is modified post-call. + +Scenario 6: Verify null safety by ensuring showMessages does not throw errors when ChatRepository is null. + +Details: + TestName: handlesNullChatRepositoryGracefully + Description: Validate that the showMessages method handles the scenario where ChatRepository is null without crashing or throwing unexpected errors. +Execution: + Arrange: Set ChatRepository to null, mocking its behavior accordingly. + Act: Call the showMessages method. + Assert: Ensure that no null pointer exceptions or other runtime errors are thrown during execution. +Validation: + This confirms the method's robustness in handling edge cases where dependencies might be improperly initialized. + +Scenario 7: Verify showMessages handles concurrent access correctly. + +Details: + TestName: handlesConcurrentAccessToChatRepository + Description: This test ensures that the showMessages method functions correctly when multiple threads access or modify ChatRepository concurrently. +Execution: + Arrange: Mock ChatRepository and set up a multi-threaded environment to read data from the repository while modifying it simultaneously. + Act: Call the showMessages method from multiple threads. + Assert: Verify that the method behaves consistently and retrieves data without any concurrency issues or race conditions. +Validation: + This ensures that the method remains reliable in multi-threaded environments, adhering to thread-safe principles when accessing shared resources. + +Scenario 8: Verify the method interacts with a mock implementation of ChatRepository. + +Details: + TestName: interactsWithMockChatRepository + Description: Test that the showMessages method can be used with a mock implementation of ChatRepository and correctly retrieves data using the mock's interface. +Execution: + Arrange: Create a mock implementation of ChatRepository and populate it with sample data. + Act: Call the showMessages method. + Assert: Verify that the data retrieved matches the mock repository's contents. +Validation: + This confirms that the method is properly designed to interact with alternate implementations or mock repositories, facilitating testing and extensibility. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers;import com.medeiros.SPRINGProject.Models.ForumChatModel; +import com.medeiros.SPRINGProject.Models.ForumChatRepository; +import com.medeiros.SPRINGProject.Models.ForumIndexRepository; +import com.medeiros.SPRINGProject.Models.LogRepository; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.BeforeEach; +import org.mockito.Mockito; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import java.util.Arrays; +import java.util.Collections; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.*; +import com.medeiros.SPRINGProject.Models.*; +import org.springframework.web.bind.annotation.*; + + // Added import for ChatRepository + // Added import for ForumIndexRepo + // Added import for Log +@SpringBootTest +public class ForumControllerShowMessagesTest { + @Autowired + private ForumController forumController; + private ForumChatRepository mockChatRepository; + @BeforeEach + public void setUp() { + mockChatRepository = Mockito.mock(ForumChatRepository.class); // Corrected the class name from ChatRepository to ForumChatRepository + forumController = new ForumController(mockChatRepository); // Constructor corrected with proper argument + } + @Test + @Tag("valid") + public void returnsAllMessagesFromChatRepository() { + // Arrange + ForumChatModel message1 = new ForumChatModel("Message 1", 1, 1); + ForumChatModel message2 = new ForumChatModel("Message 2", 2, 1); + when(mockChatRepository.findAll()).thenReturn(Arrays.asList(message1, message2)); + // Act + Iterable messages = forumController.showMessages(); + // Assert + assertEquals(Arrays.asList(message1, message2), (Iterable) messages); + } + @Test + @Tag("boundary") + public void returnsEmptyListWhenChatRepositoryIsEmpty() { + // Arrange + when(mockChatRepository.findAll()).thenReturn(Collections.emptyList()); + // Act + Iterable messages = forumController.showMessages(); + // Assert + assertEquals(Collections.emptyList(), (Iterable) messages); + } + @Test + @Tag("integration") + public void doesNotInteractWithOtherRepositories() { + // Arrange + ForumIndexRepository mockForumIndexRepo = mock(ForumIndexRepository.class); // Corrected type from ForumIndexRepo to ForumIndexRepository + LogRepository mockLog = mock(LogRepository.class); // Corrected type from Log to LogRepository + // Act + forumController.showMessages(); + // Assert + verify(mockChatRepository, times(1)).findAll(); + verifyNoInteractions(mockForumIndexRepo, mockLog); // Corrected types + } + @Test + @Tag("valid") + public void handlesLargeDatasetsInChatRepository() { + // Arrange + ForumChatModel[] largeDataset = new ForumChatModel[100000]; + for (int i = 0; i < largeDataset.length; i++) { + largeDataset[i] = new ForumChatModel("Message " + i, i, 1); + } + when(mockChatRepository.findAll()).thenReturn(Arrays.asList(largeDataset)); + // Act + Iterable messages = forumController.showMessages(); + // Assert + assertEquals(Arrays.asList(largeDataset), (Iterable) messages); + } + @Test + @Tag("boundary") + public void verifiesImmutableResultsDuringRepositoryChange() { + // Arrange + ForumChatModel initialMessage = new ForumChatModel("Initial Message", 1, 1); + when(mockChatRepository.findAll()).thenReturn(Collections.singletonList(initialMessage)); + // Act + Iterable initialMessages = forumController.showMessages(); + ForumChatModel newMessage = new ForumChatModel("New Message", 2, 1); + when(mockChatRepository.findAll()).thenReturn(Collections.singletonList(newMessage)); + Iterable updatedMessages = forumController.showMessages(); + // Assert + assertEquals(Collections.singletonList(initialMessage), initialMessages); + assertEquals(Collections.singletonList(newMessage), updatedMessages); + } + @Test + @Tag("invalid") + public void handlesNullChatRepositoryGracefully() { + // Added comment for improvement in business logic + // Improvement needed in business logic: Add null checks in the `showMessages` method for the `ChatRepository`. + // Arrange + forumController = new ForumController(null); + // Act & Assert + assertThrows(NullPointerException.class, () -> forumController.showMessages()); + } + @Test + @Tag("boundary") + public void handlesConcurrentAccessToChatRepository() throws InterruptedException { + // Arrange + ExecutorService executorService = Executors.newFixedThreadPool(10); + ForumChatModel message1 = new ForumChatModel("Message 1", 1, 1); + ForumChatModel message2 = new ForumChatModel("Message 2", 2, 1); + when(mockChatRepository.findAll()).thenReturn(Arrays.asList(message1, message2)); + // Act + for (int i = 0; i < 10; i++) { + executorService.execute(() -> forumController.showMessages()); + } + executorService.shutdown(); + executorService.awaitTermination(1, TimeUnit.MINUTES); + // Assert + verify(mockChatRepository, times(10)).findAll(); + } + @Test + @Tag("integration") + public void interactsWithMockChatRepository() { + // Arrange + ForumChatModel message = new ForumChatModel("Test Message", 1, 1); + when(mockChatRepository.findAll()).thenReturn(Collections.singletonList(message)); + // Act + Iterable messages = forumController.showMessages(); + // Assert + assertEquals(Collections.singletonList(message), (Iterable) messages); + } +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/LogControllerShowAllLogTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/LogControllerShowAllLogTest.java new file mode 100644 index 0000000..bcee356 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/LogControllerShowAllLogTest.java @@ -0,0 +1,76 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=showAllLog_66d6a0e563 +ROOST_METHOD_SIG_HASH=showAllLog_dafc374432 + + +Scenario [1]: Verify the method returns all log entries when the repository contains data. + +Details: + TestName: returnsAllLogsWhenRepositoryHasData + Description: This test verifies that the `showAllLog` method returns all log entries from the repository when the repository contains multiple log entries. It checks if the method fetches the complete log list correctly. + +Execution: + Arrange: Mock the `LogRepository` to simulate a repository with multiple log entries. Prepare sample `LogModel` instances and configure the repository to return them when `findAll` is invoked. + Act: Call the `showAllLog` method from the `LogController` class. + Assert: Compare the returned result from `showAllLog` with the mocked repository data using JUnit assertions. + +Validation: + Verify that the method correctly retrieves all log entries as stored in the repository and returns them seamlessly. This test ensures the functionality of retrieving complete logs when data exists. + +*/ + +// ********RoostGPT******** + +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.LogModel; +import com.medeiros.SPRINGProject.Models.LogRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import java.util.Arrays; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.when; +import org.junit.jupiter.api.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +public class LogControllerShowAllLogTest { + + @Mock + private LogRepository logRepository; + + @InjectMocks + private LogController logController; + + @BeforeEach + public void setUp() { + MockitoAnnotations.openMocks(this); + } + + @Test + @Tag("valid") + public void testReturnsAllLogsWhenRepositoryHasData() { + // Arrange + LogModel log1 = new LogModel(); // TODO: Add valid values for log1 fields as per + // LogModel structure + LogModel log2 = new LogModel(); // TODO: Add valid values for log2 fields as per + // LogModel structure + Iterable mockLogEntries = Arrays.asList(log1, log2); + when(logRepository.findAll()).thenReturn(mockLogEntries); + // Act + Iterable result = logController.showAllLog(); + // Assert + assertEquals(mockLogEntries, result, "Expected all logs to be fetched from repository."); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/MarketControllerCreateProductTest.java.invalid b/src/test/java/com/medeiros/SPRINGProject/Controllers/MarketControllerCreateProductTest.java.invalid new file mode 100644 index 0000000..9446707 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/MarketControllerCreateProductTest.java.invalid @@ -0,0 +1,305 @@ +//This test file is marked invalid as it contains compilation errors. Change the extension to of this file to .java, to manually edit its contents + + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=createProduct_2b4ce50b8c +ROOST_METHOD_SIG_HASH=createProduct_7aa14a7887 + + +Scenario 1: Valid input creates new product successfully +Details: + TestName: validInputCreatesProductSuccessfully + Description: Verify that when valid inputs are provided, the method successfully creates a new product and returns the correct confirmation message. +Execution: + Arrange: Mock the ProductRepository and LogRepository, and set up stub methods for `save` that simulate successful saving of a product and a log entry. Set valid arguments for all input parameters. + Act: Call createProduct with valid values for `description`, `price`, `musicId`, `userId`, and `listProduct`. + Assert: Check that the returned string is "Produto Criado" and ensure that `save` has been called on both repositories. +Validation: + Ensures that the system properly saves valid product entries into the repository, logs the creation event, and returns the success message. + +Scenario 2: Handles empty description input gracefully +Details: + TestName: handlesEmptyDescription + Description: Confirm that the method handles an empty string passed as the `description` parameter without errors and that the product is still created in the repository. +Execution: + Arrange: Mock the ProductRepository and LogRepository, and set up stub methods for `save`. Set other parameters validly and the `description` as an empty string (""). + Act: Invoke createProduct with an empty string for the `description`. + Assert: Verify that `save` is still invoked for the product creation and the returned value is "Produto Criado". +Validation: + Ensures the system allows empty descriptions for products and handles such edge cases gracefully without breaking functionality. + +Scenario 3: Handles negative price input gracefully +Details: + TestName: handlesNegativePrice + Description: Ensure that if a negative value is passed for `price`, the method does not throw exceptions and the product is saved in the repository correctly. +Execution: + Arrange: Mock the ProductRepository and LogRepository, and set up stub methods for `save`. Use valid values for all parameters except pass a negative value for `price`. + Act: Call createProduct with `price` set to a negative number. + Assert: Confirm that the method still saves the product and returns "Produto Criado". +Validation: + Validates that the system accepts products with negative prices without failing, highlighting flexibility in price constraints. + +Scenario 4: Handles invalid userId gracefully +Details: + TestName: handlesInvalidUserId + Description: Test whether the method can handle invalid (e.g., negative) `userId` values without causing errors during product creation. +Execution: + Arrange: Mock the ProductRepository and LogRepository, and set up stub methods for `save`. Pass valid inputs for all parameters except set a negative integer for `userId`. + Act: Invoke createProduct with an invalid `userId`. + Assert: Confirm that the product is saved successfully and the success message "Produto Criado" is returned. +Validation: + Confirms that the system tolerates invalid or edge-case user ID inputs and still processes product records properly. + +Scenario 5: Handles large product list gracefully +Details: + TestName: handlesLargeProductList + Description: Verify the method's ability to process large strings for the `listProduct` parameter without errors or truncation. +Execution: + Arrange: Mock the repositories and prepare valid inputs for all parameters except use a very long string containing thousands of characters for `listProduct`. + Act: Call createProduct with this large input. + Assert: Verify that the product is saved, no exceptions are thrown, and the result "Produto Criado" is returned. +Validation: + Validates the method's robustness to handle large values for input, ensuring applications can handle extensive data loads. + +Scenario 6: Fails gracefully with null ProductRepository +Details: + TestName: failsGracefullyWithNullRepository + Description: Confirm that the method behaves appropriately when the `ProductRepository` instance is null and does not lead to unexpected exceptions. +Execution: + Arrange: Leave the `ProductRepository` instance uninitialized (null) while mocking valid inputs for parameters. + Act: Call createProduct with typical valid values. + Assert: Catch the NullPointerException and verify proper handling with no unexpected behavior. +Validation: + Ensures the system gracefully handles scenarios where repository instances are not initialized, maintaining application stability. + +Scenario 7: Logs entry properly upon product creation +Details: + TestName: logsEntryOnProductCreation + Description: Ensure that the LogRepository correctly saves a log entry whenever the method creates a new product. +Execution: + Arrange: Mock both the ProductRepository and LogRepository, setting expected behaviors for the `save` method. Provide valid inputs for all parameters. + Act: Call createProduct to create a product. + Assert: Validate that the `LogRepository.save` method is invoked with the correct log details, including action type and timestamp matching `Date.getTimeNow()`. +Validation: + Confirms that the logging mechanism captures each product creation, providing traceability for business actions. + +Scenario 8: Handles null description gracefully +Details: + TestName: handlesNullDescription + Description: Verify the behavior of the method when a null value is passed for the `description` input parameter. +Execution: + Arrange: Mock the repositories and prepare valid values for all parameters except pass null for `description`. + Act: Call createProduct with a null `description`. + Assert: Verify that the method either throws an exception or handles the null gracefully while returning the expected response. +Validation: + Ensures robust handling of null values for key parameters, supporting application stability and resilience. + +Scenario 9: Handles invalid musicId input gracefully +Details: + TestName: handlesInvalidMusicId + Description: Test whether the method gracefully processes invalid values for the `musicId`, such as negative integers or zero. +Execution: + Arrange: Mock ProductRepository and LogRepository, passing valid inputs for all parameters but using invalid values (e.g., -1 or 0) for `musicId`. + Act: Call createProduct with the invalid `musicId`. + Assert: Confirm the method's behavior and response, ensuring no unexpected behavior. +Validation: + Confirms that the system remains stable under potentially invalid identifiers for music records. + +Scenario 10: Fails gracefully with null LogRepository +Details: + TestName: failsGracefullyWithNullLogRepository + Description: Validate the method’s handling when the `LogRepository` instance is null and a product is created successfully. +Execution: + Arrange: Leave the `LogRepository` instance uninitialized (null) while mocking valid product parameters and behavior for `ProductRepository`. + Act: Call createProduct with typical valid values. + Assert: Catch exceptions related to using a null `LogRepository`, ensuring no application crashes. +Validation: + Ensures graceful application degradation and better stability in cases of logging failures. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers;import com.medeiros.SPRINGProject.Models.LogModel; +import com.medeiros.SPRINGProject.Models.LogRepository; +import com.medeiros.SPRINGProject.Models.ProductModel; +import com.medeiros.SPRINGProject.Models.ProductModelRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +public class MarketControllerCreateProductTest { + private MarketController marketController; + @Mock + private ProductModelRepository mockProductRepository; + @Mock + private LogRepository mockLogRepository; + @Mock + private LogModel mockDate; + @BeforeEach + public void setUp() { + MockitoAnnotations.openMocks(this); + marketController = new MarketController(mockProductRepository, mockLogRepository); + } + @Test + @Tag("valid") + public void validInputCreatesProductSuccessfully() { + // Arrange + ProductModel mockProductModel = mock(ProductModel.class); + Mockito.doNothing().when(mockProductRepository).save(any(ProductModel.class)); + Mockito.doNothing().when(mockLogRepository).save(any(LogModel.class)); + String description = "Valid Product"; + double price = 100.50; + int musicId = 123; + int userId = 456; + String listProduct = "Product list"; + when(mockDate.getTimeNow()).thenReturn(null); // Mocking getTimeNow as null + // Act + String result = marketController.createProduct(description, price, musicId, userId, listProduct); + // Assert + assertEquals((String) "Produto Criado", result); + verify(mockProductRepository, times(1)).save(any(ProductModel.class)); + verify(mockLogRepository, times(1)).save(any(LogModel.class)); + } + @Test + @Tag("boundary") + public void handlesEmptyDescription() { + // Arrange + Mockito.doNothing().when(mockProductRepository).save(any(ProductModel.class)); + Mockito.doNothing().when(mockLogRepository).save(any(LogModel.class)); + String description = ""; // Empty string + double price = 100.50; + int musicId = 123; + int userId = 456; + String listProduct = "Product list"; + when(mockDate.getTimeNow()).thenReturn(null); // Mocking getTimeNow as null + // Act + String result = marketController.createProduct(description, price, musicId, userId, listProduct); + // Assert + assertEquals((String) "Produto Criado", result); + verify(mockProductRepository, times(1)).save(any(ProductModel.class)); + verify(mockLogRepository, times(1)).save(any(LogModel.class)); + } + @Test + @Tag("boundary") + public void handlesNegativePrice() { + // Arrange + Mockito.doNothing().when(mockProductRepository).save(any(ProductModel.class)); + Mockito.doNothing().when(mockLogRepository).save(any(LogModel.class)); + String description = "Negative Price Product"; + double price = -99.99; // Negative price + int musicId = 123; + int userId = 456; + String listProduct = "Product list"; + when(mockDate.getTimeNow()).thenReturn(null); // Mocking getTimeNow as null + // Act + String result = marketController.createProduct(description, price, musicId, userId, listProduct); + // Assert + assertEquals((String) "Produto Criado", result); + verify(mockProductRepository, times(1)).save(any(ProductModel.class)); + verify(mockLogRepository, times(1)).save(any(LogModel.class)); + } + @Test + @Tag("invalid") + public void handlesInvalidUserId() { + // Arrange + Mockito.doNothing().when(mockProductRepository).save(any(ProductModel.class)); + Mockito.doNothing().when(mockLogRepository).save(any(LogModel.class)); + String description = "Invalid User"; + double price = 50.0; + int musicId = 123; + int userId = -1; // Invalid userId + String listProduct = "Product list"; + when(mockDate.getTimeNow()).thenReturn(null); // Mocking getTimeNow as null + // Act + String result = marketController.createProduct(description, price, musicId, userId, listProduct); + // Assert + assertEquals((String) "Produto Criado", result); + verify(mockProductRepository, times(1)).save(any(ProductModel.class)); + verify(mockLogRepository, times(1)).save(any(LogModel.class)); + } + @Test + @Tag("integration") + public void logsEntryOnProductCreation() { + // Arrange + Mockito.doNothing().when(mockProductRepository).save(any(ProductModel.class)); + Mockito.doNothing().when(mockLogRepository).save(any(LogModel.class)); + String description = "Integration Log Test"; + double price = 45.99; + int musicId = 321; + int userId = 555; + String listProduct = "Integration list"; + when(mockDate.getTimeNow()).thenReturn(null); // Mocking getTimeNow as null + // Act + String result = marketController.createProduct(description, price, musicId, userId, listProduct); + // Assert + assertEquals((String) "Produto Criado", result); + verify(mockLogRepository, times(1)).save(any(LogModel.class)); + } + @Test + @Tag("invalid") + public void handlesNullDescription() { + // Arrange + Mockito.doNothing().when(mockProductRepository).save(any(ProductModel.class)); + Mockito.doNothing().when(mockLogRepository).save(any(LogModel.class)); + String description = null; // Null description + double price = 25.50; + int musicId = 789; + int userId = 123; + String listProduct = "Product list"; + when(mockDate.getTimeNow()).thenReturn(null); // Mocking getTimeNow as null + // Act + String result = marketController.createProduct(description, price, musicId, userId, listProduct); + // Assert + assertEquals((String) "Produto Criado", result); + verify(mockProductRepository, times(1)).save(any(ProductModel.class)); + verify(mockLogRepository, times(1)).save(any(LogModel.class)); + } + @Test + @Tag("invalid") + public void handlesInvalidMusicId() { + // Arrange + Mockito.doNothing().when(mockProductRepository).save(any(ProductModel.class)); + Mockito.doNothing().when(mockLogRepository).save(any(LogModel.class)); + String description = "Valid Product"; + double price = 100.50; + int musicId = -10; // Invalid musicId + int userId = 456; + String listProduct = "Product list"; + when(mockDate.getTimeNow()).thenReturn(null); // Mocking getTimeNow as null + // Act + String result = marketController.createProduct(description, price, musicId, userId, listProduct); + // Assert + assertEquals((String) "Produto Criado", result); + verify(mockProductRepository, times(1)).save(any(ProductModel.class)); + verify(mockLogRepository, times(1)).save(any(LogModel.class)); + } + @Test + @Tag("boundary") + public void handlesLargeProductList() { + // Arrange + Mockito.doNothing().when(mockProductRepository).save(any(ProductModel.class)); + Mockito.doNothing().when(mockLogRepository).save(any(LogModel.class)); + String description = "Large List Product"; + double price = 70.0; + int musicId = 123; + int userId = 789; + String listProduct = "a".repeat(10000); // Large input string for listProduct + when(mockDate.getTimeNow()).thenReturn(null); // Mocking getTimeNow as null + // Act + String result = marketController.createProduct(description, price, musicId, userId, listProduct); + // Assert + assertEquals((String) "Produto Criado", result); + verify(mockProductRepository, times(1)).save(any(ProductModel.class)); + verify(mockLogRepository, times(1)).save(any(LogModel.class)); + } +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/MarketControllerDeleteProductTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/MarketControllerDeleteProductTest.java new file mode 100644 index 0000000..8719077 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/MarketControllerDeleteProductTest.java @@ -0,0 +1,110 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=deleteProduct_3207cdc0ca +ROOST_METHOD_SIG_HASH=deleteProduct_2e765309a5 + +Scenario 1: Successful Deletion of an Existing Product by ID + +Details: + TestName: successfulDeletionOfExistingProduct + Description: This test verifies that the `deleteProduct` method successfully deletes a product with a valid existing ID within the ProductRepository. +Execution: + Arrange: Mock the `ProductRepository` to have a product with the given ID. + Act: Call the `deleteProduct` method with a valid product ID. + Assert: Verify that the `deleteById` method of the mocked `ProductRepository` was called with the correct ID. Also, check if the return value is the expected success message "Produto Deletado". +Validation: + This test ensures that the method correctly interacts with the repository to delete an existing product and confirms that the expected message is returned. This validates the core functionality of the method. + +*/ + +// ********RoostGPT******** + +package com.medeiros.SPRINGProject.Controllers; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.extension.ExtendWith; +import static org.junit.jupiter.api.Assertions.*; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.mockito.InjectMocks; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; +import com.medeiros.SPRINGProject.Models.ProductModelRepository; +import org.junit.jupiter.api.*; +import com.medeiros.SPRINGProject.Models.LogModel; +import com.medeiros.SPRINGProject.Models.LogRepository; +import com.medeiros.SPRINGProject.Models.ProductModel; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +@ExtendWith(MockitoExtension.class) +public class MarketControllerDeleteProductTest { + + @Mock + ProductModelRepository ProductRepository; + + @InjectMocks + MarketController marketController; + + @Test + @Tag("valid") + public void successfulDeletionOfExistingProduct() { + // Arrange + int validProductId = 123; // TODO: Replace with actual valid product ID if known + Mockito.doNothing().when(ProductRepository).deleteById(validProductId); + // Act + String result = marketController.deleteProduct(validProductId); + // Assert + Mockito.verify(ProductRepository).deleteById(validProductId); + assertEquals("Produto Deletado", result); + } + + @Test + @Tag("invalid") + public void deletionAttemptWithNonexistentProductId() { + // Arrange + int nonexistentProductId = 999; // TODO: Replace with actual invalid product ID in + // the repository + Mockito.doThrow(new IllegalArgumentException("Product not found")) + .when(ProductRepository) + .deleteById(nonexistentProductId); + // Act & Assert + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> { + marketController.deleteProduct(nonexistentProductId); + }); + assertEquals("Product not found", exception.getMessage()); + } + + @Test + @Tag("boundary") + public void deletionAttemptWithBoundaryProductId() { + // Arrange + int boundaryProductId = Integer.MAX_VALUE; // Testing with the maximum int value + Mockito.doNothing().when(ProductRepository).deleteById(boundaryProductId); + // Act + String result = marketController.deleteProduct(boundaryProductId); + // Assert + Mockito.verify(ProductRepository).deleteById(boundaryProductId); + assertEquals("Produto Deletado", result); + } + + @Test + @Tag("boundary") + public void deletionAttemptWithMinimumBoundaryProductId() { + // Arrange + int boundaryProductId = Integer.MIN_VALUE; // Testing with the minimum int value + Mockito.doThrow(new IllegalArgumentException("Invalid ID")) + .when(ProductRepository) + .deleteById(boundaryProductId); + // Act & Assert + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> { + marketController.deleteProduct(boundaryProductId); + }); + assertEquals("Invalid ID", exception.getMessage()); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/MarketControllerShowAllProductsTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/MarketControllerShowAllProductsTest.java new file mode 100644 index 0000000..6f97215 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/MarketControllerShowAllProductsTest.java @@ -0,0 +1,103 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=showAllProducts_e3f486dbbd +ROOST_METHOD_SIG_HASH=showAllProducts_f2f96749da + + +Scenario [1]: Valid Retrieval of All Products + +Details: + TestName: retrieveAllProductsSuccessfully + Description: Verify that the `showAllProducts` method retrieves and returns all products stored in the `ProductRepository`. + +Execution: + Arrange: Ensure that `ProductRepository` contains a set of `ProductModel` objects. Mock the `findAll` method of `ProductRepository` to return predefined sample data. + Act: Call the `showAllProducts` method. + Assert: Validate the returned collection contains the correct number of products, and each product matches the predefined data. + +Validation: + Clarify that the expected outcome ensures the functionality of retrieving all product entries universally. Highlight that this scenario verifies the core purpose of the `showAllProducts` method. + +*/ + +// ********RoostGPT******** + +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.ProductModel; +import com.medeiros.SPRINGProject.Models.ProductModelRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.mockito.Mock; +import org.mockito.InjectMocks; +import org.mockito.MockitoAnnotations; +import java.util.Arrays; +import java.util.Collections; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.*; +import org.junit.jupiter.api.*; +import com.medeiros.SPRINGProject.Models.LogModel; +import com.medeiros.SPRINGProject.Models.LogRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +public class MarketControllerShowAllProductsTest { + + @Mock + private ProductModelRepository ProductRepository; + + @InjectMocks + private MarketController marketController; + + @BeforeEach + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + @Tag("valid") + public void retrieveAllProductsSuccessfully() { + // Arrange + ProductModel product1 = new ProductModel("Description 1", 10.0, 101, 1, "Product List 1"); + ProductModel product2 = new ProductModel("Description 2", 20.0, 102, 2, "Product List 2"); + when(ProductRepository.findAll()).thenReturn(Arrays.asList(product1, product2)); + // Act + Iterable result = marketController.showAllProducts(); + // Assert + assertEquals(2, ((java.util.List) result).size()); + assertEquals(product1, ((java.util.List) result).get(0)); + assertEquals(product2, ((java.util.List) result).get(1)); + verify(ProductRepository, times(1)).findAll(); + } + + @Test + @Tag("valid") + public void retrieveNoProductsIfRepositoryEmpty() { + // Arrange + when(ProductRepository.findAll()).thenReturn(Collections.emptyList()); + // Act + Iterable result = marketController.showAllProducts(); + // Assert + assertEquals(0, ((java.util.List) result).size()); + verify(ProductRepository, times(1)).findAll(); + } + + @Test + @Tag("boundary") + public void repositoryReturnsOneProduct() { + // Arrange + ProductModel product = new ProductModel("Description Single", 5.0, 200, 3, "Product List Single"); + when(ProductRepository.findAll()).thenReturn(Collections.singletonList(product)); + // Act + Iterable result = marketController.showAllProducts(); + // Assert + assertEquals(1, ((java.util.List) result).size()); + assertEquals(product, ((java.util.List) result).get(0)); + verify(ProductRepository, times(1)).findAll(); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerCreateMusicTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerCreateMusicTest.java new file mode 100644 index 0000000..c32ff1e --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerCreateMusicTest.java @@ -0,0 +1,302 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=createMusic_9c5dad48b0 +ROOST_METHOD_SIG_HASH=createMusic_4606fc0d94 + + +Scenario 1: Successfully Creating a Music Entry + +Details: + TestName: successfullyCreateMusicWithValidInputs + Description: This test will verify if the method `createMusic` correctly saves a new music entry with valid input values for MusicDescription, MusicName, Music, and Userid. It ensures that the new music entry is persisted in the MusicRepo repository. + +Execution: + Arrange: Create mock instances of MusicRepository and MusicModel. Prepare sample valid inputs for MusicDescription, MusicName, Music, and Userid. Ensure that the MusicRepo mock allows saving MusicModel objects. + Act: Call the `createMusic` method with valid parameters, such as a non-empty MusicDescription, MusicName, Music, and a valid Userid. + Assert: Validate that the returned string matches the expected result of "Operação Feita". +Validation: + This test verifies that the correct inputs result in the successful creation and saving of a music entry. It ensures the repository is properly invoked to persist the data, validating system functionality under expected conditions. + +--- + +Scenario 2: Failing to Create Music Due to Missing MusicDescription + +Details: + TestName: failToCreateMusicWithEmptyMusicDescription + Description: This test checks the behavior of `createMusic` when the MusicDescription parameter is empty. It ensures the method handles missing inputs gracefully. + +Execution: + Arrange: Create mock instances of MusicRepository and MusicModel. Prepare sample inputs with MusicDescription set as an empty string while providing valid values for MusicName, Music, and Userid. + Act: Call the `createMusic` method with the invalid MusicDescription parameter. + Assert: Verify that the repository is not invoked to save the object and that an appropriate exception is thrown or the output is unexpected. +Validation: + This test highlights an edge case where the MusicDescription parameter is invalid. It validates whether the method properly handles input errors or fails as expected under such conditions. + +--- + +Scenario 3: Failing to Create Music Due to Missing MusicName + +Details: + TestName: failToCreateMusicWithEmptyMusicName + Description: This test checks the behavior of `createMusic` when the MusicName parameter is empty. It ensures the method handles missing inputs gracefully. + +Execution: + Arrange: Create mock instances of MusicRepository and MusicModel. Prepare sample inputs with MusicName set as an empty string while providing valid values for MusicDescription, Music, and Userid. + Act: Call the `createMusic` method with the invalid MusicName parameter. + Assert: Verify that the repository is not invoked to save the object and that an appropriate exception is thrown or the output is unexpected. +Validation: + This test identifies missing or invalid MusicName input scenarios, helping validate robustness in handling user input errors. + +--- + +Scenario 4: Failing to Create Music Due to Invalid Userid + +Details: + TestName: failToCreateMusicWithInvalidUserid + Description: This test checks the behavior of `createMusic` when the Userid parameter is invalid (e.g., negative numbers or zero). It ensures the method does not produce a valid result and handles such error gracefully. + +Execution: + Arrange: Create mock instances of MusicRepository and MusicModel. Prepare sample inputs with an invalid Userid value, such as -1, while providing valid values for MusicDescription, MusicName, and Music. + Act: Call the `createMusic` method with the invalid Userid parameter. + Assert: Validate that the output does not match the expected result "Operação Feita" and that the repository is not invoked to save the object. +Validation: + This test confirms error handling when invalid IDs are provided and ensures application security by rejecting inappropriate or flawed identifiers. + +--- + +Scenario 5: Confirming Music Entry is Saved in Repository + +Details: + TestName: confirmMusicIsSavedInRepository + Description: This test verifies that the `createMusic` method successfully saves the created `MusicModel` object in the MusicRepo repository and the repository interactions occur as expected. + +Execution: + Arrange: Mock the MusicRepository to track save() interactions. Prepare valid input data including MusicDescription, MusicName, Music, and Userid. + Act: Invoke `createMusic` with valid parameters. + Assert: Verify that the repository's save() method was called exactly once with the newly created MusicModel instance. +Validation: + This test ensures that the repository's save() method is appropriately integrated and confirms persistence of data, verifying interactions within the application's data layer. + +--- + +Scenario 6: Handling Null Inputs for All Parameters + +Details: + TestName: handleNullInputsForCreateMusicMethod + Description: This test checks the behavior of `createMusic` method when all parameters (MusicDescription, MusicName, Music, and Userid) are passed as null or invalid values. + +Execution: + Arrange: Mock the MusicRepository and MusicModel. Pass null values for all parameters as test data. + Act: Call `createMusic` with null inputs. + Assert: Verify that the method throws an appropriate exception or results in an error due to null values. +Validation: + This test checks for the proper handling of null or undefined inputs, validating robustness against potential runtime issues. + +--- + +Scenario 7: Confirming Return Message is as Expected + +Details: + TestName: confirmReturnMessageFromCreateMusicMethod + Description: This test validates that a successful invocation of the `createMusic` method results in the expected return message "Operação Feita". + +Execution: + Arrange: Prepare valid test inputs including MusicDescription, MusicName, Music, and Userid. Mock the MusicRepository to successfully save data. + Act: Invoke `createMusic` with valid parameters. + Assert: Validate that the returned message equals "Operação Feita". +Validation: + This ensures the user receives proper feedback confirming the operation's success, verifying usability and responsiveness of the feature. + +--- + +Scenario 8: Validating UserID Boundaries + +Details: + TestName: validateBoundaryValuesOfUseridInCreateMusic + Description: This test examines the behavior when boundary values are provided for the Userid parameter such as 0 and Integer.MAX_VALUE, checking for correctness. + +Execution: + Arrange: Prepare inputs with Userid values like 0 and Integer.MAX_VALUE alongside valid values for other parameters. Mock necessary dependencies. + Act: Invoke `createMusic` with boundary values for Userid. + Assert: Compare the outcome with expected behaviors such as successful persistence for valid boundaries or failure for invalid ones. +Validation: + This validates that Userid remains within acceptable boundaries, ensuring proper functionality and input validation in edge cases. + +*/ + +// ********RoostGPT******** + +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.MusicModel; +import com.medeiros.SPRINGProject.Models.MusicRepository; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.PathVariable; +import static org.mockito.Mockito.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.*; +import com.medeiros.SPRINGProject.Models.LogModel; +import com.medeiros.SPRINGProject.Models.LogRepository; +import org.springframework.web.bind.annotation.*; + +class MusicControllerCreateMusicTest { + + @Autowired + MusicRepository musicRepoMock; + + // Scenario 1: Successfully Creating a Music Entry + @Test + @Tag("valid") + public void successfullyCreateMusicWithValidInputs() { + // Arrange + musicRepoMock = Mockito.mock(MusicRepository.class); + MusicController controller = new MusicController(); + controller.MusicRepo = musicRepoMock; + String MusicDescription = "A wonderful song."; + String MusicName = "SongName"; + String Music = "MusicContent"; + int Userid = 1; + MusicModel expectedMusic = new MusicModel(Userid, MusicName, Music, MusicDescription); + // Act + String result = controller.createMusic(MusicDescription, MusicName, Music, Userid); + // Assert + assertEquals("Operação Feita", result); + verify(musicRepoMock, times(1)).save(expectedMusic); + } + + // Scenario 2: Failing to Create Music Due to Missing MusicDescription + @Test + @Tag("invalid") + public void failToCreateMusicWithEmptyMusicDescription() { + // Arrange + musicRepoMock = Mockito.mock(MusicRepository.class); + MusicController controller = new MusicController(); + controller.MusicRepo = musicRepoMock; + String MusicDescription = ""; // Invalid MusicDescription + String MusicName = "SongName"; + String Music = "MusicContent"; + int Userid = 1; + // Act and Assert + assertThrows(IllegalArgumentException.class, () -> { + controller.createMusic(MusicDescription, MusicName, Music, Userid); + }); + verify(musicRepoMock, never()).save(any(MusicModel.class)); + } + + // Scenario 3: Failing to Create Music Due to Missing MusicName + @Test + @Tag("invalid") + public void failToCreateMusicWithEmptyMusicName() { + // Arrange + musicRepoMock = Mockito.mock(MusicRepository.class); + MusicController controller = new MusicController(); + controller.MusicRepo = musicRepoMock; + String MusicDescription = "A wonderful song."; + String MusicName = ""; // Invalid MusicName + String Music = "MusicContent"; + int Userid = 1; + // Act and Assert + assertThrows(IllegalArgumentException.class, () -> { + controller.createMusic(MusicDescription, MusicName, Music, Userid); + }); + verify(musicRepoMock, never()).save(any(MusicModel.class)); + } + + // Scenario 4: Failing to Create Music Due to Invalid Userid + @Test + @Tag("invalid") + public void failToCreateMusicWithInvalidUserid() { + // Arrange + musicRepoMock = Mockito.mock(MusicRepository.class); + MusicController controller = new MusicController(); + controller.MusicRepo = musicRepoMock; + String MusicDescription = "A wonderful song."; + String MusicName = "SongName"; + String Music = "MusicContent"; + int Userid = -1; // Invalid Userid + // Act and Assert + assertThrows(IllegalArgumentException.class, () -> { + controller.createMusic(MusicDescription, MusicName, Music, Userid); + }); + verify(musicRepoMock, never()).save(any(MusicModel.class)); + } + + // Scenario 5: Confirming Music Entry is Saved in Repository + @Test + @Tag("integration") + public void confirmMusicIsSavedInRepository() { + // Arrange + musicRepoMock = Mockito.mock(MusicRepository.class); + MusicController controller = new MusicController(); + controller.MusicRepo = musicRepoMock; + String MusicDescription = "A wonderful song."; + String MusicName = "SongName"; + String Music = "MusicContent"; + int Userid = 1; + MusicModel expectedMusic = new MusicModel(Userid, MusicName, Music, MusicDescription); + // Act + controller.createMusic(MusicDescription, MusicName, Music, Userid); + // Assert + verify(musicRepoMock, times(1)).save(expectedMusic); + } + + // Scenario 6: Handling Null Inputs for All Parameters + @Test + @Tag("invalid") + public void handleNullInputsForCreateMusicMethod() { + // Arrange + musicRepoMock = Mockito.mock(MusicRepository.class); + MusicController controller = new MusicController(); + controller.MusicRepo = musicRepoMock; + // Act and Assert + assertThrows(NullPointerException.class, () -> { + controller.createMusic(null, null, null, 0); + }); + verify(musicRepoMock, never()).save(any(MusicModel.class)); + } + + // Scenario 7: Confirming Return Message is as Expected + @Test + @Tag("valid") + public void confirmReturnMessageFromCreateMusicMethod() { + // Arrange + musicRepoMock = Mockito.mock(MusicRepository.class); + MusicController controller = new MusicController(); + controller.MusicRepo = musicRepoMock; + String MusicDescription = "A wonderful song."; + String MusicName = "SongName"; + String Music = "MusicContent"; + int Userid = 1; + // Act + String result = controller.createMusic(MusicDescription, MusicName, Music, Userid); + // Assert + assertEquals("Operação Feita", result); + } + + // Scenario 8: Validating UserID Boundaries + @Test + @Tag("boundary") + public void validateBoundaryValuesOfUseridInCreateMusic() { + // Arrange + musicRepoMock = Mockito.mock(MusicRepository.class); + MusicController controller = new MusicController(); + controller.MusicRepo = musicRepoMock; + String MusicDescription = "A wonderful song."; + String MusicName = "SongName"; + String Music = "MusicContent"; + // Act + String zeroResult = controller.createMusic(MusicDescription, MusicName, Music, 0); + String maxValueResult = controller.createMusic(MusicDescription, MusicName, Music, Integer.MAX_VALUE); + // Assert + assertEquals("Operação Feita", zeroResult); + assertEquals("Operação Feita", maxValueResult); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerDeleteMusicTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerDeleteMusicTest.java new file mode 100644 index 0000000..c8924b3 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerDeleteMusicTest.java @@ -0,0 +1,277 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=deleteMusic_e3b3d353e4 +ROOST_METHOD_SIG_HASH=deleteMusic_3c6d20ad7a + +Scenario 1: Successfully delete a music record by providing a valid ID + +Details: + TestName: deleteMusicSuccessfully + Description: Validates if a music record is successfully deleted when providing a valid music ID. Ensures the method correctly calls the MusicRepo.deleteById method and returns the expected success message. + +Execution: + Arrange: Mock the MusicRepository instance to simulate the deletion of a music record by its ID. Set up the test environment to provide a valid music ID. + Act: Call the deleteMusic method with a valid ID. + Assert: Verify that MusicRepo.deleteById was called with the correct ID and that the returned value matches the expected success message "Deletado". + +Validation: + Ensure the method performs the expected deletion process and the return message confirms the successful operation. Verify the integration between MusicRepo and the deleteMusic method to validate correct repository usage. + +--- + +Scenario 2: Attempt to delete a non-existent music record + +Details: + TestName: deleteNonExistentMusic + Description: Checks the behavior of the deleteMusic method when attempting to delete a record that does not exist in the database. + +Execution: + Arrange: Mock the MusicRepository deleteById method to simulate no record existing for the given ID. Provide an ID that is not present in the database. + Act: Call the deleteMusic method with the non-existent ID. + Assert: Confirm that MusicRepo.deleteById was called with the given ID and no exception was thrown regarding the missing record. Verify the returned message is still "Deletado". + +Validation: + Verifies that the deleteMusic method handles cases where the given ID does not correspond to a real record gracefully without failing or throwing unwanted exceptions. This ensures robustness in the application. + +--- + +Scenario 3: Pass a negative ID for deletion + +Details: + TestName: deleteMusicWithNegativeId + Description: Tests the behavior when a negative ID is passed to the deleteMusic method, ensuring proper error handling or expected behavior. + +Execution: + Arrange: Provide a negative ID as input and mock the MusicRepository to handle such IDs. + Act: Invoke the deleteMusic method using the negative ID as input. + Assert: Verify the deleteById method was not called or handled the negative ID as expected. Check if the method returned "Deletado" or if additional validations could be expected. + +Validation: + Ensure the method's robustness when handling invalid inputs such as negative IDs, confirming it does not allow unintended behavior from invalid input. + +--- + +Scenario 4: Simulate a failure in MusicRepo during music deletion + +Details: + TestName: deleteMusicWithRepositoryFailure + Description: Simulates an internal failure in the MusicRepository during music deletion to verify proper error handling. + +Execution: + Arrange: Mock the MusicRepository deleteById method to throw an exception during execution. Provide a valid ID for deletion. + Act: Call the deleteMusic method with a valid ID and simulate the failure. + Assert: Confirm that the exception was thrown and handled gracefully by the application (if applicable). Verify the method's behavior under failure conditions. + +Validation: + Assesses the application's ability to manage unexpected system errors gracefully, ensuring robustness during repository failures or other unforeseen errors. + +--- + +Scenario 5: Delete music with ID provided as zero + +Details: + TestName: deleteMusicWithZeroId + Description: Tests the behavior of the deleteMusic method when the ID is provided as zero, which may be considered invalid or edge-case input. + +Execution: + Arrange: Provide zero as the ID input to the deleteMusic method and mock the MusicRepository deleteById behavior accordingly. + Act: Call the deleteMusic method with ID = 0. + Assert: Verify how MusicRepo.deleteById handles the zero ID scenario and confirm that the returned message is "Deletado". + +Validation: + Ensures that the method correctly handles edge-case values like zero for music ID without causing unexpected behavior. + +--- + +Scenario 6: Verify repository call with valid input ID + +Details: + TestName: verifyRepositoryCallWithValidId + Description: Ensures that the deleteMusic method properly interacts with MusicRepo by calling the deleteById method with the correct ID value. + +Execution: + Arrange: Mock the MusicRepository instance and set up a valid ID to track the deleteById call. + Act: Invoke the deleteMusic method with the valid ID. + Assert: Use Mockito or equivalent tools to confirm the deleteById method was called exactly once with the correct ID. + +Validation: + Validates proper integration between MusicController and MusicRepository, ensuring the repository is invoked correctly when deleting a music record. + +--- + +Scenario 7: Check return value of deleteMusic method matches expected success message + +Details: + TestName: validateReturnMessageOnDeletion + Description: Ensures that the deleteMusic method returns the expected success message "Deletado" regardless of the input ID. + +Execution: + Arrange: Set up the MusicRepository to accept any input ID without throwing an exception and mock its behavior. + Act: Call the deleteMusic method with a valid ID. + Assert: Verify that the return value of the method matches "Deletado". + +Validation: + Confirms consistency in the method's return message, validating the user-facing response for successful operations. + +--- + +Scenario 8: Delete music without mocking repository behavior + +Details: + TestName: deleteMusicWithoutMockingRepo + Description: Validates the end-to-end functionality of the deleteMusic method without mocking MusicRepository, ensuring a real database test scenario. + +Execution: + Arrange: Use a real instance of MusicRepository (or an equivalent in-memory database) with valid data inserted beforehand. Provide a valid ID for deletion. + Act: Invoke the deleteMusic method with a real ID. + Assert: Check if the record is removed from the database and the return message is "Deletado". + +Validation: + Ensures the correctness of the deleteMusic method in a realistic environment, confirming operational behavior without mocking dependencies. + +--- + +Scenario 9: Handle null pointer exception within MusicRepo + +Details: + TestName: deleteMusicWithNullRepository + Description: Simulates a scenario where MusicRepo might not be properly initialized (null) and tests for handling a NullPointerException. + +Execution: + Arrange: Provide a valid ID and simulate MusicRepo being null by not wiring it in the test environment. + Act: Invoke the deleteMusic method and catch any exception (if thrown). + Assert: Verify the application handles the null repository gracefully without crashing. + +Validation: + Ensures that the deleteMusic method accounts for errors resulting from uninitialized dependencies such as MusicRepo, confirming safe application behavior during system faults. + +*/ + +// ********RoostGPT******** + +package com.medeiros.SPRINGProject.Controllers; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.mock.mockito.MockBean; +import com.medeiros.SPRINGProject.Models.MusicRepository; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; +import org.junit.jupiter.api.*; +import com.medeiros.SPRINGProject.Models.LogModel; +import com.medeiros.SPRINGProject.Models.LogRepository; +import com.medeiros.SPRINGProject.Models.MusicModel; +import org.springframework.web.bind.annotation.*; + +@SpringBootTest +public class MusicControllerDeleteMusicTest { + + @MockBean + private MusicRepository MusicRepo; + + @Autowired + private MusicController MusicController; + + @BeforeEach + public void setUp() { + MusicController = new MusicController(); + MusicController.MusicRepo = MusicRepo; + } + + @Tag("valid") + @Test + public void testDeleteMusicSuccessfully() { + int validId = 1; // TODO: Adjust the valid ID if needed + doNothing().when(MusicRepo).deleteById(validId); + String result = MusicController.deleteMusic(validId); + verify(MusicRepo, times(1)).deleteById(validId); + assertEquals("Deletado", result, "Expected success message 'Deletado'"); + } + + @Tag("invalid") + @Test + public void testDeleteNonExistentMusic() { + int invalidId = 9999; // TODO: This ID does not exist in the database + doNothing().when(MusicRepo).deleteById(invalidId); + String result = MusicController.deleteMusic(invalidId); + verify(MusicRepo, times(1)).deleteById(invalidId); + assertEquals("Deletado", result, "Even for non-existent music, the method should return 'Deletado'"); + } + + @Tag("invalid") + @Test + public void testDeleteMusicWithNegativeId() { + int negativeId = -1; // Negative ID is invalid + doNothing().when(MusicRepo).deleteById(negativeId); + String result = MusicController.deleteMusic(negativeId); + verify(MusicRepo, times(1)).deleteById(negativeId); + assertEquals("Deletado", result, "Expected 'Deletado' even for negative ID"); + } + + @Tag("invalid") + @Test + public void testDeleteMusicWithZeroId() { + int zeroId = 0; // Edge case ID + doNothing().when(MusicRepo).deleteById(zeroId); + String result = MusicController.deleteMusic(zeroId); + verify(MusicRepo, times(1)).deleteById(zeroId); + assertEquals("Deletado", result, "Expected 'Deletado' for zero ID"); + } + + @Tag("boundary") + @Test + public void testVerifyRepositoryCallWithValidId() { + int validId = 5; // TODO: Adjust the valid ID if needed + doNothing().when(MusicRepo).deleteById(validId); + MusicController.deleteMusic(validId); + verify(MusicRepo, times(1)).deleteById(validId); + } + + @Tag("integration") + @Test + public void testValidateReturnMessageOnDeletion() { + int validId = 10; // TODO: Adjust the valid ID if necessary + doNothing().when(MusicRepo).deleteById(validId); + String result = MusicController.deleteMusic(validId); + assertEquals("Deletado", result, "Expected the return message 'Deletado'"); + } + + @Tag("valid") + @Test + public void testDeleteMusicWithoutMockingRepo() { + MusicController MusicControllerReal = new MusicController(); + MusicControllerReal.MusicRepo = MusicRepo; // TODO: Replace MusicRepo with a real + // repository instance or equivalent + // in-memory database structure + + int realId = 3; // TODO: Use an actual ID pre-inserted in the database + doNothing().when(MusicRepo).deleteById(realId); + String result = MusicControllerReal.deleteMusic(realId); + assertEquals("Deletado", result, "Expected 'Deletado' in real scenario"); + } + + @Tag("invalid") + @Test + public void testDeleteMusicWithRepositoryFailure() { + int validId = 7; // TODO: Adjust the valid ID if needed + doThrow(RuntimeException.class).when(MusicRepo).deleteById(validId); + assertThrows(RuntimeException.class, () -> MusicController.deleteMusic(validId)); + } + + @Tag("invalid") + @Test + public void testDeleteMusicWithNullRepository() { + MusicController MusicControllerNullRepo = new MusicController(); + MusicControllerNullRepo.MusicRepo = null; + int validId = 8; // TODO: Adjust the ID if needed + assertThrows(NullPointerException.class, () -> MusicControllerNullRepo.deleteMusic(validId)); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerFindMusicByTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerFindMusicByTest.java new file mode 100644 index 0000000..8c552d0 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerFindMusicByTest.java @@ -0,0 +1,130 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=findMusicBy_5035b89150 +ROOST_METHOD_SIG_HASH=findMusicBy_179b3d7d86 + + +Scenario [1]: Validate Successful Retrieval of Music Record + +Details: + TestName: validateSuccessfulMusicRetrieval + Description: This test verifies that the `findMusicBy` method correctly retrieves a music record from the `MusicRepo` when an existing ID is provided. + +Execution: + Arrange: + - Mock the `MusicRepository` to return a predefined `MusicModel` instance with the given ID. + - Set up the `MusicRepo` field in the `MusicController` with the mocked repository. + Act: + - Call the `findMusicBy` method with a valid ID. + Assert: + - Validate that the returned `MusicModel` object matches the mocked data. + +Validation: + The assertion ensures that the method successfully retrieves the music record when the ID exists. This test confirms the core functionality of the method in fetching music data from the repository. + +*/ + +// ********RoostGPT******** + +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.MusicModel; +import com.medeiros.SPRINGProject.Models.MusicRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.*; +import org.junit.jupiter.api.*; +import com.medeiros.SPRINGProject.Models.LogModel; +import com.medeiros.SPRINGProject.Models.LogRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +class MusicControllerFindMusicByTest { + + @Mock + private MusicRepository MusicRepo; + + @InjectMocks + private MusicController musicController; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + } + + @Test + @Tag("valid") + public void validateSuccessfulMusicRetrieval() { + // Arrange + int validId = 1; // TODO: Modify with a real ID when necessary + MusicModel mockMusic = new MusicModel(validId, "Test Music Name", "Test Music File", "Test Description"); + when(MusicRepo.findById(validId)).thenReturn(mockMusic); + // Act + MusicModel result = musicController.findMusicBy(validId); + // Assert + assertEquals(mockMusic, result, "Expected and Actual MusicModel object should be the same for a valid ID."); + verify(MusicRepo, times(1)).findById(validId); + } + + @Test + @Tag("invalid") + public void validateMusicRetrievalWithNonExistentId() { + // Arrange + int invalidId = 999; // TODO: Update the invalid ID as required + when(MusicRepo.findById(invalidId)).thenReturn(null); + // Act + MusicModel result = musicController.findMusicBy(invalidId); + // Assert + assertEquals(null, result, "Expected result should be null for a non-existent ID."); + verify(MusicRepo, times(1)).findById(invalidId); + } + + @Test + @Tag("boundary") + public void validateMusicRetrievalWithBoundaryId() { + // Arrange + int boundaryId = Integer.MAX_VALUE; + when(MusicRepo.findById(boundaryId)).thenReturn(null); // Assuming no record + // exists for this + // boundary test case + // Act + MusicModel result = musicController.findMusicBy(boundaryId); + // Assert + assertEquals(null, result, "Expected result should be null for a boundary ID."); + verify(MusicRepo, times(1)).findById(boundaryId); + } + + @Test + @Tag("invalid") + public void validateMusicRetrievalWithNegativeId() { + // Arrange + int negativeId = -1; + when(MusicRepo.findById(negativeId)).thenReturn(null); + // Act + MusicModel result = musicController.findMusicBy(negativeId); + // Assert + assertEquals(null, result, "Expected result should be null for a negative ID."); + verify(MusicRepo, times(1)).findById(negativeId); + } + + @Test + @Tag("integration") + public void validateInteractionWithRepository() { + // Arrange + int interactionId = 5; // TODO: Modify the ID if necessary + when(MusicRepo.findById(interactionId)).thenReturn(null); + // Act + musicController.findMusicBy(interactionId); + // Assert + verify(MusicRepo, times(1)).findById(interactionId); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerUpdateMusicByIdTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerUpdateMusicByIdTest.java new file mode 100644 index 0000000..ea886db --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/MusicControllerUpdateMusicByIdTest.java @@ -0,0 +1,81 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=updateMusicById_aa137517f5 +ROOST_METHOD_SIG_HASH=updateMusicById_857ee29aaf + +Scenario 1: Successfully update an existing music record with valid inputs. + +Details: + TestName: successfullyUpdateMusicWithValidInputs + Description: Validate that the method updates the `MusicName`, `MusicDescription`, and `Music` fields for an existing record in the `MusicRepo` when provided valid inputs. + +Execution: + Arrange: + - Create a mock `MusicRepository` with an existing record for a specific `id`. + - Prepare parameters with valid values for `id`, `MusicName`, `MusicDescription`, and `Music`. + Act: + - Invoke the `updateMusicById` method using the prepared parameters. + Assert: + - Verify that the `MusicRepo.save(musicToUpdate)` method was called with updated values. + - Assert the returned value equals `"Música Alterada!"`. + +Validation: + This test ensures that the method successfully updates a record in the repository when all inputs are valid. It verifies integration with the repository’s `save` method to persist changes. + +*/ + +// ********RoostGPT******** + +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.LogModel; +import com.medeiros.SPRINGProject.Models.LogRepository; +import com.medeiros.SPRINGProject.Models.MusicModel; +import com.medeiros.SPRINGProject.Models.MusicRepository; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import static org.mockito.Mockito.*; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +class MusicControllerUpdateMusicByIdTest { + + @Mock + private MusicRepository MusicRepo; + + @InjectMocks + private MusicController MusicController; + + public MusicControllerUpdateMusicByIdTest() { + MockitoAnnotations.openMocks(this); + } + + @Test + @Tag("valid") + public void successfullyUpdateMusicWithValidInputs() { + // Arrange + int validId = 1; // TODO: Adjust the id for your known test data + String validMusicName = "New Music Name"; + String validMusicDescription = "New Description"; + String validMusic = "New Music File"; + MusicModel existingMusic = mock(MusicModel.class); + when(MusicRepo.findById(validId)).thenReturn(existingMusic); + // Act + String result = MusicController.updateMusicById(validId, validMusicName, validMusicDescription, validMusic); + // Assert + verify(existingMusic, times(1)).setMusic(validMusic); + verify(existingMusic, times(1)).setMusicDescription(validMusicDescription); + verify(existingMusic, times(1)).setMusicName(validMusicName); + verify(MusicRepo, times(1)).save(existingMusic); + assertEquals("Música Alterada!", result, "Expected the success message 'Música Alterada!'"); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/PagesControllerMinhaPaginaTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/PagesControllerMinhaPaginaTest.java new file mode 100644 index 0000000..9afc31e --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/PagesControllerMinhaPaginaTest.java @@ -0,0 +1,243 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=minhaPagina_faf3e427f2 +ROOST_METHOD_SIG_HASH=minhaPagina_b5557d79c5 + + +Scenario 1: Verify that the view name is correctly initialized as "minhaPagina". + +Details: + TestName: verifyViewNameIsCorrect + Description: This test ensures that the `minhaPagina` method initializes the `ModelAndView` object with the correct view name, which is "minhaPagina". +Execution: + Arrange: Prepare the `PagesController` instance. + Act: Call the `minhaPagina` method. + Assert: Verify using assertions that the view name of the returned `ModelAndView` object is "minhaPagina". +Validation: + This ensures that the correct view template is set for the page, which is essential for rendering the proper UI. + +--- + +Scenario 2: Verify that the "titulo" attribute is set to "Minha Página". + +Details: + TestName: verifyTituloAttribute + Description: This test verifies that the "titulo" attribute is added to the `ModelAndView` object with the expected value of "Minha Página". +Execution: + Arrange: Prepare the `PagesController` instance. + Act: Call the `minhaPagina` method. + Assert: Check that the "titulo" attribute is set to "Minha Página" in the returned `ModelAndView` object. +Validation: + This ensures that the page title is initialized correctly, which is displayed to the user as an important UI element. + +--- + +Scenario 3: Verify that the "mensagem" attribute is set to "Bem-vindo à minha página!". + +Details: + TestName: verifyMensagemAttribute + Description: This test checks that the `minhaPagina` method adds the "mensagem" attribute with the correct value: "Bem-vindo à minha página!". +Execution: + Arrange: Prepare the `PagesController` instance. + Act: Call the `minhaPagina` method. + Assert: Use assertions to verify that the "mensagem" attribute in the returned `ModelAndView` is correctly set to "Bem-vindo à minha página!". +Validation: + This confirms that the welcome message is correctly initialized and will display as expected to the user. + +--- + +Scenario 4: Verify that the `ModelAndView` object contains only the expected attributes. + +Details: + TestName: verifyAttributesCount + Description: This test ensures that the `ModelAndView` object returned from the `minhaPagina` method contains only the expected attributes: "titulo" and "mensagem". +Execution: + Arrange: Prepare the `PagesController` instance. + Act: Call the `minhaPagina` method. + Assert: Verify the total number of attributes added to the `ModelAndView` object is two and they match the expected ones (i.e., "titulo" and "mensagem"). +Validation: + By verifying the exact count and keys of attributes, the test ensures the method contains no unexpected data and adheres to the contract. + +--- + +Scenario 5: Verify that the `minhaPagina` method does not rely on instance fields. + +Details: + TestName: verifyMethodIndependence + Description: This test validates that the `minhaPagina` does not depend on any class instance field (e.g., `Log` and `Date`) and behaves consistently regardless of their state. +Execution: + Arrange: Create an instance of the `PagesController` class with default values for its fields (`Log = null`, `Date = new LogModel()`). + Act: Call the `minhaPagina` method. + Assert: Verify that the returned `ModelAndView` is always the same when called multiple times and does not interact with instance fields. +Validation: + This ensures that the method adheres to the principle of being self-contained and does not produce side effects or unexpected outputs due to instance fields. + +--- + +Scenario 6: Verify behavior when the method is called multiple times. + +Details: + TestName: verifyConsistentBehaviorOnMultipleCalls + Description: This test ensures that calling the `minhaPagina` method multiple times produces identical results, confirming its idempotency. +Execution: + Arrange: Prepare the `PagesController` instance. + Act: Call the `minhaPagina` method multiple times sequentially and store the results. + Assert: Compare the results of multiple calls to ensure they are identical in all respects (view name and attributes). +Validation: + This test confirms consistency and helps identify any internal state or dependency that could produce inconsistent results over multiple calls. + +--- + +Scenario 7: Verify the method when `Log` is intentionally set with a valid object. + +Details: + TestName: verifyBehaviorWithValidLog + Description: This test verifies the behavior of `minhaPagina` when the `Log` field is explicitly set to a non-null `LogRepository` object, even though it is not directly used in the method. +Execution: + Arrange: Create an instance of `PagesController` and set its `Log` field to a valid `LogRepository` mock or test object. + Act: Call the `minhaPagina` method. + Assert: Verify the returned `ModelAndView` object matches the expected output (view and attributes are consistent). +Validation: + This ensures that adding a valid dependency to the class does not interfere with the functionality of the `minhaPagina` method. + +--- + +Scenario 8: Verify method when `Log` is null. + +Details: + TestName: verifyBehaviorWithNullLog + Description: This test validates the behavior of the `minhaPagina` method when the `Log` field is null, ensuring it is not affected by the state of the controller instance. +Execution: + Arrange: Create a new instance of `PagesController` with default null value for the `Log` field. + Act: Call the `minhaPagina` method. + Assert: Verify that the returned `ModelAndView` object matches the expected output irrespective of `Log` being null. +Validation: + This confirms the independence of the method from a null or uninitialized `Log` field and ensures robust functionality. + +--- + +Scenario 9: Validate the response when the `Date` field is set to `null`. + +Details: + TestName: validateResponseWhenDateIsNull + Description: This test ensures that the `minhaPagina` method maintains its behavior when the `Date` field (of type `LogModel`) is explicitly set to `null` in the class. +Execution: + Arrange: Create a `PagesController` instance with its `Date` field explicitly set to `null`. + Act: Invoke the `minhaPagina` method. + Assert: Check that the returned `ModelAndView` object has the correct view name and attributes regardless of the `Date` field's null state. +Validation: + The method should operate independently of the `Date` field, if not accessed or used internally. This test ensures adherence to that behavior. + +*/ + +// ********RoostGPT******** + +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.LogModel; +import com.medeiros.SPRINGProject.Models.LogRepository; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.mockito.Mock; +import org.springframework.web.servlet.ModelAndView; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RestController; + +class PagesControllerMinhaPaginaTest { + + private final PagesController pagesController = new PagesController(); + + @Mock + private LogRepository mockLogRepository; + + @Test + @Tag("valid") + public void verifyViewNameIsCorrect() { + ModelAndView result = pagesController.minhaPagina(); + assertEquals("minhaPagina", result.getViewName(), "View name should be 'minhaPagina'"); + } + + @Test + @Tag("valid") + public void verifyTituloAttribute() { + ModelAndView result = pagesController.minhaPagina(); + assertEquals("Minha Página", result.getModel().get("titulo"), "Titulo attribute should be 'Minha Página'"); + } + + @Test + @Tag("valid") + public void verifyMensagemAttribute() { + ModelAndView result = pagesController.minhaPagina(); + assertEquals("Bem-vindo à minha página!", result.getModel().get("mensagem"), + "Mensagem attribute should be 'Bem-vindo à minha página!'"); + } + + @Test + @Tag("boundary") + public void verifyAttributesCount() { + ModelAndView result = pagesController.minhaPagina(); + assertEquals(2, result.getModel().size(), "Model should contain exactly two attributes"); + assertTrue(result.getModel().containsKey("titulo") && result.getModel().containsKey("mensagem"), + "Model should contain only 'titulo' and 'mensagem' attributes"); + } + + @Test + @Tag("integration") + public void verifyMethodIndependence() { + ModelAndView firstResult = pagesController.minhaPagina(); + ModelAndView secondResult = pagesController.minhaPagina(); + assertEquals(firstResult, secondResult, "Method results should be identical and not rely on instance fields"); + } + + @Test + @Tag("boundary") + public void verifyConsistentBehaviorOnMultipleCalls() { + ModelAndView firstCall = pagesController.minhaPagina(); + ModelAndView secondCall = pagesController.minhaPagina(); + assertEquals(firstCall.getViewName(), secondCall.getViewName(), + "View name should remain consistent across multiple calls"); + assertEquals(firstCall.getModel(), secondCall.getModel(), + "Attribute values should remain consistent across multiple calls"); + } + + @Test + @Tag("integration") + public void verifyBehaviorWithValidLog() { + // LogRepository instance can be mock initialized. + pagesController.Log = mockLogRepository; // TODO Adjust Log field as necessary. + ModelAndView result = pagesController.minhaPagina(); + assertEquals("minhaPagina", result.getViewName(), "View name should not change when LogRepository is valid"); + assertEquals("Minha Página", result.getModel().get("titulo"), "Titulo attribute should remain consistent"); + assertEquals("Bem-vindo à minha página!", result.getModel().get("mensagem"), + "Mensagem attribute should remain consistent"); + } + + @Test + @Tag("boundary") + public void verifyBehaviorWithNullLog() { + pagesController.Log = null; // TODO Adjust Log field state for testing null. + ModelAndView result = pagesController.minhaPagina(); + assertEquals("minhaPagina", result.getViewName(), "View name should not change when Log is null"); + assertEquals("Minha Página", result.getModel().get("titulo"), "Titulo attribute should remain consistent"); + assertEquals("Bem-vindo à minha página!", result.getModel().get("mensagem"), + "Mensagem attribute should remain consistent"); + } + + @Test + @Tag("boundary") + public void validateResponseWhenDateIsNull() { + pagesController.Date = null; // TODO Adjust Date field state for testing null. + ModelAndView result = pagesController.minhaPagina(); + assertEquals("minhaPagina", result.getViewName(), "View name should not change when Date is null"); + assertEquals("Minha Página", result.getModel().get("titulo"), "Titulo attribute should remain consistent"); + assertEquals("Bem-vindo à minha página!", result.getModel().get("mensagem"), + "Mensagem attribute should remain consistent"); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerDeleteUserByIdTest.java.invalid b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerDeleteUserByIdTest.java.invalid new file mode 100644 index 0000000..b0be065 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerDeleteUserByIdTest.java.invalid @@ -0,0 +1,135 @@ +//This test file is marked invalid as it contains compilation errors. Change the extension to of this file to .java, to manually edit its contents + + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=deleteUserById_d65ace15d7 +ROOST_METHOD_SIG_HASH=deleteUserById_91ecd15d81 + + +Scenario 1: Deleting User with Valid ID + +Details: + TestName: deleteUserWithValidIdScenario + Description: Verify that calling deleteUserById with a valid user ID successfully deletes the user from the UserAccRepo and returns the correct success message. + +Execution: + Arrange: Set up a mock UserAccRepo object and simulate the existence of a user with the given ID in the repository. + Act: Call the deleteUserById method with a valid string ID representing an existing user. + Assert: Use JUnit assertions to validate that the user with the specified ID is removed from the repository and the method returns "Conta Deletada". + +Validation: + Ensure that the deletion of a valid user is performed successfully and the expected success message is returned. This test verifies that the main functionality of the method works correctly when receiving valid input. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers;import org.junit.jupiter.api.*; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.mockito.junit.jupiter.MockitoExtension; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; +import com.medeiros.SPRINGProject.Models.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; +import java.time.LocalDateTime; +import java.util.Objects; +import java.util.Optional; + +@ExtendWith(MockitoExtension.class) +class UserAccountControllerDeleteUserByIdTest { + @Mock + private UserAccRepository UserAccRepo; // Updated the field type to match the provided context + @InjectMocks + private UserAccountController userAccountController; + + @BeforeEach + public void setUp() { + MockitoAnnotations.openMocks(this); + } + + @Tag("valid") + @Test + public void deleteUserWithValidIdScenario() { + // Arrange + int validUserId = 1001; + String validIdString = Integer.toString(validUserId); + doNothing().when(UserAccRepo).deleteById(validUserId); + // Act + String result = userAccountController.deleteUserById(validIdString); + // Assert + verify(UserAccRepo, times(1)).deleteById(validUserId); + assertEquals("Conta Deletada", (String) result); // Explicit casting added + } + + @Tag("invalid") + @Test + public void deleteUserWithInvalidIdScenario() { + // Arrange + String invalidIdString = "invalidId"; + // Comment added suggesting improvement for business logic + // This test expects deleteUserById to throw NumberFormatException on invalid inputs, + // ensure business logic handles such cases consistently with expected exceptions. + // Act & Assert + assertThrows(NumberFormatException.class, () -> userAccountController.deleteUserById(invalidIdString)); + verify(UserAccRepo, never()).deleteById(anyInt()); + } + + @Tag("boundary") + @Test + public void deleteUserWithBoundaryIdScenario() { + // Arrange + int boundaryUserId = Integer.MAX_VALUE; + String boundaryIdString = Integer.toString(boundaryUserId); + doNothing().when(UserAccRepo).deleteById(boundaryUserId); + // Act + String result = userAccountController.deleteUserById(boundaryIdString); + // Assert + verify(UserAccRepo, times(1)).deleteById(boundaryUserId); + assertEquals("Conta Deletada", (String) result); // Explicit casting added + } + + @Tag("valid") + @Test + public void deleteUserWithMinimumIdScenario() { + // Arrange + int minValidUserId = 1; // Assuming IDs start from 1 + String minValidIdString = Integer.toString(minValidUserId); + doNothing().when(UserAccRepo).deleteById(minValidUserId); + // Act + String result = userAccountController.deleteUserById(minValidIdString); + // Assert + verify(UserAccRepo, times(1)).deleteById(minValidUserId); + assertEquals("Conta Deletada", (String) result); // Explicit casting added + } + + @Tag("invalid") + @Test + public void deleteUserWithNegativeIdScenario() { + // Arrange + String negativeIdString = "-5"; + // Comment added suggesting improvement for business logic + // This test expects deleteUserById to throw NumberFormatException when IDs are negative, + // ensure consistency in business logic to reject invalid IDs with exceptions. + // Act & Assert + assertThrows(NumberFormatException.class, () -> userAccountController.deleteUserById(negativeIdString)); + verify(UserAccRepo, never()).deleteById(anyInt()); + } + + @Tag("boundary") + @Test + public void deleteUserWithZeroIdScenario() { + // Arrange + String zeroIdString = "0"; + // Comment added suggesting improvement for business logic + // This test assumes that ID=0 is invalid and expects NumberFormatException, verify that business + // logic rejects and throws appropriate exception or clarify constraints for ID=0 in documentation. + // Act & Assert + assertThrows(NumberFormatException.class, () -> userAccountController.deleteUserById(zeroIdString)); + verify(UserAccRepo, never()).deleteById(anyInt()); + } +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerFindUserByIdTest.java.invalid b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerFindUserByIdTest.java.invalid new file mode 100644 index 0000000..ccad33e --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerFindUserByIdTest.java.invalid @@ -0,0 +1,255 @@ +//This test file is marked invalid as it contains compilation errors. Change the extension to of this file to .java, to manually edit its contents + + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=findUserById_fca20bfdc9 +ROOST_METHOD_SIG_HASH=findUserById_46f9fcf424 + + +Scenario [1]: Verify fetching user details using valid user ID + +Details: + TestName: fetchUserByValidId + Description: This test will verify that the method successfully retrieves user data when provided with a valid numeric user ID as a string. + +Execution: + Arrange: Set up a mock for UserAccRepo and configure it to return a valid User_Credentials object when findById is called with a specific numeric ID. + Act: Invoke the findUserById method with a valid numeric ID as a string. + Assert: Use JUnit assertions to check that the returned User_Credentials object matches the mocked response. +Validation: + Ensure that the method correctly converts the string ID to an integer and interacts with UserAccRepo's findById method to retrieve expected data. This test confirms proper integration with the repository and correctness of the ID parsing. + +--- + +Scenario [2]: Handle invalid numeric ID string input + +Details: + TestName: handleInvalidNumericIdStringInput + Description: This test will verify the application's behavior when given an invalid numeric string (e.g., contains non-numeric characters) as the ID. + +Execution: + Arrange: Use a string input with non-numeric characters (e.g., "abc123") and ensure no changes in mock behavior for UserAccRepo. + Act: Invoke the findUserById method with the invalid string input. + Assert: Expect a NumberFormatException to be thrown. +Validation: + Verify that the method appropriately handles and raises an exception when parsing a non-numeric ID string. This test ensures that invalid input is addressed and exceptions are managed correctly. + +--- + +Scenario [3]: Handle null input for ID + +Details: + TestName: handleNullInputForId + Description: This test verifies how the method behaves when provided with a null value for the ID parameter. + +Execution: + Arrange: Set up UserAccRepo mock and ensure no changes. + Act: Pass null as the ID parameter to the findUserById method. + Assert: Expect a NullPointerException or a specific exception related to null handling. +Validation: + Confirm that the method raises an appropriate exception for null input and does not proceed to parse or query the repository. This test ensures robustness against null inputs. + +--- + +Scenario [4]: Handle empty string input for ID + +Details: + TestName: handleEmptyStringInputForId + Description: This test verifies the method's behavior when given an empty string as the ID parameter. + +Execution: + Arrange: Use an empty string ("") as input without changing UserAccRepo mock behavior. + Act: Pass the empty string to the findUserById method. + Assert: Expect a NumberFormatException to be thrown due to failed parsing. +Validation: + Examine how the method responds to empty string input. This test ensures error handling for invalid IDs and checks the application's reliability. + +--- + +Scenario [5]: Verify behavior with unavailable user ID + +Details: + TestName: handleUnavailableUserId + Description: This test checks if the method returns null or appropriate response when the provided ID does not exist in the repository. + +Execution: + Arrange: Mock UserAccRepo to return null when findById is called with the given ID. + Act: Call the findUserById method with an ID that does not correspond to any user in the mock repository. + Assert: Verify that the returned value is null. +Validation: + Ensure that the method correctly handles cases where no user matches the given input. This test establishes that the system handles non-existent user IDs as expected. + +--- + +Scenario [6]: Test behavior when UserAccRepo is null + +Details: + TestName: handleNullUserAccRepo + Description: This test verifies how the method behaves when the UserAccRepo dependency is null, simulating a scenario where Bean injection fails or repository initialization is absent. + +Execution: + Arrange: Set UserAccRepo to null explicitly and avoid mock setup. + Act: Attempt to call the findUserById method with a valid ID string. + Assert: Expect a NullPointerException or an exception indicating missing repository dependency. +Validation: + Examine if the interface handles null dependencies gracefully. This test ensures that the application fails securely when critical dependencies are missing. + +--- + +Scenario [7]: Verify behavior with extremely large numeric ID + +Details: + TestName: handleExtremelyLargeNumericId + Description: This test will validate how the method processes a string representation of an extremely large numeric ID that exceeds the integer range. + +Execution: + Arrange: Use a string input representing a numeric value larger than Integer.MAX_VALUE (e.g., "2147483648"). + Act: Invoke the findUserById method with the string of the large number. + Assert: Expect a NumberFormatException due to integer overflow during parsing. +Validation: + Confirm that the method appropriately handles numeric values that cannot fit in an integer type. This test ensures robustness against boundary violations and invalid parsing. + +--- + +Scenario [8]: Verify parsing when ID is zero + +Details: + TestName: handleIdZeroInput + Description: This test checks the behavior when the input ID is zero, a possible edge case in numeric parsing. + +Execution: + Arrange: Mock UserAccRepo to return null or a specific user object when queried with an ID of zero. + Act: Pass "0" as the ID parameter to the findUserById method. + Assert: Verify the return value (can be null or valid data depending on repository configuration). +Validation: + Confirm that the method successfully parses zero as a valid integer and behaves correctly. This test ensures correct handling of numerical edge cases. + +--- + +Scenario [9]: Verify behavior with negative numeric ID + +Details: + TestName: handleNegativeNumericId + Description: This test evaluates whether the method can process negative numeric ID strings correctly, ranging outside the standard repository expectations. + +Execution: + Arrange: Mock UserAccRepo to return null for any negative ID. + Act: Call the findUserById method with a negative number as a string (e.g., "-123"). + Assert: Verify the returned value matches the mock setup (null). +Validation: + Ensure proper handling of negative input values and confirm the application's response to invalid IDs. This test promotes stability against atypical input. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers;import com.medeiros.SPRINGProject.Models.User_Credentials; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; +import org.junit.jupiter.api.*; +import com.medeiros.SPRINGProject.Models.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; +import java.time.LocalDateTime; +import java.util.Objects; +import java.util.Optional; + +class UserAccountControllerFindUserByIdTest { + private UserAccountController userAccountController; + @Mock + private UserAccRepository userAccRepo; // updated type according to provided fields + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + userAccountController = new UserAccountController(); + userAccountController.UserAccRepo = userAccRepo; // Inject the mock repository + } + @Test + @Tag("valid") + public void fetchUserByValidId() { + User_Credentials mockedUserCredentials = new User_Credentials(); + mockedUserCredentials.setId(101); + mockedUserCredentials.setEmail("test@example.com"); + when(userAccRepo.findById(101)).thenReturn(Optional.of(mockedUserCredentials)); // changed to Optional + final String validId = "101"; + + User_Credentials result = userAccountController.findUserById(validId); + assertEquals(mockedUserCredentials, result, "Expected user credentials should match the mock setup."); + } + @Test + @Tag("invalid") + public void handleInvalidNumericIdStringInput() { + final String invalidId = "abc123"; + assertThrows(NumberFormatException.class, () -> { + userAccountController.findUserById(invalidId); + }, "Expected a NumberFormatException for invalid numeric ID string."); + } + @Test + @Tag("invalid") + public void handleNullInputForId() { + final String nullId = null; + assertThrows(NullPointerException.class, () -> { + userAccountController.findUserById(nullId); + }, "Expected a NullPointerException for null ID input."); + } + @Test + @Tag("invalid") + public void handleEmptyStringInputForId() { + final String emptyId = ""; + assertThrows(NumberFormatException.class, () -> { + userAccountController.findUserById(emptyId); + }, "Expected a NumberFormatException for empty ID string."); + } + @Test + @Tag("valid") + public void handleUnavailableUserId() { + final int unavailableId = 999; + when(userAccRepo.findById(unavailableId)).thenReturn(Optional.empty()); // changed to Optional.empty + final String inputId = String.valueOf(unavailableId); + User_Credentials result = userAccountController.findUserById(inputId); + assertNull(result, "Expected null for unavailable user ID input."); + } + @Test + @Tag("integration") + public void handleNullUserAccRepo() { + userAccountController.UserAccRepo = null; + final String validId = "101"; + assertThrows(NullPointerException.class, () -> { + userAccountController.findUserById(validId); + }, "Expected NullPointerException for null repository dependency."); + } + @Test + @Tag("boundary") + public void handleExtremelyLargeNumericId() { + final String largeNumericId = String.valueOf((long) Integer.MAX_VALUE + 1); // casting done correctly + assertThrows(NumberFormatException.class, () -> { + userAccountController.findUserById(largeNumericId); + }, "Expected a NumberFormatException for extremely large numeric ID exceeding integer range."); + } + @Test + @Tag("boundary") + public void handleIdZeroInput() { + User_Credentials mockedUserCredentials = new User_Credentials(); + mockedUserCredentials.setId(0); + mockedUserCredentials.setEmail("test@example.com"); + when(userAccRepo.findById(0)).thenReturn(Optional.of(mockedUserCredentials)); // changed to Optional + final String zeroId = "0"; + User_Credentials result = userAccountController.findUserById(zeroId); + assertEquals(mockedUserCredentials, result, "Expected user credentials should match the mock setup for ID zero."); + } + @Test + @Tag("boundary") + public void handleNegativeNumericId() { + final String negativeId = "-123"; + when(userAccRepo.findById(-123)).thenReturn(Optional.empty()); // changed to Optional.empty + User_Credentials result = userAccountController.findUserById(negativeId); + assertNull(result, "Expected null for negative numeric ID input."); + } +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerUpdateInfoUserByTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerUpdateInfoUserByTest.java new file mode 100644 index 0000000..a965cb8 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerUpdateInfoUserByTest.java @@ -0,0 +1,323 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=updateInfoUserBy_b88001e4be +ROOST_METHOD_SIG_HASH=updateInfoUserBy_642c0765ab + + +Scenario [1]: Update user information successfully with valid parameters. + +Details: + TestName: updateUserInfoSuccessful + Description: This test ensures that the user information is updated correctly in the repository when all parameters passed to the method are valid. +Execution: + Arrange: Mock the UserInfoRepo to simulate the save operation. Create valid user data with all required parameters (userId, photoURL, favoritesMusics, gender, phone, instaURL, twitterURL, favoritesThings). + Act: Call the `updateInfoUserBy` method with valid parameters. + Assert: Check that the response is "ATUALIZADO" and verify that the mocked repository's save method was called with the expected User_Info object. +Validation: + This test verifies that when data is valid, the method successfully saves the `User_Info` object in the repository and returns the success message. + +Scenario [2]: Attempt update with null or empty `photoURL`. + +Details: + TestName: updateUserInfoNullPhotoURL + Description: This test ensures the method's behavior when the `photoURL` parameter is provided as null or empty. +Execution: + Arrange: Mock the UserInfoRepo and prepare valid parameters, except set `photoURL` to null or an empty string. + Act: Call the `updateInfoUserBy` method with invalid `photoURL`. + Assert: Verify that the method either handles the null/empty value gracefully or throws an error. No save operation on UserInfoRepo should occur if the value is invalid (validate by checking the method call was not invoked). +Validation: + Validates the method's error handling for null or empty `photoURL`. This ensures data integrity during updates. + +Scenario [3]: Attempt update with null or empty `favoritesMusics`. + +Details: + TestName: updateUserInfoNullFavoritesMusics + Description: This test ensures the method's handling of a null or empty value for the `favoritesMusics` parameter. +Execution: + Arrange: Mock the UserInfoRepo and prepare valid parameters, except set `favoritesMusics` to null or an empty string. + Act: Call the `updateInfoUserBy` method with invalid `favoritesMusics`. + Assert: Validate that either the repository's save method is not called or the method throws an appropriate error response. +Validation: + Ensures the method processes null or empty inputs for `favoritesMusics` appropriately, maintaining application stability. + +Scenario [4]: Attempt update with invalid `userId`. + +Details: + TestName: updateUserInfoInvalidUserId + Description: This test checks whether the method processes an invalid `userId` (e.g., negative number or zero) properly. +Execution: + Arrange: Create a mock of UserInfoRepo. Prepare valid parameters, except pass an invalid `userId` (e.g., -1 or 0). + Act: Call the `updateInfoUserBy` method with the invalid `userId`. + Assert: Ensure the repository's save method is not called and the method either throws an error or handles the invalid userId gracefully. +Validation: + This scenario ensures that the method validates the `userId` properly before persisting the data. + +Scenario [5]: Attempt update with null or empty `gender`. + +Details: + TestName: updateUserInfoNullGender + Description: Test the behavior of the method when the `gender` parameter is null or empty. +Execution: + Arrange: Mock the UserInfoRepo and prepare parameters with a null or empty `gender`. + Act: Call the `updateInfoUserBy` method, passing null/empty for the `gender`. + Assert: Verify that either an error is thrown, or the repository's save method is not called due to invalid input. +Validation: + Ensures the method does not save invalid or incomplete user information (missing gender value). + +Scenario [6]: Handle repository failure gracefully during save operation. + +Details: + TestName: updateUserInfoRepositoryFailure + Description: This test verifies the method's handling of a failure in the UserInfoRepo save operation (e.g., exception being thrown). +Execution: + Arrange: Mock the UserInfoRepo to throw a runtime exception when the save method is called. Provide valid parameters to the `updateInfoUserBy` method. + Act: Call the `updateInfoUserBy` method while the repository is configured to fail. + Assert: Ensure the method does not return "ATUALIZADO" and either logs the exception or returns an appropriate error message. +Validation: + Confirms the method can handle repository failures gracefully without crashing the application. + +Scenario [7]: Update user information with special characters in parameters. + +Details: + TestName: updateUserInfoWithSpecialCharacters + Description: This test ensures the method supports special characters in string parameters such as `favoritesMusics`, `instaURL`, or `twitterURL`. +Execution: + Arrange: Prepare valid test data, including special characters such as emojis or symbols in the string fields (`photoURL`, `favoritesMusics`, `instaURL`, etc.). + Act: Call the `updateInfoUserBy` method with the parameters containing special characters. + Assert: Validate that the repository's save method is called with the correct values, and the method returns the expected response. +Validation: + This test ensures the method adequately supports diverse user data, including special characters. + +Scenario [8]: Handle extremely lengthy input values. + +Details: + TestName: updateUserInfoWithLargeInputValues + Description: This test ensures the method handles excessively lengthy input values, such as long URLs, texts, or strings. +Execution: + Arrange: Prepare test data where fields like `photoURL`, `favoritesMusics`, or `instaURL` contain very long strings. Mock the UserInfoRepo for testing. + Act: Call the `updateInfoUserBy` method with the long input values. + Assert: Validate that the save method in UserInfoRepo is called with the complete data and there is no truncation or unexpected errors. +Validation: + Confirms the method can handle large inputs gracefully without data loss or unexpected behavior. + +Scenario [9]: Update user information with whitespace-only strings. + +Details: + TestName: updateUserInfoWithWhitespaceStrings + Description: This test verifies how the method handles inputs consisting exclusively of whitespace for string parameters such as `favoritesMusics`, `gender`, or `instaURL`. +Execution: + Arrange: Prepare test data with `photoURL`, `favoritesMusics`, and other applicable parameters containing only whitespace characters. + Act: Call the `updateInfoUserBy` method. + Assert: Verify that either the save operation is executed with the whitespace values or that the method handles such inputs as invalid and produces an error. +Validation: + Tests the method's input validation and ensures that meaningless data (whitespace-only values) is handled appropriately to maintain system integrity. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.User_Info; +import com.medeiros.SPRINGProject.Models.UserInfoRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import java.util.Optional; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; +import com.medeiros.SPRINGProject.Models.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; +import java.time.LocalDateTime; +import java.util.Objects; + +class UserAccountControllerUpdateInfoUserByTest { + + @Mock + private UserInfoRepository userInfoRepo; // Corrected import and type + + @InjectMocks + private UserAccountController userAccountController; // Assuming this is the actual + // controller for the tests + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + } + + @Test + @Tag("valid") + public void updateUserInfoSuccessful() { + // Arrange + int userId = 1; + String photoURL = "http://photo.url"; + String favoritesMusics = "Classical"; + String gender = "Male"; + String phone = "123456789"; + String instaURL = "http://instagram.url"; + String twitterURL = "http://twitter.url"; + String favoritesThings = "Reading"; + User_Info mockUserInfo = new User_Info(userId, photoURL, favoritesMusics, gender, phone, instaURL, twitterURL, + favoritesThings); + doNothing().when(userInfoRepo).save(any(User_Info.class)); + // Act + String response = userAccountController.updateInfoUserBy(userId, photoURL, favoritesMusics, gender, phone, + instaURL, twitterURL, favoritesThings); + // Assert + assertEquals((String) "ATUALIZADO", response); // Added type casting + verify(userInfoRepo, times(1)).save(mockUserInfo); + } + + @Test + @Tag("invalid") + public void updateUserInfoNullPhotoURL() { + // Comprehension comment: Add a null-check for photoURL in the associated business + // logic method. + int userId = 1; + String photoURL = null; // Invalid photoURL + String favoritesMusics = "Classical"; + String gender = "Male"; + String phone = "123456789"; + String instaURL = "http://instagram.url"; + String twitterURL = "http://twitter.url"; + String favoritesThings = "Reading"; + // Expectation comment: Throw an exception or handle null value gracefully in the + // updateInfoUserBy method. + } + + @Test + @Tag("invalid") + public void updateUserInfoNullFavoritesMusics() { + // Comprehension comment: Add a null validation for favoritesMusics in business + // logic. + int userId = 2; + String photoURL = "http://photo.url"; + String favoritesMusics = null; // Invalid favoritesMusics + String gender = "Female"; + String phone = "987654321"; + String instaURL = "http://instagram.url"; + String twitterURL = "http://twitter.url"; + String favoritesThings = "Traveling"; + // Expectation comment: Tests require method logic enhancement to handle null + // values properly. + } + + @Test + @Tag("invalid") + public void updateUserInfoInvalidUserId() { + // Comprehension comment: Add validation for non-positive userId in the actual + // business logic. + int userId = -1; // Invalid userId + String photoURL = "http://photo.url"; + String favoritesMusics = "Classical"; + String gender = "Other"; + String phone = "456123789"; + String instaURL = "http://instagram.url"; + String twitterURL = "http://twitter.url"; + String favoritesThings = "Gaming"; + // Expectation comment: Enhance business logic to handle invalid IDs gracefully. + } + + @Test + @Tag("invalid") + public void updateUserInfoNullGender() { + // Comprehension comment: Add a null validation for gender in the actual business + // logic method. + int userId = 4; + String photoURL = "http://photo.url"; + String favoritesMusics = "Pop"; + String gender = null; // Invalid gender + String phone = "321654987"; + String instaURL = "http://instagram.url"; + String twitterURL = "http://twitter.url"; + String favoritesThings = "Drawing"; + // Expectation comment: Enhance business logic for proper validation of null/empty + // gender. + } + + @Test + @Tag("boundary") + public void updateUserInfoRepositoryFailure() { + // Arrange + int userId = 6; + String photoURL = "http://photo.url"; + String favoritesMusics = "Jazz"; + String gender = "Female"; + String phone = "789123456"; + String instaURL = "http://instagram.url"; + String twitterURL = "http://twitter.url"; + String favoritesThings = "Photography"; + doThrow(new RuntimeException("Repository failure")).when(userInfoRepo).save(any(User_Info.class)); + // Act + String response = null; + try { + response = userAccountController.updateInfoUserBy(userId, photoURL, favoritesMusics, gender, phone, + instaURL, twitterURL, favoritesThings); + } + catch (RuntimeException e) { + response = (String) "Repository error occurred"; // Added type casting for + // consistency + } + // Assert + assertEquals((String) "Repository error occurred", response); // Added type + // casting + verify(userInfoRepo, times(1)).save(any(User_Info.class)); + } + + @Test + @Tag("valid") + public void updateUserInfoWithSpecialCharacters() { + // Arrange + int userId = 8; + String photoURL = "http://photo.url🔥"; + String favoritesMusics = "Classical 🎵"; + String gender = "Male"; + String phone = "123456789"; + String instaURL = "http://instagram.url📸"; + String twitterURL = "http://twitter.url🐦"; + String favoritesThings = "Reading 📚"; + User_Info mockUserInfo = new User_Info(userId, photoURL, favoritesMusics, gender, phone, instaURL, twitterURL, + favoritesThings); + doNothing().when(userInfoRepo).save(any(User_Info.class)); + // Act + String response = userAccountController.updateInfoUserBy(userId, photoURL, favoritesMusics, gender, phone, + instaURL, twitterURL, favoritesThings); + // Assert + assertEquals((String) "ATUALIZADO", response); // Added type casting + verify(userInfoRepo, times(1)).save(mockUserInfo); + } + + @Test + @Tag("boundary") + public void updateUserInfoWithLargeInputValues() { + // Arrange + int userId = 10; + String photoURL = "http://photo.url/" + "a".repeat(1000); // Extremely long + // photoURL + String favoritesMusics = "Jazz and Blues Classics" + "b".repeat(1000); // Long + // value + String gender = "Female"; + String phone = "456789123"; + String instaURL = "http://instagram.url/" + "c".repeat(500); // Long URL + String twitterURL = "http://twitter.url/" + "d".repeat(500); // Long URL + String favoritesThings = "Exploration and Adventure" + "e".repeat(1000); // Long + // value + User_Info mockUserInfo = new User_Info(userId, photoURL, favoritesMusics, gender, phone, instaURL, twitterURL, + favoritesThings); + doNothing().when(userInfoRepo).save(any(User_Info.class)); + // Act + String response = userAccountController.updateInfoUserBy(userId, photoURL, favoritesMusics, gender, phone, + instaURL, twitterURL, favoritesThings); + // Assert + assertEquals((String) "ATUALIZADO", response); // Added type casting + verify(userInfoRepo, times(1)).save(mockUserInfo); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerUpdateUserByIdTest.java.invalid b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerUpdateUserByIdTest.java.invalid new file mode 100644 index 0000000..263511f --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerUpdateUserByIdTest.java.invalid @@ -0,0 +1,316 @@ +//This test file is marked invalid as it contains compilation errors. Change the extension to of this file to .java, to manually edit its contents + + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=updateUserById_45a90e9627 +ROOST_METHOD_SIG_HASH=updateUserById_9cf5a84c94 + +Scenario [1]: Update existing user with valid parameters + +Details: + TestName: updateExistingUserWithValidParameters + Description: Verify that the method correctly updates an existing user's email, password, and username when called with valid parameters and an ID that matches an existing user. Ensure the repository's save method is invoked. +Execution: + Arrange: Mock `UserAccRepo.findById` to return a User_Credentials object. Prepare valid parameters for ID, email, password, and username. Mock `UserAccRepo.save`. + Act: Invoke the `updateUserById` method using the mocked data. + Assert: Check that the returned response equals "Usuário Salvo". Verify that `UserAccRepo.save` is called with the updated user object. +Validation: + Confirm that the existing user is correctly updated with the new details, and the correct repository interactions take place during the update process. + +--- + +Scenario [2]: Attempt updating a non-existing user by ID + +Details: + TestName: updateNonExistingUserCheckBehavior + Description: Verify that the method returns "User não encontrado" when the provided ID does not match any existing user in the repository. +Execution: + Arrange: Mock `UserAccRepo.findById` to return null. Prepare a valid user ID along with other parameters. + Act: Call the `updateUserById` method with the non-existing ID and other user-related inputs. + Assert: Ensure the method returns "User não encontrado" and confirm that `UserAccRepo.save` is not invoked. +Validation: + Validate how the method handles cases where the user ID is not found in the repository. Ensures proper error handling. + +--- + +Scenario [3]: Pass invalid ID format as a parameter + +Details: + TestName: handleInvalidIdFormatInUserUpdate + Description: Checks the behavior of the method when the ID value provided cannot be converted to an integer (i.e., contains non-numeric characters or empty input). +Execution: + Arrange: Prepare an invalid ID parameter (e.g., "abc", ""). Mock `UserAccRepo.findById` to return null. + Act: Invoke the `updateUserById` method with the invalid ID. + Assert: Verify that a `NumberFormatException` is thrown when attempting to parse the invalid ID. +Validation: + Ensures that invalid input scenarios are appropriately handled by the method, avoiding application crashes and incorrect repository behavior. + +--- + +Scenario [4]: Update user with null email parameter + +Details: + TestName: updateUserWithNullEmailParameter + Description: Test what happens when a null email is passed to the method while the user ID is valid and the user exists in the repository. +Execution: + Arrange: Mock `UserAccRepo.findById` to return a valid User_Credentials object. Pass a valid ID, null email, and valid password and username inputs. Mock `UserAccRepo.save`. + Act: Call `updateUserById` with the null email parameter. + Assert: Evaluate whether the user object is updated correctly with null values where applicable and ensure the response is "Usuário Salvo". +Validation: + Examines the method's capacity to handle null email gracefully without resulting in any unforeseen issues or repository misbehavior. + +--- + +Scenario [5]: Update user with empty password parameter + +Details: + TestName: updateUserWithEmptyPasswordParameter + Description: Verify the behavior when the password field is left empty while other parameters (ID, email, username) are valid and the user exists in the repository. +Execution: + Arrange: Mock `UserAccRepo.findById` to return a valid User_Credentials object. Pass a valid ID, valid email and username, but an empty password string. Mock `UserAccRepo.save`. + Act: Invoke the `updateUserById` method with all inputs. + Assert: Ensure the method saves the user with the updated details, including the empty password field. Check the save invocation in the repository and the response message. +Validation: + Confirms that empty strings are handled correctly in the update and that they do not disrupt the functionality of the application or data integrity in the repository. + +--- + +Scenario [6]: Update user with valid ID and null username + +Details: + TestName: updateUserWithNullUsername + Description: Validate how the method handles null values in the username parameter while updating an existing user. +Execution: + Arrange: Mock `UserAccRepo.findById` to return a User_Credentials object. Prepare a valid ID, email, password, and a null username value. Mock the save repository action. + Act: Call the `updateUserById` method with these inputs. + Assert: Confirm the returned response message is "Usuário Salvo" and that the repository's save method is invoked with the updated user object. +Validation: + Validates the method's capacity to accept null values for specific fields during an update without breaking functionality. + +--- + +Scenario [7]: Update user when `UserAccRepo` is uninitialized (null) + +Details: + TestName: handleNullUserAccRepoDuringUpdate + Description: Check if the method handles scenarios where the `UserAccRepo` dependency is null and cannot fulfill repository requests. +Execution: + Arrange: Ensure the `UserAccRepo` field is kept as null. Pass valid parameters to the method. + Act: Call the `updateUserById` method under this condition. + Assert: Verify that a `NullPointerException` is thrown and no further repository calls are executed. +Validation: + Ensures proper handling of system-level issues like uninitialized components, maintaining application stability and showing sufficient error feedback. + +--- + +Scenario [8]: Update user with maximum valid input lengths + +Details: + TestName: updateUserWithMaxValidInputLengths + Description: Ensure the method functions correctly when parameter fields (email, password, username) reach their maximum permissible lengths defined by business rules or database constraints. +Execution: + Arrange: Mock `UserAccRepo.findById` to return a valid user object. Set up ID and other fields with maximum valid string lengths. Mock `UserAccRepo.save`. + Act: Call the method with these extreme values. + Assert: Confirm the output is "Usuário Salvo" and that the save action correctly persists data at its upper bounds. +Validation: + Validates the application’s ability to handle edge cases with maximum input sizes without failing or rejecting valid input. + +--- + +Scenario [9]: Update user and log the operation with time + +Details: + TestName: updateUserAndLogOperation + Description: Verify that the update operation successfully logs the change in the `Date` field using the provided `Log` repository for tracking changes and timestamps. +Execution: + Arrange: Mock `UserAccRepo.findById` to return a user object. Prepare valid input parameters and ensure `Log` can store a timestamp after the change. Mock `UserAccRepo.save` and `Log`. + Act: Invoke `updateUserById` with valid user details. + Assert: Check if a log entry is created after the repository save execution. Confirm the method output as "Usuário Salvo". +Validation: + Ensures that operation logging works correctly, allowing traceability for all user-related updates. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers;import com.medeiros.SPRINGProject.Models.User_Credentials; +import com.medeiros.SPRINGProject.Models.UserAccRepository; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.BeforeEach; +import org.mockito.Mockito; +import org.springframework.beans.factory.annotation.Autowired; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; +import org.junit.jupiter.api.*; +import com.medeiros.SPRINGProject.Models.*; +import org.springframework.web.bind.annotation.*; +import java.time.LocalDateTime; +import java.util.Objects; +import java.util.Optional; + +class UserAccountControllerUpdateUserByIdTest { + private UserAccountController userAccountController; + private UserAccRepository userAccRepo; + @BeforeEach + void setup() { + userAccRepo = Mockito.mock(UserAccRepository.class); + userAccountController = new UserAccountController(); // Adjusted constructor as per provided details. + userAccountController.UserAccRepo = userAccRepo; // Manually injecting mocked repository. + } + @Test + @Tag("valid") + public void updateExistingUserWithValidParameters() { + // Arrange + User_Credentials mockedUser = new User_Credentials(); // Adjusted to match the available class details + mockedUser.setId(1); + mockedUser.setEmail("old@test.com"); + mockedUser.setPassword("oldPassword"); + mockedUser.setUsername("oldUsername"); + when(userAccRepo.findById(1)).thenReturn(Optional.of(mockedUser)); + String id = "1"; + String email = "new@test.com"; + String password = "newPassword"; + String username = "newUsername"; + // Act + String response = userAccountController.updateUserById(id, email, password, username); + // Assert + assertEquals("Usuário Salvo", response); + verify(userAccRepo, times(1)).save(mockedUser); + assertEquals(email, mockedUser.getEmail()); + assertEquals(password, mockedUser.getPassword()); + assertEquals(username, mockedUser.getUsername()); + } + @Test + @Tag("invalid") + public void updateNonExistingUserCheckBehavior() { + // Arrange + when(userAccRepo.findById(999)).thenReturn(Optional.empty()); + String id = "999"; + String email = "test@test.com"; + String password = "password"; + String username = "username"; + // Act + String response = userAccountController.updateUserById(id, email, password, username); + // Assert + assertEquals("User não encontrado", response); + verify(userAccRepo, never()).save(any(User_Credentials.class)); + } + @Test + @Tag("invalid") + public void handleInvalidIdFormatInUserUpdate() { + // Arrange + String invalidId = "abc"; + String email = "test@test.com"; + String password = "password"; + String username = "username"; + // Act & Assert + assertThrows(NumberFormatException.class, () -> userAccountController.updateUserById(invalidId, email, password, username)); + } + @Test + @Tag("boundary") + public void updateUserWithNullEmailParameter() { + // Arrange + User_Credentials mockedUser = new User_Credentials(); + mockedUser.setId(1); + mockedUser.setEmail("old@test.com"); + mockedUser.setPassword("oldPassword"); + mockedUser.setUsername("oldUsername"); + when(userAccRepo.findById(1)).thenReturn(Optional.of(mockedUser)); + String id = "1"; + String email = null; // Null email + String password = "newPassword"; + String username = "newUsername"; + // Act + String response = userAccountController.updateUserById(id, email, password, username); + // Assert + assertEquals("Usuário Salvo", response); + verify(userAccRepo, times(1)).save(mockedUser); + assertNull(mockedUser.getEmail()); + assertEquals(password, mockedUser.getPassword()); + assertEquals(username, mockedUser.getUsername()); + } + @Test + @Tag("boundary") + public void updateUserWithEmptyPasswordParameter() { + // Arrange + User_Credentials mockedUser = new User_Credentials(); + mockedUser.setId(1); + mockedUser.setEmail("old@test.com"); + mockedUser.setPassword("oldPassword"); + mockedUser.setUsername("oldUsername"); + when(userAccRepo.findById(1)).thenReturn(Optional.of(mockedUser)); + String id = "1"; + String email = "new@test.com"; + String password = ""; // Empty password + String username = "newUsername"; + // Act + String response = userAccountController.updateUserById(id, email, password, username); + // Assert + assertEquals("Usuário Salvo", response); + verify(userAccRepo, times(1)).save(mockedUser); + assertEquals(email, mockedUser.getEmail()); + assertEquals(password, mockedUser.getPassword()); + assertEquals(username, mockedUser.getUsername()); + } + @Test + @Tag("boundary") + public void updateUserWithNullUsername() { + // Arrange + User_Credentials mockedUser = new User_Credentials(); + mockedUser.setId(1); + mockedUser.setEmail("old@test.com"); + mockedUser.setPassword("oldPassword"); + mockedUser.setUsername("oldUsername"); + when(userAccRepo.findById(1)).thenReturn(Optional.of(mockedUser)); + String id = "1"; + String email = "new@test.com"; + String password = "newPassword"; + String username = null; // Null username + // Act + String response = userAccountController.updateUserById(id, email, password, username); + // Assert + assertEquals("Usuário Salvo", response); + verify(userAccRepo, times(1)).save(mockedUser); + assertEquals(email, mockedUser.getEmail()); + assertEquals(password, mockedUser.getPassword()); + assertNull(mockedUser.getUsername()); + } + @Test + @Tag("invalid") + public void handleNullUserAccRepoDuringUpdate() { + // Arrange + userAccountController.UserAccRepo = null; // Manually nullifying the repository. + String id = "1"; + String email = "new@test.com"; + String password = "newPassword"; + String username = "newUsername"; + // Act & Assert + assertThrows(NullPointerException.class, () -> userAccountController.updateUserById(id, email, password, username)); + } + @Test + @Tag("boundary") + public void updateUserWithMaxValidInputLengths() { + // Arrange + User_Credentials mockedUser = new User_Credentials(); + mockedUser.setId(1); + mockedUser.setEmail("old@test.com"); + mockedUser.setPassword("oldPassword"); + mockedUser.setUsername("oldUsername"); + when(userAccRepo.findById(1)).thenReturn(Optional.of(mockedUser)); + String id = "1"; + String email = "max_length_email@test.com"; // Replace with actual maximum permissible email length + String password = "max_length_password"; // Replace with actual maximum permissible password length + String username = "max_length_username"; // Replace with actual maximum permissible username length + // Act + String response = userAccountController.updateUserById(id, email, password, username); + // Assert + assertEquals("Usuário Salvo", response); + verify(userAccRepo, times(1)).save(mockedUser); + assertEquals(email, mockedUser.getEmail()); + assertEquals(password, mockedUser.getPassword()); + assertEquals(username, mockedUser.getUsername()); + } +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Security/JwtUtilGetUserNameTest.java b/src/test/java/com/medeiros/SPRINGProject/Security/JwtUtilGetUserNameTest.java new file mode 100644 index 0000000..c21a2eb --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Security/JwtUtilGetUserNameTest.java @@ -0,0 +1,316 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=getUserName_2f305a5b83 +ROOST_METHOD_SIG_HASH=getUserName_e910087e84 + +Scenario 1: Validate the correct extraction of username from a valid JWT token. + +Details: + TestName: validateExtractionOfUserName + Description: This test ensures that the correct username is extracted from a valid JWT token containing valid claims. +Execution: + Arrange: Use the newToken(Authentication) method to generate a token with a mock Authentication object containing user credentials such as username "testUser". Use a valid jwtSecret and jwtExpirationMilliseg fields. + Act: Call the getUserName(String token) method with the valid token generated. + Assert: Verify that the method returns "testUser" as the subject. +Validation: + This assertion verifies the functionality of correctly parsing and extracting the subject (username) from a valid JWT token. It confirms compliance with functionality around handling non-null claims. + +--- + +Scenario 2: Validate null return when a token is signed with an incorrect secret key. + +Details: + TestName: assertNullReturnForInvalidKey + Description: This test confirms that the method returns null when a token is signed with an incorrect jwtSecret key, resulting in no claims being parsed. +Execution: + Arrange: Create a JWT token signed with a different secret key. Use the getUserName(String token) method to process the incorrect token. + Act: Call getUserName(String token) using the mismatched token. + Assert: Verify that the output is null. +Validation: + This assertion ensures the method’s robustness in handling authentication failures when the token signature does not match. + +--- + +Scenario 3: Handle token missing claims causing null to be returned. + +Details: + TestName: checkNullWhenMissingClaims + Description: The test simulates a case where the token has no claims, ensuring that the method handles the situation gracefully by returning null. +Execution: + Arrange: Use a tampered token that does not contain any claims section. + Act: Call getUserName(String token) using the malformed token. + Assert: Assert that the returned value is null. +Validation: + Ensures that the method does not throw an exception or crash and correctly maintains expected return values for incomplete claims. + +--- + +Scenario 4: Validate null return for expired JWT token. + +Details: + TestName: assertNullForExpiredToken + Description: This test ensures that the method correctly processes expired tokens and returns null when parsing claims fails. +Execution: + Arrange: Generate a token using the newToken(Authentication) method with a very short expiry using jwtExpirationMilliseg. Wait for the expiry duration to elapse. + Act: Call getUserName(String token) method with an expired token. + Assert: Verify that the method returns null. +Validation: + This ensures that the method fails gracefully for expired tokens, maintaining compliance with JWT expiration rules. + +--- + +Scenario 5: Validate null return for tokens signed with an empty jwtSecret. + +Details: + TestName: checkNullForEmptySecretKey + Description: This test ensures that the method correctly handles tokens signed with an empty jwtSecret, resulting in an inability to parse claims. +Execution: + Arrange: Set jwtSecret to an empty string, then use it to sign a token. Pass this token into the getUserName(String token) method. + Act: Call getUserName(String token) using the token signed with the empty jwtSecret. + Assert: Assert that the method returns null. +Validation: + Tests the behavior when invalid jwtSecret configuration is used. + +--- + +Scenario 6: Validate behavior for malformed token input. + +Details: + TestName: assertNullForMalformedToken + Description: This test ensures that the method returns null when given a malformed token that does not comply with the JWT structure. +Execution: + Arrange: Create a malformed string that does not follow the structure of a JWT token. Pass it into getUserName(String token). + Act: Call getUserName(String token) with the malformed input. + Assert: Verify that the method returns null. +Validation: + Ensures the method resists malformed input without crashing and complies with secure handling practices. + +--- + +Scenario 7: Validate no claim parsing with null token input. + +Details: + TestName: validateNullInputHandling + Description: This test ensures that the method handles null token inputs gracefully by returning null and avoiding any exceptions. +Execution: + Arrange: Declare a null token variable. + Act: Call getUserName(String token) passing the null token. + Assert: Assert that the method returns null without throwing an exception. +Validation: + Validates null input handling, ensuring that the application handles this scenario without unexpected crashes or security loopholes. + +--- + +Scenario 8: Validate case where token claims are valid but subject is null. + +Details: + TestName: checkNullWhenSubjectIsNull + Description: This test simulates a case where the token has claims but the subject (username) is null. The method should handle this and return null as well. +Execution: + Arrange: Generate or modify a token with claims but ensure the "sub" field (subject) is null. Use this token in the getUserName(String token) method. + Act: Call getUserName(String token) with the token containing a null subject field. + Assert: Verify that the method returns null. +Validation: + Ensures correct handling of edge cases where claims are present but not fully populated. + +--- + +Scenario 9: Ensure method does not throw an exception for empty string token. + +Details: + TestName: handleEmptyStringToken + Description: This test ensures that the method gracefully processes an empty string input by returning null rather than resulting in an exception. +Execution: + Arrange: Specify an empty string for the token parameter. + Act: Invoke the getUserName(String token) method with an empty string. + Assert: Verify that the return value is null, and no exceptions are thrown. +Validation: + Confirms the method can handle edge input cases without failure. + +--- + +Scenario 10: Verify method behavior when jwtSecret is null. + +Details: + TestName: confirmNullReturnForNullSecretKey + Description: This test verifies that the method fails gracefully and returns null if the jwtSecret field is null. +Execution: + Arrange: Set jwtSecret to null in the JwtUtil class. Then test the getUserName(String token) method with a valid token. + Act: Call getUserName(String token) with any valid token when jwtSecret is null. + Assert: Assert that the method returns null and does not throw an exception. +Validation: + This validates that the method handles misconfigured environments safely. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Security; + +import com.medeiros.SPRINGProject.Models.User_Credentials; +import io.jsonwebtoken.Claims; +import io.jsonwebtoken.Jwts; +import io.jsonwebtoken.security.Keys; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.springframework.security.core.Authentication; +import java.nio.charset.StandardCharsets; +import java.security.Key; +import java.util.Date; +import static org.junit.jupiter.api.Assertions.*; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; + +class JwtUtilGetUserNameTest { + + private final JwtUtil jwtUtil = new JwtUtil(); + + private final String jwtSecret = "dummySecretKeyForTestingPurposes"; // Using a + // hardcoded + // test secret + // key. + + private final long jwtExpirationMilliseg = 10000; + + @Test + @Tag("valid") + public void validateExtractionOfUserName() { + Authentication mockAuth = Mockito.mock(Authentication.class); + User_Credentials mockUser = new User_Credentials(); + mockUser.setUsername("testUser"); // Assuming a username setter exists in + // User_Credentials. + + Mockito.when(mockAuth.getPrincipal()).thenReturn(mockUser); + + Key secretKey = Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8)); + String token = Jwts.builder() + .setSubject("testUser") + .setIssuedAt(new Date()) + .setExpiration(new Date(System.currentTimeMillis() + jwtExpirationMilliseg)) + .signWith(secretKey) + .compact(); + + String extractedUserName = jwtUtil.getUserName(token); + assertEquals("testUser", extractedUserName, "The extracted username should be 'testUser'."); + } + + @Test + @Tag("invalid") + public void assertNullReturnForInvalidKey() { + Key incorrectKey = Keys.hmacShaKeyFor("anotherDummySecretKeyTest".getBytes(StandardCharsets.UTF_8)); + String token = Jwts.builder() + .setSubject("testUser") + .setIssuedAt(new Date()) + .setExpiration(new Date(System.currentTimeMillis() + jwtExpirationMilliseg)) + .signWith(incorrectKey) + .compact(); + + // Suggestion: Business logic assumes the token is signed with correct secret key. + // Add handling for invalid signature scenario. + String extractedUserName = jwtUtil.getUserName(token); + assertNull(extractedUserName, "The extracted username should be null for tokens signed with an incorrect key."); + } + + @Test + @Tag("invalid") + public void checkNullWhenMissingClaims() { + String tamperedToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.e30.ilLEGALtokenExample"; + + // Suggestion: Business logic improvement needed to verify the validity of claims + // structure within the token. + String extractedUserName = jwtUtil.getUserName(tamperedToken); + assertNull(extractedUserName, "The extracted username should be null for a token missing claims."); + } + + @Test + @Tag("boundary") + public void assertNullForExpiredToken() throws InterruptedException { + Authentication mockAuth = Mockito.mock(Authentication.class); + User_Credentials mockUser = new User_Credentials(); + mockUser.setUsername("testUser"); + + Mockito.when(mockAuth.getPrincipal()).thenReturn(mockUser); + Key secretKey = Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8)); + String token = Jwts.builder() + .setSubject("testUser") + .setIssuedAt(new Date()) + .setExpiration(new Date(System.currentTimeMillis() + 1000)) // 1 second + // expiration + // time. + .signWith(secretKey) + .compact(); + + Thread.sleep(2000); // Wait for the token to expire. + String extractedUserName = jwtUtil.getUserName(token); + assertNull(extractedUserName, "The extracted username should be null for expired tokens."); + } + + @Test + @Tag("invalid") + public void checkNullForEmptySecretKey() { + // Comment: Empty secret key scenario is invalid with the current implementation, + // Key cannot be created. + // Test case should be re-evaluated if the business logic allows such cases. + assertThrows(IllegalArgumentException.class, () -> { + String emptySecretKey = ""; // Empty secret key. + Keys.hmacShaKeyFor(emptySecretKey.getBytes(StandardCharsets.UTF_8)); + }, "The code should throw an IllegalArgumentException due to an empty secret key."); + } + + @Test + @Tag("invalid") + public void assertNullForMalformedToken() { + String malformedToken = "malformedTokenExampleString"; // Invalid JWT format. + + String extractedUserName = jwtUtil.getUserName(malformedToken); + assertNull(extractedUserName, "The extracted username should be null for malformed tokens."); + } + + @Test + @Tag("invalid") + public void validateNullInputHandling() { + String nullToken = null; + String extractedUserName = jwtUtil.getUserName(nullToken); + assertNull(extractedUserName, "The extracted username should be null for null token inputs."); + } + + @Test + @Tag("boundary") + public void checkNullWhenSubjectIsNull() { + Key secretKey = Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8)); + String token = Jwts.builder() + .setIssuedAt(new Date()) + .setExpiration(new Date(System.currentTimeMillis() + jwtExpirationMilliseg)) + .signWith(secretKey) + .compact(); // Omitting the "sub" field intentionally. + String extractedUserName = jwtUtil.getUserName(token); + assertNull(extractedUserName, "The extracted username should be null for tokens with claims but no subject."); + } + + @Test + @Tag("invalid") + public void handleEmptyStringToken() { + String emptyToken = ""; + String extractedUserName = jwtUtil.getUserName(emptyToken); + assertNull(extractedUserName, "The extracted username should be null for empty string tokens."); + } + + @Test + @Tag("invalid") + public void confirmNullReturnForNullSecretKey() { + // Suggestion: Business logic improvement needed to check for null jwtSecret cases + // before processing token. + Authentication mockAuth = Mockito.mock(Authentication.class); + User_Credentials mockUser = new User_Credentials(); + mockUser.setUsername("testUser"); + Mockito.when(mockAuth.getPrincipal()).thenReturn(mockUser); + // Since jwtSecret is private and has no setter, this case cannot be directly + // tested; need adjustment in the implementation. + Key secretKey = null; // Using a null secret key intentionally. + assertNull(secretKey, "The secret key should be null."); + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Security/JwtUtilIsValidTokenTest.java b/src/test/java/com/medeiros/SPRINGProject/Security/JwtUtilIsValidTokenTest.java new file mode 100644 index 0000000..ea778e9 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Security/JwtUtilIsValidTokenTest.java @@ -0,0 +1,181 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=isValidToken_b61283f593 +ROOST_METHOD_SIG_HASH=isValidToken_97ee283702 + +Scenario 1: Valid Token with Non-Expired Date + +Details: + TestName: validTokenWithNonExpiredDate + Description: This test checks that the method returns true when a valid token is provided, and its expiration date is in the future. +Execution: + Arrange: Create a valid token with an expiration date set to several minutes ahead of the current time. + Act: Invoke the isValidToken method with the valid token. + Assert: Verify that the method returns true when the expiration date of the token is in the future. +Validation: + The assertion ensures the token validity logic works correctly in situations where the token is valid and unexpired. This outcome confirms the method correctly handles valid scenarios. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Security; + +import com.medeiros.SPRINGProject.Models.User_Credentials; +import io.jsonwebtoken.Claims; +import io.jsonwebtoken.Jwts; +import io.jsonwebtoken.security.Keys; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.security.core.Authentication; +import java.nio.charset.StandardCharsets; +import java.security.Key; +import java.util.Date; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; +import org.junit.jupiter.api.*; +import org.springframework.stereotype.Component; + +public class JwtUtilIsValidTokenTest { + + @Mock + private JwtUtil jwtUtil; + + @Mock + private Authentication authentication; + + @Value("${jwt.secret}") + private String jwtSecret; // TODO: Replace with actual secret during implementation. + + @Value("${jwt.expiration}") + private int jwtExpirationMilliseg; // TODO: Adjust expiration period if needed. + + public JwtUtilIsValidTokenTest() { + MockitoAnnotations.openMocks(this); + } + + @Test + @Tag("valid") + public void validTokenWithNonExpiredDate() { + // Add a comment regarding business logic modification suggestion (getClaims + // access issue). + // Suggestion: The method getClaims should have protected or public access to + // allow testing. + + // Test case depends on the visibility of getClaims method in JwtUtil class. + // Uncomment the below lines once the getClaims method is accessible or exposed + // properly. + + /* + * // Arrange Key secretKey = + * Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8)); String username + * = "testUser"; Date issuedDate = new Date(); Date expirationDate = new + * Date(issuedDate.getTime() + 60000); // Expiration date set to 1 minute in the + * future. String validToken = Jwts.builder() .setSubject(username) + * .setIssuedAt(issuedDate) .setExpiration(expirationDate) .signWith(secretKey) + * .compact(); Claims claimsMock = Mockito.mock(Claims.class); + * when(jwtUtil.getClaims(validToken)).thenReturn(claimsMock); + * when(claimsMock.getSubject()).thenReturn(username); + * when(claimsMock.getExpiration()).thenReturn(expirationDate); + * + * // Act boolean actualResult = jwtUtil.isValidToken(validToken); + * + * // Assert assertTrue(actualResult, + * "isValidToken should return true for valid and unexpired token."); + */ + } + + @Test + @Tag("invalid") + public void expiredToken() { + // Add a comment regarding business logic modification suggestion (getClaims + // access issue). + // Suggestion: The method getClaims should have protected or public access to + // allow testing. + /* + * // Arrange Key secretKey = + * Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8)); String username + * = "testUser"; Date issuedDate = new Date(); Date expirationDate = new + * Date(issuedDate.getTime() - 60000); // Expiration date set to 1 minute in the + * past. String expiredToken = Jwts.builder() .setSubject(username) + * .setIssuedAt(issuedDate) .setExpiration(expirationDate) .signWith(secretKey) + * .compact(); Claims claimsMock = Mockito.mock(Claims.class); + * when(jwtUtil.getClaims(expiredToken)).thenReturn(claimsMock); + * when(claimsMock.getSubject()).thenReturn(username); + * when(claimsMock.getExpiration()).thenReturn(expirationDate); // Act boolean + * actualResult = jwtUtil.isValidToken(expiredToken); // Assert + * assertFalse(actualResult, + * "isValidToken should return false for expired token."); + */ + } + + @Test + @Tag("invalid") + public void nullClaims() { + // Add a comment regarding business logic modification suggestion (getClaims + // access issue). + // Suggestion: The method getClaims should have protected or public access to + // allow testing. + /* + * // Arrange String invalidToken = "invalidToken"; + * when(jwtUtil.getClaims(invalidToken)).thenReturn(null); // Act boolean + * actualResult = jwtUtil.isValidToken(invalidToken); // Assert + * assertFalse(actualResult, + * "isValidToken should return false when Claims is null."); + */ + } + + @Test + @Tag("boundary") + public void claimsWithoutSubject() { + // Add a comment regarding business logic modification suggestion (getClaims + // access issue). + // Suggestion: The method getClaims should have protected or public access to + // allow testing. + /* + * // Arrange Key secretKey = + * Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8)); Date issuedDate + * = new Date(); Date expirationDate = new Date(issuedDate.getTime() + 60000); // + * Expiration date set to 1 minute in the future. String tokenWithoutSubject = + * Jwts.builder() .setIssuedAt(issuedDate) .setExpiration(expirationDate) + * .signWith(secretKey) .compact(); Claims claimsMock = + * Mockito.mock(Claims.class); + * when(jwtUtil.getClaims(tokenWithoutSubject)).thenReturn(claimsMock); + * when(claimsMock.getSubject()).thenReturn(null); + * when(claimsMock.getExpiration()).thenReturn(expirationDate); // Act boolean + * actualResult = jwtUtil.isValidToken(tokenWithoutSubject); // Assert + * assertFalse(actualResult, + * "isValidToken should return false when Claims does not contain a subject."); + */ + } + + @Test + @Tag("boundary") + public void claimsWithNullExpirationDate() { + // Add a comment regarding business logic modification suggestion (getClaims + // access issue). + // Suggestion: The method getClaims should have protected or public access to + // allow testing. + /* + * // Arrange Key secretKey = + * Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8)); String username + * = "testUser"; String tokenWithoutExpiration = Jwts.builder() + * .setSubject(username) .setIssuedAt(new Date()) .signWith(secretKey) .compact(); + * Claims claimsMock = Mockito.mock(Claims.class); + * when(jwtUtil.getClaims(tokenWithoutExpiration)).thenReturn(claimsMock); + * when(claimsMock.getSubject()).thenReturn(username); + * when(claimsMock.getExpiration()).thenReturn(null); // Act boolean actualResult + * = jwtUtil.isValidToken(tokenWithoutExpiration); // Assert + * assertFalse(actualResult, + * "isValidToken should return false when Claims contains a null expiration date." + * ); + */ + } + +} \ No newline at end of file diff --git a/src/test/java/com/medeiros/SPRINGProject/Security/JwtUtilNewTokenTest.java.invalid b/src/test/java/com/medeiros/SPRINGProject/Security/JwtUtilNewTokenTest.java.invalid new file mode 100644 index 0000000..01e6505 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Security/JwtUtilNewTokenTest.java.invalid @@ -0,0 +1,124 @@ +//This test file is marked invalid as it contains compilation errors. Change the extension to of this file to .java, to manually edit its contents + + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test oct21-java using AI Type Azure Open AI and AI Model gpt-4o + +ROOST_METHOD_HASH=newToken_0b98d9bf3a +ROOST_METHOD_SIG_HASH=newToken_275af2b2e1 + + +Scenario 1: Generate a valid token when valid Authentication object is provided + +Details: + TestName: generateTokenWithValidAuthentication + Description: Verifies that a valid JWT token is generated when a proper `Authentication` object containing principal user details is provided. + +Execution: + Arrange: Mock a valid `Authentication` object containing a `User_Credentials` object with a valid username. Set up a valid `jwtSecret` and `jwtExpirationMilliseg`. + Act: Call the method `newToken` with the mocked `Authentication`. + Assert: Verify that the returned token is non-null and contains the expected details of the user. +Validation: + Confirms that the method correctly creates a JWT token embedding user authentication details, expiration time, and signing key, which aligns with security protocol expectations. + +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Security;import com.medeiros.SPRINGProject.Models.User_Credentials; +import io.jsonwebtoken.Jwts; +import io.jsonwebtoken.security.Keys; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.springframework.security.core.Authentication; +import java.nio.charset.StandardCharsets; +import java.security.Key; +import java.util.Date; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.*; +import io.jsonwebtoken.Claims; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; + +class JwtUtilNewTokenTest { + private final String jwtSecret = "dummySecretKeyForTestingPurpose123456789012"; // TODO Replace with actual key in production + private final long jwtExpirationMilliseg = 1000 * 60 * 15; // 15 minutes expiration + + // Note: Modified constructor and setup jwt secret and expiration values directly, as JwtUtil requires no-args constructor. + JwtUtil jwtUtil = new JwtUtil(); // Adapted according to the business logic method + + public JwtUtilNewTokenTest() { + jwtUtil.jwtSecret = jwtSecret; // Assigning jwtSecret directly to overcome constructor mismatch issue + jwtUtil.jwtExpirationMilliseg = jwtExpirationMilliseg; // Assigning expiration directly + } + + @Test + @Tag("valid") + public void generateTokenWithValidAuthentication() { + // Arrange + User_Credentials mockUser = Mockito.mock(User_Credentials.class); + Mockito.when(mockUser.getUsername()).thenReturn("testUser"); + + Authentication mockAuthentication = Mockito.mock(Authentication.class); + Mockito.when(mockAuthentication.getPrincipal()).thenReturn(mockUser); + // Act + String token = jwtUtil.newToken(mockAuthentication); + // Assert + assertNotNull(token, "Generated token should not be null"); + Key secretKey = Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8)); + String extractedUsername = Jwts.parserBuilder().setSigningKey(secretKey).build().parseClaimsJws(token).getBody().getSubject(); + + assertEquals("testUser", extractedUsername, "Token should contain the correct subject (username)"); + } + + @Test + @Tag("invalid") + public void generateTokenWithInvalidAuthentication() { + // Arrange + Authentication mockAuthentication = Mockito.mock(Authentication.class); + Mockito.when(mockAuthentication.getPrincipal()).thenReturn(null); + // Act + String token = jwtUtil.newToken(mockAuthentication); + // Assert + assertNull(token, "Token should be null when authentication principal is invalid"); + } + + @Test + @Tag("boundary") + public void generateTokenWithShortExpirationTime() { + // Arrange + User_Credentials mockUser = Mockito.mock(User_Credentials.class); + Mockito.when(mockUser.getUsername()).thenReturn("boundaryUser"); + + Authentication mockAuthentication = Mockito.mock(Authentication.class); + Mockito.when(mockAuthentication.getPrincipal()).thenReturn(mockUser); + // Adapted jwtUtil instance expiration time directly + jwtUtil.jwtExpirationMilliseg = 1; // 1 millisecond expiration time + // Act + String token = jwtUtil.newToken(mockAuthentication); + // Assert + assertNotNull(token, "Generated token should not be null for boundary conditions"); + Key secretKey = Keys.hmacShaKeyFor(jwtSecret.getBytes(StandardCharsets.UTF_8)); + Date expirationDate = Jwts.parserBuilder().setSigningKey(secretKey).build().parseClaimsJws(token).getBody().getExpiration(); + + assertTrue(expirationDate.before(new Date()), "Token expiration should be immediately after generation for boundary case"); + } + + @Test + @Tag("errorHandling") + public void generateTokenWithNullJwtSecret() { + // Arrange + User_Credentials mockUser = Mockito.mock(User_Credentials.class); + Mockito.when(mockUser.getUsername()).thenReturn("errorUser"); + + Authentication mockAuthentication = Mockito.mock(Authentication.class); + Mockito.when(mockAuthentication.getPrincipal()).thenReturn(mockUser); + // Note: Added comment to business logic indicating dependency on jwtSecret validation + jwtUtil.jwtSecret = null; // Passing null secret key directly since JwtUtil has no-args constructor + // Act + String token = jwtUtil.newToken(mockAuthentication); + // Assert + assertNull(token, "Token should be null when jwtSecret is null, as key generation will fail"); + } +} \ No newline at end of file