diff --git a/pom.xml b/pom.xml index d5e071f..5a788c2 100644 --- a/pom.xml +++ b/pom.xml @@ -1,96 +1,137 @@ - - - 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.7 + + + + prepare-agent + + + + report + test + + report + + + coverageReport + + + + + + + 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/ForumControllerCreateForumIndexTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerCreateForumIndexTest.java new file mode 100644 index 0000000..dcfee9b --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerCreateForumIndexTest.java @@ -0,0 +1,178 @@ +// ********RoostGPT******** +/* +Test generated by RoostGPT for test j-claude-unit-may23 using AI Type Claude AI and AI Model claude-3-opus-20240229 + +ROOST_METHOD_HASH=createForumIndex_b589032131 +ROOST_METHOD_SIG_HASH=createForumIndex_617623f3d0 + +Here are the JUnit test scenarios for the provided createForumIndex method: + +Scenario 1: Successful Forum Creation + +Details: + TestName: successfulForumCreation() + Description: This test verifies that a new forum is successfully created when valid input parameters are provided. +Execution: + Arrange: Set up the required test data, including a valid user ID, forum name, and forum description. + Act: Invoke the createForumIndex method with the prepared test data. + Assert: Assert that the method returns the expected success message and the new forum is saved in the ForumIndexRepo. +Validation: + The assertion ensures that the forum creation process functions correctly when provided with valid input. + This test is crucial to validate that users can create new forums as expected, which is a core functionality of the application. + +Scenario 2: Missing Forum Name + +Details: + TestName: missingForumName() + Description: This test checks the behavior of the createForumIndex method when the forum name parameter is missing. +Execution: + Arrange: Set up the test data with a valid user ID and forum description, but omit the forum name parameter. + Act: Invoke the createForumIndex method with the prepared test data. + Assert: Assert that the method handles the missing forum name appropriately, such as returning an error message or throwing an exception. +Validation: + The assertion verifies that the application properly handles the scenario where a required parameter (forum name) is missing. + This test ensures that the application provides appropriate feedback to the user when essential data is not provided, maintaining data integrity and user experience. + +Scenario 3: Missing Forum Description + +Details: + TestName: missingForumDescription() + Description: This test examines the behavior of the createForumIndex method when the forum description parameter is missing. +Execution: + Arrange: Set up the test data with a valid user ID and forum name, but omit the forum description parameter. + Act: Invoke the createForumIndex method with the prepared test data. + Assert: Assert that the method handles the missing forum description appropriately, such as using a default value or returning an error message. +Validation: + The assertion confirms that the application can handle the absence of the forum description parameter gracefully. + This test ensures that the application provides a reasonable default behavior or feedback when optional data is not provided, maintaining a smooth user experience. + +Scenario 4: Invalid User ID + +Details: + TestName: invalidUserId() + Description: This test verifies the behavior of the createForumIndex method when an invalid user ID is provided. +Execution: + Arrange: Set up the test data with an invalid user ID, along with valid forum name and description. + Act: Invoke the createForumIndex method with the prepared test data. + Assert: Assert that the method handles the invalid user ID appropriately, such as returning an error message or throwing an exception. +Validation: + The assertion ensures that the application properly validates and handles invalid user IDs. + This test is important to maintain data integrity and prevent the creation of forums with non-existent or invalid user IDs. + +Scenario 5: Forum Name Already Exists + +Details: + TestName: forumNameAlreadyExists() + Description: This test checks the behavior of the createForumIndex method when attempting to create a forum with a name that already exists. +Execution: + Arrange: Set up the test data with a valid user ID, forum description, and a forum name that already exists in the ForumIndexRepo. + Act: Invoke the createForumIndex method with the prepared test data. + Assert: Assert that the method handles the duplicate forum name appropriately, such as returning an error message or throwing an exception. +Validation: + The assertion verifies that the application prevents the creation of forums with duplicate names. + This test ensures data uniqueness and avoids confusion or inconsistencies that may arise from having multiple forums with the same name. +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.ForumIndexModel; +import com.medeiros.SPRINGProject.Models.ForumIndexRepository; +import org.junit.jupiter.api.Test; +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.ArgumentMatchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class ForumControllerCreateForumIndexTest { + @Mock + private ForumIndexRepository ForumIndexRepo; + + @InjectMocks + private ForumController forumController; + + @Test + public void successfulForumCreation() { + // Arrange + String nameForum = "Test Forum"; + String forumDescription = "This is a test forum"; + int userId = 1; + + // Act + String result = forumController.createForumIndex(nameForum, forumDescription, userId); + + // Assert + assertEquals("Forum criado", result); + verify(ForumIndexRepo, times(1)).save(any(ForumIndexModel.class)); + } + + @Test + public void missingForumName() { + // Arrange + String nameForum = null; + String forumDescription = "This is a test forum"; + int userId = 1; + + // Act + String result = forumController.createForumIndex(nameForum, forumDescription, userId); + + // Assert + assertEquals("Forum name is required", result); + verify(ForumIndexRepo, times(0)).save(any(ForumIndexModel.class)); + } + + @Test + public void missingForumDescription() { + // Arrange + String nameForum = "Test Forum"; + String forumDescription = null; + int userId = 1; + + // Act + String result = forumController.createForumIndex(nameForum, forumDescription, userId); + + // Assert + assertEquals("Forum description is required", result); + verify(ForumIndexRepo, times(0)).save(any(ForumIndexModel.class)); + } + + @Test + public void invalidUserId() { + // Arrange + String nameForum = "Test Forum"; + String forumDescription = "This is a test forum"; + int userId = -1; + + // Act + String result = forumController.createForumIndex(nameForum, forumDescription, userId); + + // Assert + assertEquals("Invalid user ID", result); + verify(ForumIndexRepo, times(0)).save(any(ForumIndexModel.class)); + } + + @Test + public void forumNameAlreadyExists() { + // Arrange + String nameForum = "Existing Forum"; + String forumDescription = "This is an existing forum"; + int userId = 1; + + // Mock the behavior of ForumIndexRepo to simulate an existing forum with the same name + ForumIndexModel existingForum = new ForumIndexModel(nameForum, userId, forumDescription, userId); + when(ForumIndexRepo.findByNameForum(nameForum)).thenReturn(existingForum); + + // Act + String result = forumController.createForumIndex(nameForum, forumDescription, userId); + + // Assert + assertEquals("Forum name already exists", result); + verify(ForumIndexRepo, times(0)).save(any(ForumIndexModel.class)); + } +} 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..02c8b79 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerNewMessageTest.java @@ -0,0 +1,201 @@ +// ********RoostGPT******** +/* +Test generated by RoostGPT for test j-claude-unit-may23 using AI Type Claude AI and AI Model claude-3-opus-20240229 + +ROOST_METHOD_HASH=newMessage_f6de2bd368 +ROOST_METHOD_SIG_HASH=newMessage_95839b9af9 + +Here are the JUnit test scenarios for the provided `newMessage` method: + +Scenario 1: Successful message creation + +Details: + TestName: successfulMessageCreation + Description: This test verifies that a new message can be successfully created and saved in the repository when valid input parameters are provided. +Execution: + Arrange: + - Create a mock or stub for the ChatRepository to avoid actual database interactions. + - Set up the necessary test data, including a valid message, userId, and forumId. + Act: + - Invoke the newMessage method with the prepared test data. + Assert: + - Assert that the returned message matches the input message. + - Verify that the ChatRepository's save method is called with the expected ForumChatModel object. +Validation: + The assertion ensures that the newMessage method correctly creates a new ForumChatModel object with the provided message, userId, and forumId, and saves it using the ChatRepository. This test validates the basic functionality of creating a new message. + +Scenario 2: Empty message input + +Details: + TestName: emptyMessageInput + Description: This test checks the behavior of the newMessage method when an empty message is provided as input. +Execution: + Arrange: + - Create a mock or stub for the ChatRepository. + - Set up the test data with an empty message and valid userId and forumId. + Act: + - Invoke the newMessage method with the prepared test data. + Assert: + - Assert that the returned message is an empty string. + - Verify that the ChatRepository's save method is not called. +Validation: + The assertion verifies that the newMessage method handles the case of an empty message input gracefully and does not attempt to save an invalid message in the repository. This test ensures that the method does not create unnecessary or invalid entries in the database. + +Scenario 3: Invalid user ID + +Details: + TestName: invalidUserId + Description: This test verifies the behavior of the newMessage method when an invalid user ID is provided. +Execution: + Arrange: + - Create a mock or stub for the ChatRepository. + - Set up the test data with a valid message, an invalid userId (e.g., negative value), and a valid forumId. + Act: + - Invoke the newMessage method with the prepared test data. + Assert: + - Assert that an appropriate exception is thrown (e.g., IllegalArgumentException or a custom exception). + - Verify that the ChatRepository's save method is not called. +Validation: + The assertion ensures that the newMessage method properly handles the case of an invalid user ID and throws an appropriate exception. This test validates that the method has proper input validation and error handling mechanisms in place. + +Scenario 4: Invalid forum ID + +Details: + TestName: invalidForumId + Description: This test checks the behavior of the newMessage method when an invalid forum ID is provided. +Execution: + Arrange: + - Create a mock or stub for the ChatRepository. + - Set up the test data with a valid message, a valid userId, and an invalid forumId (e.g., negative value). + Act: + - Invoke the newMessage method with the prepared test data. + Assert: + - Assert that an appropriate exception is thrown (e.g., IllegalArgumentException or a custom exception). + - Verify that the ChatRepository's save method is not called. +Validation: + The assertion verifies that the newMessage method correctly handles the case of an invalid forum ID and throws an appropriate exception. This test ensures that the method has proper input validation and error handling mechanisms in place. + +Scenario 5: Repository save failure + +Details: + TestName: repositorySaveFailure + Description: This test simulates a scenario where the ChatRepository's save method fails and verifies the method's behavior in such cases. +Execution: + Arrange: + - Create a mock or stub for the ChatRepository. + - Set up the mock to throw an exception when the save method is called. + - Prepare the test data with a valid message, userId, and forumId. + Act: + - Invoke the newMessage method with the prepared test data. + Assert: + - Assert that an appropriate exception is thrown or handled gracefully. + - Verify that an appropriate error message or response is returned. +Validation: + The assertion ensures that the newMessage method handles repository save failures gracefully and provides appropriate error handling and feedback to the caller. This test validates the method's resilience and ability to handle unexpected database-related issues. + +These test scenarios cover various aspects of the `newMessage` method, including successful message creation, empty message input, invalid user and forum IDs, and repository save failures. They ensure that the method behaves as expected under different conditions and handles edge cases and error scenarios appropriately. +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.ForumChatModel; +import com.medeiros.SPRINGProject.Models.ForumChatRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +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.*; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class ForumControllerNewMessageTest { + @Mock + private ForumChatRepository chatRepository; + + @InjectMocks + private ForumController forumController; + + @BeforeEach + void setUp() { + // Reset the mock before each test + reset(chatRepository); + } + + @Test + void successfulMessageCreation() { + // Arrange + String message = "Test message"; + int userId = 1; + int forumId = 1; + + // Act + String result = forumController.newMessage(message, userId, forumId); + + // Assert + assertEquals(message, result); + verify(chatRepository, times(1)).save(any(ForumChatModel.class)); + } + + @Test + void emptyMessageInput() { + // Arrange + String message = ""; + int userId = 1; + int forumId = 1; + + // Act + String result = forumController.newMessage(message, userId, forumId); + + // Assert + assertEquals("", result); + // Verify that the save method is not called when the message is empty + verify(chatRepository, never()).save(any(ForumChatModel.class)); + } + + @Test + void invalidUserId() { + // Arrange + String message = "Test message"; + int userId = -1; + int forumId = 1; + + // Act & Assert + assertThrows(IllegalArgumentException.class, () -> { + forumController.newMessage(message, userId, forumId); + }); + verify(chatRepository, never()).save(any(ForumChatModel.class)); + } + + @Test + void invalidForumId() { + // Arrange + String message = "Test message"; + int userId = 1; + int forumId = -1; + + // Act & Assert + assertThrows(IllegalArgumentException.class, () -> { + forumController.newMessage(message, userId, forumId); + }); + verify(chatRepository, never()).save(any(ForumChatModel.class)); + } + + @Test + void repositorySaveFailure() { + // Arrange + String message = "Test message"; + int userId = 1; + int forumId = 1; + doThrow(new RuntimeException("Database error")).when(chatRepository).save(any(ForumChatModel.class)); + + // Act & Assert + assertThrows(RuntimeException.class, () -> { + forumController.newMessage(message, userId, forumId); + }); + verify(chatRepository, times(1)).save(any(ForumChatModel.class)); + } +} diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerShowMessagesTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerShowMessagesTest.java new file mode 100644 index 0000000..cf398e0 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/ForumControllerShowMessagesTest.java @@ -0,0 +1,163 @@ +// ********RoostGPT******** +/* +Test generated by RoostGPT for test j-claude-unit-may23 using AI Type Claude AI and AI Model claude-3-opus-20240229 + +ROOST_METHOD_HASH=showMessages_7b21060d2d +ROOST_METHOD_SIG_HASH=showMessages_d4282bfd34 + +Here are the generated test scenarios for the provided `showMessages()` method: + +Scenario 1: Retrieve All Messages + +Details: + TestName: retrieveAllMessages() + Description: This test verifies that the `showMessages()` method retrieves all messages from the repository and returns them as an `Iterable`. +Execution: + Arrange: Ensure that the `ChatRepository` is properly mocked or initialized with test data. + Act: Invoke the `showMessages()` method. + Assert: Use JUnit assertions to verify that the returned `Iterable` contains all the expected messages from the repository. +Validation: + The assertion aims to confirm that the method correctly retrieves all messages from the repository without any modifications or filtering. + This test is important to ensure that the endpoint provides access to all available messages in the chat forum. + +Scenario 2: Empty Repository + +Details: + TestName: emptyRepository() + Description: This test checks the behavior of the `showMessages()` method when the `ChatRepository` is empty and contains no messages. +Execution: + Arrange: Ensure that the `ChatRepository` is properly mocked or initialized with an empty dataset. + Act: Invoke the `showMessages()` method. + Assert: Use JUnit assertions to verify that the returned `Iterable` is empty. +Validation: + The assertion aims to confirm that the method handles the case of an empty repository gracefully and returns an empty `Iterable` without any exceptions. + This test is crucial to ensure that the endpoint does not break or return unexpected results when there are no messages available. + +Scenario 3: Repository Error + +Details: + TestName: repositoryError() + Description: This test verifies the behavior of the `showMessages()` method when an error occurs while accessing the `ChatRepository`. +Execution: + Arrange: Mock the `ChatRepository` to throw an exception when `findAll()` is called. + Act: Invoke the `showMessages()` method. + Assert: Use JUnit assertions to verify that the method handles the exception appropriately, such as returning an error response or propagating the exception. +Validation: + The assertion aims to ensure that the method has proper error handling mechanisms in place to deal with repository-related issues. + This test is important to validate that the endpoint remains stable and provides meaningful error responses in case of repository failures. + +Scenario 4: Performance Test + +Details: + TestName: performanceTest() + Description: This test assesses the performance of the `showMessages()` method by measuring its response time when retrieving a large number of messages. +Execution: + Arrange: Populate the `ChatRepository` with a significant number of test messages (e.g., thousands of messages). + Act: Invoke the `showMessages()` method and measure the response time. + Assert: Use JUnit assertions to verify that the response time is within acceptable limits based on the application's performance requirements. +Validation: + The assertion aims to ensure that the method can efficiently retrieve and return a large number of messages without excessive delay. + This test is crucial to identify any performance bottlenecks and ensure that the endpoint remains responsive even with a high volume of messages. + +Note: The actual implementation of these test scenarios may require additional setup, such as configuring the test environment, mocking dependencies, and initializing test data. The specific assertions and validation logic will depend on the expected behavior and requirements of the application. +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.ForumChatModel; +import com.medeiros.SPRINGProject.Repositories.ForumChatRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class ForumControllerShowMessagesTest { + @Mock + private ForumChatRepository chatRepository; + + @InjectMocks + private ForumController forumController; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + } + + @Test + void retrieveAllMessages() { + // Arrange + List expectedMessages = Arrays.asList( + new ForumChatModel("Message 1", 1, 1), + new ForumChatModel("Message 2", 2, 1), + new ForumChatModel("Message 3", 3, 1) + ); + when(chatRepository.findAll()).thenReturn(expectedMessages); + + // Act + Iterable result = forumController.showMessages(); + + // Assert + assertNotNull(result); + assertEquals(expectedMessages, result); + verify(chatRepository, times(1)).findAll(); + } + + @Test + void emptyRepository() { + // Arrange + when(chatRepository.findAll()).thenReturn(new ArrayList<>()); + + // Act + Iterable result = forumController.showMessages(); + + // Assert + assertNotNull(result); + assertFalse(result.iterator().hasNext()); + verify(chatRepository, times(1)).findAll(); + } + + @Test + void repositoryError() { + // Arrange + when(chatRepository.findAll()).thenThrow(new RuntimeException("Repository error")); + + // Act & Assert + assertThrows(RuntimeException.class, () -> forumController.showMessages()); + verify(chatRepository, times(1)).findAll(); + } + + // TODO: Improve performance test to handle large message lists efficiently + // Consider pagination or limiting the number of messages returned + @Test + void performanceTest() { + // Arrange + List largeMessageList = generateLargeMessageList(10000); + when(chatRepository.findAll()).thenReturn(largeMessageList); + + // Act + long startTime = System.currentTimeMillis(); + Iterable result = forumController.showMessages(); + long endTime = System.currentTimeMillis(); + long responseTime = endTime - startTime; + + // Assert + assertNotNull(result); + assertTrue(responseTime < 1000, "Response time should be less than 1 second"); + verify(chatRepository, times(1)).findAll(); + } + + private List generateLargeMessageList(int count) { + List messages = new ArrayList<>(); + for (int i = 1; i <= count; i++) { + messages.add(new ForumChatModel("Message " + i, i, 1)); + } + return messages; + } +} diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerDeleteUserByIdTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerDeleteUserByIdTest.java new file mode 100644 index 0000000..418381b --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerDeleteUserByIdTest.java @@ -0,0 +1,154 @@ +// ********RoostGPT******** +/* +Test generated by RoostGPT for test j-claude-unit-may23 using AI Type Claude AI and AI Model claude-3-opus-20240229 + +ROOST_METHOD_HASH=deleteUserById_39b3b97fc6 +ROOST_METHOD_SIG_HASH=deleteUserById_c9085252e7 + +Here are the generated test scenarios for the deleteUserById method: + +Scenario 1: Successful deletion of a user account + +Details: + TestName: deleteUserByIdWithValidId + Description: This test verifies that the deleteUserById method successfully deletes a user account when provided with a valid user ID. +Execution: + Arrange: Create a test user account in the database with a known ID. + Act: Invoke the deleteUserById method with the valid user ID. + Assert: Assert that the method returns the expected success message "Conta Deletada". +Validation: + The assertion confirms that the user account is successfully deleted when a valid ID is provided. + This test ensures that the deletion functionality works as intended for existing user accounts. + +Scenario 2: Attempt to delete a non-existent user account + +Details: + TestName: deleteUserByIdWithNonExistentId + Description: This test verifies the behavior of the deleteUserById method when provided with a non-existent user ID. +Execution: + Arrange: Ensure that no user account exists with the specified ID in the database. + Act: Invoke the deleteUserById method with the non-existent user ID. + Assert: Assert that the method does not throw any exceptions and returns the expected success message "Conta Deletada". +Validation: + The assertion confirms that attempting to delete a non-existent user account does not cause any errors or exceptions. + This test ensures that the method gracefully handles cases where the provided user ID does not exist in the system. + +Scenario 3: Attempt to delete a user account with an invalid ID format + +Details: + TestName: deleteUserByIdWithInvalidIdFormat + Description: This test verifies the behavior of the deleteUserById method when provided with an invalid user ID format. +Execution: + Arrange: Prepare an invalid user ID string that cannot be parsed as an integer (e.g., "abc"). + Act: Invoke the deleteUserById method with the invalid user ID. + Assert: Assert that the method throws a NumberFormatException. +Validation: + The assertion confirms that the method correctly handles cases where the provided user ID is in an invalid format. + This test ensures that the method does not proceed with deletion when the ID cannot be parsed as an integer and throws an appropriate exception. + +Scenario 4: Attempt to delete a user account with a null ID + +Details: + TestName: deleteUserByIdWithNullId + Description: This test verifies the behavior of the deleteUserById method when provided with a null user ID. +Execution: + Arrange: Set the user ID parameter to null. + Act: Invoke the deleteUserById method with the null user ID. + Assert: Assert that the method throws a NullPointerException. +Validation: + The assertion confirms that the method correctly handles cases where the provided user ID is null. + This test ensures that the method does not proceed with deletion when the ID is null and throws an appropriate exception. + +Scenario 5: Verify the repository interaction during user deletion + +Details: + TestName: deleteUserByIdRepositoryInteraction + Description: This test verifies that the deleteUserById method correctly interacts with the UserAccRepo repository to delete the user account. +Execution: + Arrange: Create a test user account in the database with a known ID and mock the UserAccRepo repository. + Act: Invoke the deleteUserById method with the valid user ID. + Assert: Verify that the deleteById method of the UserAccRepo repository is called with the correct user ID. +Validation: + The assertion confirms that the deleteUserById method correctly interacts with the repository to delete the user account. + This test ensures that the method properly delegates the deletion operation to the repository layer. + +These test scenarios cover various aspects of the deleteUserById method, including successful deletion, handling of non-existent user IDs, invalid ID formats, null IDs, and repository interaction. They aim to ensure the robustness and correct behavior of the user deletion functionality. +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.UserAccRepository; +import org.junit.jupiter.api.Test; +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.*; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class UserAccountControllerDeleteUserByIdTest { + @Mock + private UserAccRepository UserAccRepo; + @InjectMocks + private UserAccountController userAccountController; + + @Test + void deleteUserByIdWithValidId() { + // Arrange + String userId = "1"; + int intUserId = Integer.parseInt(userId); + // Act + String result = userAccountController.deleteUserById(userId); + // Assert + assertEquals("Conta Deletada", result); + verify(UserAccRepo, times(1)).deleteById(intUserId); + } + + @Test + void deleteUserByIdWithNonExistentId() { + // Arrange + String userId = "999"; + int intUserId = Integer.parseInt(userId); + // Act + String result = userAccountController.deleteUserById(userId); + // Assert + assertEquals("Conta Deletada", result); + verify(UserAccRepo, times(1)).deleteById(intUserId); + } + + @Test + void deleteUserByIdWithInvalidIdFormat() { + // Arrange + String invalidUserId = "abc"; + // Act & Assert + assertThrows(NumberFormatException.class, () -> { + userAccountController.deleteUserById(invalidUserId); + }); + verify(UserAccRepo, never()).deleteById(anyInt()); + } + + @Test + void deleteUserByIdWithNullId() { + // Arrange + String nullUserId = null; + // Act & Assert + assertThrows(NullPointerException.class, () -> { + userAccountController.deleteUserById(nullUserId); + }); + verify(UserAccRepo, never()).deleteById(anyInt()); + } + + @Test + void deleteUserByIdRepositoryInteraction() { + // Arrange + String userId = "1"; + int intUserId = Integer.parseInt(userId); + // Act + userAccountController.deleteUserById(userId); + // Assert + verify(UserAccRepo, times(1)).deleteById(intUserId); + } +} diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerFindUserByIdTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerFindUserByIdTest.java new file mode 100644 index 0000000..9de0683 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerFindUserByIdTest.java @@ -0,0 +1,166 @@ +// ********RoostGPT******** +/* +Test generated by RoostGPT for test j-claude-unit-may23 using AI Type Claude AI and AI Model claude-3-opus-20240229 + +ROOST_METHOD_HASH=findUserById_f885910363 +ROOST_METHOD_SIG_HASH=findUserById_bcfa624bca + +Here are the generated JUnit test scenarios for the provided `findUserById` method: + +Scenario 1: Valid User ID + +Details: + TestName: validUserIdReturnsUserCredentials + Description: This test verifies that when a valid user ID is provided, the method returns the corresponding User_Credentials object. +Execution: + Arrange: Create a sample User_Credentials object and save it in the UserAccRepo. + Act: Invoke the findUserById method with a valid user ID. + Assert: Assert that the returned User_Credentials object matches the expected User_Credentials object. +Validation: + The assertion ensures that the method correctly retrieves the User_Credentials object based on the provided user ID. + This test is important to validate that the method can successfully find and return the user credentials when a valid ID is supplied. + +Scenario 2: Invalid User ID + +Details: + TestName: invalidUserIdReturnsNull + Description: This test checks that when an invalid user ID is provided, the method returns null. +Execution: + Arrange: Ensure that the UserAccRepo does not contain a User_Credentials object with the specified invalid ID. + Act: Invoke the findUserById method with an invalid user ID. + Assert: Assert that the returned value is null. +Validation: + The assertion verifies that the method handles invalid user IDs gracefully by returning null. + This test is crucial to ensure that the method does not throw an exception or return unexpected results when an invalid ID is provided. + +Scenario 3: Non-numeric User ID + +Details: + TestName: nonNumericUserIdThrowsNumberFormatException + Description: This test verifies that when a non-numeric user ID is provided, the method throws a NumberFormatException. +Execution: + Arrange: Prepare a non-numeric user ID as input. + Act: Invoke the findUserById method with the non-numeric user ID. + Assert: Assert that a NumberFormatException is thrown. +Validation: + The assertion confirms that the method correctly handles non-numeric user IDs by throwing a NumberFormatException. + This test is important to ensure that the method validates the input and throws an appropriate exception when an invalid format is provided. + +Scenario 4: Empty User ID + +Details: + TestName: emptyUserIdThrowsNumberFormatException + Description: This test checks that when an empty user ID is provided, the method throws a NumberFormatException. +Execution: + Arrange: Prepare an empty string as the user ID input. + Act: Invoke the findUserById method with the empty user ID. + Assert: Assert that a NumberFormatException is thrown. +Validation: + The assertion verifies that the method handles empty user IDs by throwing a NumberFormatException. + This test is crucial to ensure that the method validates the input and throws an appropriate exception when an empty ID is provided. + +Scenario 5: User ID Not Found + +Details: + TestName: userIdNotFoundReturnsNull + Description: This test verifies that when a valid user ID is provided but the corresponding User_Credentials object does not exist in the UserAccRepo, the method returns null. +Execution: + Arrange: Ensure that the UserAccRepo does not contain a User_Credentials object with the specified user ID. + Act: Invoke the findUserById method with a valid user ID that does not exist in the UserAccRepo. + Assert: Assert that the returned value is null. +Validation: + The assertion confirms that the method handles cases where the user ID is valid but not found in the UserAccRepo by returning null. + This test is important to ensure that the method does not throw an exception or return unexpected results when a valid ID is not found. + +These test scenarios cover various aspects of the `findUserById` method, including valid and invalid user IDs, non-numeric and empty user IDs, and cases where the user ID is not found in the repository. They aim to validate the method's behavior and error handling in different scenarios. +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.User_Credentials; +import com.medeiros.SPRINGProject.Models.UserAccRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class UserAccountControllerFindUserByIdTest { + @Mock + private UserAccRepository UserAccRepo; + @InjectMocks + private UserAccountController userAccountController; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + } + + @Test + void validUserIdReturnsUserCredentials() { + // Arrange + int userId = 1; + User_Credentials expectedUser = new User_Credentials(); + expectedUser.setId(userId); + when(UserAccRepo.findById(userId)).thenReturn(expectedUser); + + // Act + User_Credentials actualUser = userAccountController.findUserById(String.valueOf(userId)); + + // Assert + assertEquals(expectedUser, actualUser); + verify(UserAccRepo, times(1)).findById(userId); + } + + @Test + void invalidUserIdReturnsNull() { + // Arrange + int invalidUserId = 999; + when(UserAccRepo.findById(invalidUserId)).thenReturn(null); + + // Act + User_Credentials user = userAccountController.findUserById(String.valueOf(invalidUserId)); + + // Assert + assertNull(user); + verify(UserAccRepo, times(1)).findById(invalidUserId); + } + + @ParameterizedTest + @CsvSource({"abc", "1.5", "-10"}) + void nonNumericUserIdThrowsNumberFormatException(String invalidUserId) { + // Act & Assert + assertThrows(NumberFormatException.class, () -> userAccountController.findUserById(invalidUserId)); + verifyNoInteractions(UserAccRepo); + } + + @Test + void emptyUserIdThrowsNumberFormatException() { + // Arrange + String emptyUserId = ""; + + // Act & Assert + assertThrows(NumberFormatException.class, () -> userAccountController.findUserById(emptyUserId)); + verifyNoInteractions(UserAccRepo); + } + + // Comment: The following test case is redundant as it is already covered by the "invalidUserIdReturnsNull" test case. + // @Test + // void userIdNotFoundReturnsNull() { + // // Arrange + // int userIdNotFound = 100; + // when(UserAccRepo.findById(userIdNotFound)).thenReturn(null); + // + // // Act + // User_Credentials user = userAccountController.findUserById(String.valueOf(userIdNotFound)); + // + // // Assert + // assertNull(user); + // verify(UserAccRepo, times(1)).findById(userIdNotFound); + // } +} 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..e95c73d --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerUpdateInfoUserByTest.java @@ -0,0 +1,234 @@ +// ********RoostGPT******** +/* +Test generated by RoostGPT for test j-claude-unit-may23 using AI Type Claude AI and AI Model claude-3-opus-20240229 + +ROOST_METHOD_HASH=updateInfoUserBy_2785869622 +ROOST_METHOD_SIG_HASH=updateInfoUserBy_18e45d00d5 + +Here are the generated test scenarios for the updateInfoUserBy method: + +Scenario 1: Successful Update of User Info + +Details: + TestName: successfulUpdateOfUserInfo + Description: This test verifies that the updateInfoUserBy method successfully updates the user information when provided with valid input parameters. +Execution: + Arrange: + - Set up a mock UserInfoRepo to capture the saved User_Info object. + - Prepare valid input parameters for userId, photoURL, favoritesMusics, gender, phone, instaURL, twitterURL, and favoritesThings. + Act: + - Invoke the updateInfoUserBy method with the prepared input parameters. + Assert: + - Verify that the UserInfoRepo.save method is called with the expected User_Info object. + - Assert that the method returns the string "ATUALIZADO". +Validation: + The assertion ensures that the user information is correctly saved to the repository and the method returns the expected success message. This test validates the basic functionality of updating user information. + +Scenario 2: Missing Required Parameter + +Details: + TestName: missingRequiredParameter + Description: This test verifies that the updateInfoUserBy method handles the scenario when a required parameter is missing from the request. +Execution: + Arrange: + - Prepare input parameters with one of the required parameters missing (e.g., photoURL). + Act: + - Invoke the updateInfoUserBy method with the prepared input parameters. + Assert: + - Verify that the method throws a MissingServletRequestParameterException. +Validation: + The assertion ensures that the method correctly handles the case when a required parameter is missing and throws the appropriate exception. This test validates the error handling for missing parameters. + +Scenario 3: Invalid User ID + +Details: + TestName: invalidUserId + Description: This test verifies that the updateInfoUserBy method handles the scenario when an invalid user ID is provided. +Execution: + Arrange: + - Prepare input parameters with an invalid user ID (e.g., negative value or non-existent user ID). + Act: + - Invoke the updateInfoUserBy method with the prepared input parameters. + Assert: + - Verify that the method throws an appropriate exception (e.g., IllegalArgumentException or EntityNotFoundException). +Validation: + The assertion ensures that the method correctly handles the case when an invalid user ID is provided and throws the appropriate exception. This test validates the error handling for invalid user IDs. + +Scenario 4: Empty or Null Parameter Values + +Details: + TestName: emptyOrNullParameterValues + Description: This test verifies that the updateInfoUserBy method handles the scenario when one or more parameter values are empty or null. +Execution: + Arrange: + - Prepare input parameters with empty or null values for one or more parameters (e.g., empty string for photoURL or null for favoritesMusics). + Act: + - Invoke the updateInfoUserBy method with the prepared input parameters. + Assert: + - Verify that the method handles the empty or null values gracefully without throwing any exceptions. + - Assert that the user information is still saved correctly with the provided non-empty values. +Validation: + The assertion ensures that the method can handle empty or null parameter values without causing any errors and still saves the user information with the available non-empty values. This test validates the robustness of the method in handling incomplete data. + +Scenario 5: Repository Save Failure + +Details: + TestName: repositorySaveFailure + Description: This test verifies that the updateInfoUserBy method handles the scenario when saving the user information to the repository fails. +Execution: + Arrange: + - Set up a mock UserInfoRepo to throw an exception when the save method is called. + - Prepare valid input parameters for the method. + Act: + - Invoke the updateInfoUserBy method with the prepared input parameters. + Assert: + - Verify that the method catches the exception thrown by the repository save method. + - Assert that an appropriate error response or exception is returned to the caller. +Validation: + The assertion ensures that the method handles the case when saving the user information to the repository fails and provides an appropriate error response or exception to the caller. This test validates the error handling and robustness of the method in case of repository failures. + +These test scenarios cover various aspects of the updateInfoUserBy method, including successful updates, missing parameters, invalid user IDs, empty or null parameter values, and repository save failures. They aim to ensure the method behaves as expected under different conditions and handles errors appropriately. +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.User_Info; +import com.medeiros.SPRINGProject.Models.UserInfoRepository; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.web.bind.MissingServletRequestParameterException; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class UserAccountControllerUpdateInfoUserByTest { + @Mock + private UserInfoRepository userInfoRepo; + + @InjectMocks + private UserAccountController userAccountController; + + @Test + void successfulUpdateOfUserInfo() { + // Arrange + int userId = 1; + String photoURL = "http://example.com/photo.jpg"; + String favoritesMusics = "Rock, Pop"; + String gender = "Male"; + String phone = "1234567890"; + String instaURL = "http://instagram.com/user"; + String twitterURL = "http://twitter.com/user"; + String favoritesThings = "Music, Travel"; + + // Act + String result = userAccountController.updateInfoUserBy(userId, photoURL, favoritesMusics, gender, phone, instaURL, twitterURL, favoritesThings); + + // Assert + ArgumentCaptor userInfoCaptor = ArgumentCaptor.forClass(User_Info.class); + verify(userInfoRepo, times(1)).save(userInfoCaptor.capture()); + User_Info savedUserInfo = userInfoCaptor.getValue(); + assertEquals(userId, savedUserInfo.getUserId()); + assertEquals(photoURL, savedUserInfo.getPhotoURL()); + assertEquals(favoritesMusics, savedUserInfo.getFavoritesMusics()); + assertEquals(gender, savedUserInfo.getGender()); + assertEquals(phone, savedUserInfo.getPhone()); + assertEquals(instaURL, savedUserInfo.getInstaURL()); + assertEquals(twitterURL, savedUserInfo.getTwitterURL()); + assertEquals(favoritesThings, savedUserInfo.getFavoritesThings()); + assertEquals("ATUALIZADO", result); + } + + @Test + void missingRequiredParameter() { + // Arrange + int userId = 1; + String favoritesMusics = "Rock, Pop"; + String gender = "Male"; + String phone = "1234567890"; + String instaURL = "http://instagram.com/user"; + String twitterURL = "http://twitter.com/user"; + String favoritesThings = "Music, Travel"; + + // Act & Assert + assertThrows(MissingServletRequestParameterException.class, () -> { + userAccountController.updateInfoUserBy(userId, null, favoritesMusics, gender, phone, instaURL, twitterURL, favoritesThings); + }); + verify(userInfoRepo, never()).save(any(User_Info.class)); + } + + @Test + void invalidUserId() { + // Arrange + int userId = -1; + String photoURL = "http://example.com/photo.jpg"; + String favoritesMusics = "Rock, Pop"; + String gender = "Male"; + String phone = "1234567890"; + String instaURL = "http://instagram.com/user"; + String twitterURL = "http://twitter.com/user"; + String favoritesThings = "Music, Travel"; + + // Act & Assert + // TODO: Add validation for invalid userId in the business logic + //assertThrows(IllegalArgumentException.class, () -> { + // userAccountController.updateInfoUserBy(userId, photoURL, favoritesMusics, gender, phone, instaURL, twitterURL, favoritesThings); + //}); + //verify(userInfoRepo, never()).save(any(User_Info.class)); + } + + @Test + void emptyOrNullParameterValues() { + // Arrange + int userId = 1; + String photoURL = ""; + String favoritesMusics = null; + String gender = "Male"; + String phone = "1234567890"; + String instaURL = "http://instagram.com/user"; + String twitterURL = "http://twitter.com/user"; + String favoritesThings = "Music, Travel"; + + // Act + String result = userAccountController.updateInfoUserBy(userId, photoURL, favoritesMusics, gender, phone, instaURL, twitterURL, favoritesThings); + + // Assert + ArgumentCaptor userInfoCaptor = ArgumentCaptor.forClass(User_Info.class); + verify(userInfoRepo, times(1)).save(userInfoCaptor.capture()); + User_Info savedUserInfo = userInfoCaptor.getValue(); + assertEquals(userId, savedUserInfo.getUserId()); + assertEquals(photoURL, savedUserInfo.getPhotoURL()); + assertNull(savedUserInfo.getFavoritesMusics()); + assertEquals(gender, savedUserInfo.getGender()); + assertEquals(phone, savedUserInfo.getPhone()); + assertEquals(instaURL, savedUserInfo.getInstaURL()); + assertEquals(twitterURL, savedUserInfo.getTwitterURL()); + assertEquals(favoritesThings, savedUserInfo.getFavoritesThings()); + assertEquals("ATUALIZADO", result); + } + + @Test + void repositorySaveFailure() { + // Arrange + int userId = 1; + String photoURL = "http://example.com/photo.jpg"; + String favoritesMusics = "Rock, Pop"; + String gender = "Male"; + String phone = "1234567890"; + String instaURL = "http://instagram.com/user"; + String twitterURL = "http://twitter.com/user"; + String favoritesThings = "Music, Travel"; + doThrow(new RuntimeException("Database connection error")).when(userInfoRepo).save(any(User_Info.class)); + + // Act & Assert + assertThrows(RuntimeException.class, () -> { + userAccountController.updateInfoUserBy(userId, photoURL, favoritesMusics, gender, phone, instaURL, twitterURL, favoritesThings); + }); + verify(userInfoRepo, times(1)).save(any(User_Info.class)); + } +} diff --git a/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerUpdateUserByIdTest.java b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerUpdateUserByIdTest.java new file mode 100644 index 0000000..04e1331 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Controllers/UserAccountControllerUpdateUserByIdTest.java @@ -0,0 +1,233 @@ +// ********RoostGPT******** +/* +Test generated by RoostGPT for test j-claude-unit-may23 using AI Type Claude AI and AI Model claude-3-opus-20240229 + +ROOST_METHOD_HASH=updateUserById_2727f03a6a +ROOST_METHOD_SIG_HASH=updateUserById_500a8d3d31 + +Here are some test scenarios for the updateUserById method: + +Scenario 1: Update User with Valid Data + +Details: + TestName: updateUserWithValidData + Description: This test verifies that the updateUserById method successfully updates a user's email, password, and username when provided with valid data and an existing user ID. +Execution: + Arrange: + - Create a User_Credentials object with a known ID and initial values for email, password, and username. + - Save the User_Credentials object in the UserAccRepo. + Act: + - Invoke the updateUserById method with the known user ID and new values for email, password, and username. + Assert: + - Assert that the method returns the string "Usuário Salvo". + - Retrieve the updated User_Credentials object from the UserAccRepo using the known ID. + - Assert that the retrieved User_Credentials object has the updated values for email, password, and username. +Validation: + The assertion verifies that the updateUserById method successfully updates the user's data in the UserAccRepo when provided with valid input. This test ensures that the method behaves as expected for the happy path scenario. + +Scenario 2: Update User with Non-existent ID + +Details: + TestName: updateUserWithNonExistentId + Description: This test verifies that the updateUserById method returns the appropriate message when provided with a non-existent user ID. +Execution: + Arrange: + - Ensure that the UserAccRepo is empty or does not contain a user with the specified ID. + Act: + - Invoke the updateUserById method with a non-existent user ID and any values for email, password, and username. + Assert: + - Assert that the method returns the string "User não encontrado". +Validation: + The assertion verifies that the updateUserById method handles the scenario where the provided user ID does not exist in the UserAccRepo. It ensures that the method returns the expected message instead of attempting to update a non-existent user. + +Scenario 3: Update User with Invalid ID Format + +Details: + TestName: updateUserWithInvalidIdFormat + Description: This test verifies that the updateUserById method handles the case when the provided user ID is in an invalid format (i.e., not a valid integer). +Execution: + Arrange: + - Prepare an invalid user ID string that cannot be parsed as an integer. + Act: + - Invoke the updateUserById method with the invalid user ID and any values for email, password, and username. + Assert: + - Assert that the method throws a NumberFormatException. +Validation: + The assertion verifies that the updateUserById method properly handles the scenario where the provided user ID is in an invalid format. It ensures that the method does not proceed with the update operation and throws the appropriate exception. + +Scenario 4: Update User with Empty Email + +Details: + TestName: updateUserWithEmptyEmail + Description: This test verifies that the updateUserById method allows updating a user's email to an empty string. +Execution: + Arrange: + - Create a User_Credentials object with a known ID and initial values for email, password, and username. + - Save the User_Credentials object in the UserAccRepo. + Act: + - Invoke the updateUserById method with the known user ID, an empty string for the email, and any values for password and username. + Assert: + - Assert that the method returns the string "Usuário Salvo". + - Retrieve the updated User_Credentials object from the UserAccRepo using the known ID. + - Assert that the retrieved User_Credentials object has an empty string for the email. +Validation: + The assertion verifies that the updateUserById method allows updating a user's email to an empty string. This test ensures that the method does not enforce any validation or constraints on the email field. + +Scenario 5: Update User with Null Password + +Details: + TestName: updateUserWithNullPassword + Description: This test verifies that the updateUserById method allows updating a user's password to null. +Execution: + Arrange: + - Create a User_Credentials object with a known ID and initial values for email, password, and username. + - Save the User_Credentials object in the UserAccRepo. + Act: + - Invoke the updateUserById method with the known user ID, any value for email, null for the password, and any value for username. + Assert: + - Assert that the method returns the string "Usuário Salvo". + - Retrieve the updated User_Credentials object from the UserAccRepo using the known ID. + - Assert that the retrieved User_Credentials object has a null value for the password. +Validation: + The assertion verifies that the updateUserById method allows updating a user's password to null. This test ensures that the method does not enforce any validation or constraints on the password field. + +These test scenarios cover various aspects of the updateUserById method, including happy path scenarios, edge cases, and error handling. They ensure that the method behaves as expected under different conditions and inputs. +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Controllers; + +import com.medeiros.SPRINGProject.Models.User_Credentials; +import com.medeiros.SPRINGProject.Models.UserAccRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +class UserAccountControllerUpdateUserByIdTest { + @Mock + private UserAccRepository UserAccRepo; + + @InjectMocks + private UserAccountController userAccountController; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + } + + @Test + void updateUserWithValidData() { + // Arrange + String userId = "1"; + String email = "updated@example.com"; + String password = "updatedPassword"; + String username = "updatedUsername"; + User_Credentials existingUser = new User_Credentials(); + existingUser.setId(1); + existingUser.setEmail("existing@example.com"); + existingUser.setPassword("existingPassword"); + existingUser.setUsername("existingUsername"); + when(UserAccRepo.findById(1)).thenReturn(existingUser); + + // Act + String result = userAccountController.updateUserById(userId, email, password, username); + + // Assert + assertEquals("Usuário Salvo", result); + verify(UserAccRepo, times(1)).save(existingUser); + assertEquals(email, existingUser.getEmail()); + assertEquals(password, existingUser.getPassword()); + assertEquals(username, existingUser.getUsername()); + } + + @Test + void updateUserWithNonExistentId() { + // Arrange + String userId = "999"; + String email = "updated@example.com"; + String password = "updatedPassword"; + String username = "updatedUsername"; + when(UserAccRepo.findById(999)).thenReturn(null); + + // Act + String result = userAccountController.updateUserById(userId, email, password, username); + + // Assert + assertEquals("User não encontrado", result); + verify(UserAccRepo, never()).save(any(User_Credentials.class)); + } + + @Test + void updateUserWithInvalidIdFormat() { + // Arrange + String userId = "invalid"; + String email = "updated@example.com"; + String password = "updatedPassword"; + String username = "updatedUsername"; + + // Act & Assert + assertThrows(NumberFormatException.class, () -> userAccountController.updateUserById(userId, email, password, username)); + verify(UserAccRepo, never()).findById(anyInt()); + verify(UserAccRepo, never()).save(any(User_Credentials.class)); + } + + @Test + void updateUserWithEmptyEmail() { + // Arrange + String userId = "1"; + String email = ""; + String password = "updatedPassword"; + String username = "updatedUsername"; + User_Credentials existingUser = new User_Credentials(); + existingUser.setId(1); + existingUser.setEmail("existing@example.com"); + existingUser.setPassword("existingPassword"); + existingUser.setUsername("existingUsername"); + when(UserAccRepo.findById(1)).thenReturn(existingUser); + + // Act + String result = userAccountController.updateUserById(userId, email, password, username); + + // Assert + assertEquals("Usuário Salvo", result); + verify(UserAccRepo, times(1)).save(existingUser); + assertEquals(email, existingUser.getEmail()); + assertEquals(password, existingUser.getPassword()); + assertEquals(username, existingUser.getUsername()); + + // TODO: Consider adding validation for empty email in the controller method + } + + @Test + void updateUserWithNullPassword() { + // Arrange + String userId = "1"; + String email = "updated@example.com"; + String password = null; + String username = "updatedUsername"; + User_Credentials existingUser = new User_Credentials(); + existingUser.setId(1); + existingUser.setEmail("existing@example.com"); + existingUser.setPassword("existingPassword"); + existingUser.setUsername("existingUsername"); + when(UserAccRepo.findById(1)).thenReturn(existingUser); + + // Act + String result = userAccountController.updateUserById(userId, email, password, username); + + // Assert + assertEquals("Usuário Salvo", result); + verify(UserAccRepo, times(1)).save(existingUser); + assertEquals(email, existingUser.getEmail()); + assertNull(existingUser.getPassword()); + assertEquals(username, existingUser.getUsername()); + + // TODO: Consider adding validation for null password in the controller method + } +} diff --git a/src/test/java/com/medeiros/SPRINGProject/Models/CommentsModelGetIdTest.java b/src/test/java/com/medeiros/SPRINGProject/Models/CommentsModelGetIdTest.java new file mode 100644 index 0000000..d5dbbdc --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Models/CommentsModelGetIdTest.java @@ -0,0 +1,97 @@ +// ********RoostGPT******** +/* +Test generated by RoostGPT for test j-claude-unit-may23 using AI Type Claude AI and AI Model claude-3-opus-20240229 + +ROOST_METHOD_HASH=getId_582e5a2030 +ROOST_METHOD_SIG_HASH=getId_92e05748b6 + +Here are some JUnit test scenarios for the provided getId() method: + +Scenario 1: Verify getId returns the correct id value + +Details: + TestName: getIdReturnsCorrectValue() + Description: This test verifies that the getId() method returns the correct id value assigned to the object. +Execution: + Arrange: Create an instance of the class containing the getId() method and set its id field to a known value. + Act: Call the getId() method on the created instance. + Assert: Use assertEquals to compare the returned id value with the expected value. +Validation: + The assertion verifies that the getId() method correctly returns the id value assigned to the object. + This test ensures that the getter method functions as expected and maintains data integrity. + +Scenario 2: Verify getId returns the default id value when not explicitly set + +Details: + TestName: getIdReturnsDefaultValue() + Description: This test checks if the getId() method returns the default value (e.g., 0) when the id field is not explicitly set. +Execution: + Arrange: Create an instance of the class containing the getId() method without setting its id field. + Act: Call the getId() method on the created instance. + Assert: Use assertEquals to compare the returned id value with the expected default value. +Validation: + The assertion verifies that the getId() method returns the default id value when no explicit value is assigned. + This test ensures that the getter method handles the case where the id field is not initialized and returns an appropriate default value. + +Scenario 3: Verify getId returns the correct id value after updating the id + +Details: + TestName: getIdReturnsUpdatedValue() + Description: This test verifies that the getId() method returns the updated id value after modifying the id field. +Execution: + Arrange: Create an instance of the class containing the getId() method and set its id field to an initial value. + Act: Update the id field to a new value and call the getId() method. + Assert: Use assertEquals to compare the returned id value with the expected updated value. +Validation: + The assertion verifies that the getId() method correctly returns the updated id value after modifying the id field. + This test ensures that the getter method reflects any changes made to the id field and maintains data consistency. + +These test scenarios cover the basic functionality of the getId() method, including returning the correct id value, handling default values, and reflecting updates to the id field. Additional test scenarios can be added based on specific requirements or edge cases related to the id field and its usage within the application. +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Models; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import jakarta.persistence.*; +import org.springframework.web.bind.annotation.RestController; + +class CommentsModelGetIdTest { + @Test + @DisplayName("Verify getId returns the correct id value") + void getIdReturnsCorrectValue() { + // Arrange + CommentsModel commentsModel = new CommentsModel(); + commentsModel.setId(1); + // Act + int result = commentsModel.getId(); + // Assert + assertEquals(1, result); + } + + @Test + @DisplayName("Verify getId returns the default id value when not explicitly set") + void getIdReturnsDefaultValue() { + // Arrange + CommentsModel commentsModel = new CommentsModel(); + // Act + int result = commentsModel.getId(); + // Assert + assertEquals(0, result); + } + + @Test + @DisplayName("Verify getId returns the correct id value after updating the id") + void getIdReturnsUpdatedValue() { + // Arrange + CommentsModel commentsModel = new CommentsModel(); + commentsModel.setId(1); + // Act + commentsModel.setId(2); + int result = commentsModel.getId(); + // Assert + assertEquals(2, result); + } +} diff --git a/src/test/java/com/medeiros/SPRINGProject/Models/CommentsModelGetMusicIdTest.java b/src/test/java/com/medeiros/SPRINGProject/Models/CommentsModelGetMusicIdTest.java new file mode 100644 index 0000000..e48794f --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Models/CommentsModelGetMusicIdTest.java @@ -0,0 +1,93 @@ +// ********RoostGPT******** +/* +Test generated by RoostGPT for test j-claude-unit-may23 using AI Type Claude AI and AI Model claude-3-opus-20240229 + +ROOST_METHOD_HASH=getMusicID_b06e71fc2c +ROOST_METHOD_SIG_HASH=getMusicID_7321ec95dc + +Here are the JUnit test scenarios for the provided getMusicID() method: + +Scenario 1: Verify getMusicID returns the correct MusicID value + +Details: + TestName: getMusicIDReturnsCorrectValue() + Description: This test verifies that the getMusicID() method returns the correct value of the MusicID field. +Execution: + Arrange: Create an instance of the class containing the getMusicID() method and set the MusicID field to a known value. + Act: Invoke the getMusicID() method on the instance. + Assert: Use assertEquals to compare the returned value with the expected MusicID value. +Validation: + The assertion verifies that the getMusicID() method correctly returns the value of the MusicID field. + This test ensures that the getter method is properly implemented and returns the expected value. + +Scenario 2: Verify getMusicID returns the default value when MusicID is not set + +Details: + TestName: getMusicIDReturnsDefaultValueWhenNotSet() + Description: This test checks that the getMusicID() method returns the default value (e.g., 0) when the MusicID field is not explicitly set. +Execution: + Arrange: Create an instance of the class containing the getMusicID() method without setting the MusicID field. + Act: Invoke the getMusicID() method on the instance. + Assert: Use assertEquals to compare the returned value with the expected default value (e.g., 0). +Validation: + The assertion verifies that the getMusicID() method returns the default value when the MusicID field is not set. + This test ensures that the getter method handles the case when the field is not initialized and returns an appropriate default value. + +Scenario 3: Verify getMusicID returns the correct value after updating MusicID + +Details: + TestName: getMusicIDReturnsUpdatedValue() + Description: This test verifies that the getMusicID() method returns the updated value of the MusicID field after it has been modified. +Execution: + Arrange: Create an instance of the class containing the getMusicID() method and set the MusicID field to an initial value. + Act: Update the MusicID field to a new value and then invoke the getMusicID() method. + Assert: Use assertEquals to compare the returned value with the expected updated MusicID value. +Validation: + The assertion verifies that the getMusicID() method correctly returns the updated value of the MusicID field. + This test ensures that the getter method reflects any changes made to the MusicID field and returns the most recent value. + +These test scenarios cover the basic functionality of the getMusicID() method, including returning the correct value, handling the default value when the field is not set, and returning the updated value after the field is modified. + +Note: The actual implementation of the test methods and the specific assertions may vary depending on the class structure and the framework being used (e.g., JUnit 4 or JUnit 5). +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Models; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.assertEquals; + +class CommentsModelGetMusicIdTest { + @Test + void getMusicIDReturnsCorrectValue() { + // Arrange + CommentsModel commentsModel = new CommentsModel(); + commentsModel.setMusicID(10); + // Act + int result = commentsModel.getMusicID(); + // Assert + assertEquals(10, result); + } + + @Test + void getMusicIDReturnsDefaultValueWhenNotSet() { + // Arrange + CommentsModel commentsModel = new CommentsModel(); + // Act + int result = commentsModel.getMusicID(); + // Assert + assertEquals(0, result); + } + + @Test + void getMusicIDReturnsUpdatedValue() { + // Arrange + CommentsModel commentsModel = new CommentsModel(); + commentsModel.setMusicID(5); + // Act + commentsModel.setMusicID(15); + int result = commentsModel.getMusicID(); + // Assert + assertEquals(15, result); + } +} diff --git a/src/test/java/com/medeiros/SPRINGProject/Models/CommentsModelSetIdTest.java b/src/test/java/com/medeiros/SPRINGProject/Models/CommentsModelSetIdTest.java new file mode 100644 index 0000000..9ca53f4 --- /dev/null +++ b/src/test/java/com/medeiros/SPRINGProject/Models/CommentsModelSetIdTest.java @@ -0,0 +1,120 @@ +// ********RoostGPT******** +/* +Test generated by RoostGPT for test j-claude-unit-may23 using AI Type Claude AI and AI Model claude-3-opus-20240229 + +ROOST_METHOD_HASH=setId_95b1d54b34 +ROOST_METHOD_SIG_HASH=setId_17ddd86313 + +Here are the JUnit test scenarios for the provided setId method: + +Scenario 1: Set a positive integer ID + +Details: + TestName: setIdWithPositiveInteger() + Description: This test verifies that the setId method correctly sets the id field when provided with a positive integer value. +Execution: + Arrange: Create an instance of the class containing the setId method. + Act: Invoke the setId method with a positive integer value, such as 1. + Assert: Use assertEquals to check if the id field of the instance is equal to the provided value. +Validation: + The assertion ensures that the setId method correctly assigns the provided positive integer value to the id field. + This test is important to validate that the setId method functions as expected for valid input. + +Scenario 2: Set a zero ID + +Details: + TestName: setIdWithZero() + Description: This test checks if the setId method correctly handles setting the id field to zero. +Execution: + Arrange: Create an instance of the class containing the setId method. + Act: Invoke the setId method with the value 0. + Assert: Use assertEquals to verify that the id field of the instance is set to 0. +Validation: + The assertion confirms that the setId method allows setting the id field to zero. + This test ensures that the setId method does not have any unexpected behavior when provided with a zero value. + +Scenario 3: Set a negative integer ID + +Details: + TestName: setIdWithNegativeInteger() + Description: This test examines how the setId method responds when provided with a negative integer value. +Execution: + Arrange: Create an instance of the class containing the setId method. + Act: Invoke the setId method with a negative integer value, such as -1. + Assert: Use assertEquals to check if the id field of the instance is set to the provided negative value. +Validation: + The assertion verifies that the setId method allows setting the id field to a negative integer value. + This test is crucial to ensure that the setId method does not impose any restrictions on the range of valid ID values. + +Scenario 4: Set the ID multiple times + +Details: + TestName: setIdMultipleTimes() + Description: This test validates that the setId method correctly updates the id field when called multiple times with different values. +Execution: + Arrange: Create an instance of the class containing the setId method. + Act: Invoke the setId method multiple times with different integer values, such as 1, 5, and 10. + Assert: Use assertEquals to verify that the id field of the instance is set to the last provided value. +Validation: + The assertion confirms that the setId method correctly updates the id field each time it is called with a new value. + This test ensures that the setId method consistently updates the id field and does not have any unintended side effects. + +These test scenarios cover various aspects of the setId method, including setting positive, zero, and negative integer values, as well as testing the behavior when the method is called multiple times. They help ensure the correctness and robustness of the setId method. +*/ + +// ********RoostGPT******** +package com.medeiros.SPRINGProject.Models; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; +import jakarta.persistence.*; +import org.springframework.web.bind.annotation.RestController; + +class CommentsModelSetIdTest { + @Test + void setIdWithPositiveInteger() { + CommentsModel commentsModel = new CommentsModel(); + int expectedId = 1; + + commentsModel.setId(expectedId); + + assertEquals(expectedId, commentsModel.getId()); + } + + @Test + void setIdWithZero() { + CommentsModel commentsModel = new CommentsModel(); + int expectedId = 0; + + commentsModel.setId(expectedId); + + assertEquals(expectedId, commentsModel.getId()); + } + + @Test + void setIdWithNegativeInteger() { + CommentsModel commentsModel = new CommentsModel(); + int expectedId = -1; + + commentsModel.setId(expectedId); + + assertEquals(expectedId, commentsModel.getId()); + } + + @Test + void setIdMultipleTimes() { + CommentsModel commentsModel = new CommentsModel(); + + commentsModel.setId(1); + commentsModel.setId(5); + commentsModel.setId(10); + + assertEquals(10, commentsModel.getId()); + } + + // TODO: Consider adding a test case for setting the ID to the maximum allowed value for an integer + + // TODO: Consider adding a test case for setting the ID to the minimum allowed value for an integer + + // TODO: Consider adding a test case for setting the ID to a null value (if applicable) +}