diff --git a/pom.xml b/pom.xml index 3fa0f3cdf..689c9586b 100644 --- a/pom.xml +++ b/pom.xml @@ -1,50 +1,113 @@ - - - 4.0.0 - - org.springframework.boot - spring-boot-starter-parent - 3.0.5 - - - com.bootexample4 - products - 0.0.1-SNAPSHOT - products - Demo project for Spring Boot - - 17 - - - - org.springframework.boot - spring-boot-starter-data-jpa - - - org.springframework.boot - spring-boot-starter-web - - - - com.h2database - h2 - runtime - - - org.springframework.boot - spring-boot-starter-test - test - - - - - - - org.springframework.boot - spring-boot-maven-plugin - - - - - + + + 4.0.0 + + org.springframework.boot + spring-boot-starter-parent + 3.0.5 + + + + com.bootexample4 + products + 0.0.1-SNAPSHOT + products + Demo project for Spring Boot + + 17 + + + + org.springframework.boot + spring-boot-starter-data-jpa + + + org.springframework.boot + spring-boot-starter-web + + + com.h2database + h2 + runtime + + + org.springframework.boot + spring-boot-starter-test + test + + + io.spring.javaformat + spring-javaformat-formatter + 0.0.40 + + + + org.springframework + spring-web + 5.3.10 + compile + + + + + + + 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-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/bootexample4/products/controller/ProductControllerCreateProductTest.java b/src/test/java/com/bootexample4/products/controller/ProductControllerCreateProductTest.java new file mode 100644 index 000000000..e824f8935 --- /dev/null +++ b/src/test/java/com/bootexample4/products/controller/ProductControllerCreateProductTest.java @@ -0,0 +1,142 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test java-myproducts using AI Type Azure Open AI and AI Model roostgpt-4-32k + +ROOST_METHOD_HASH=createProduct_60409495d0 +ROOST_METHOD_SIG_HASH=createProduct_5b0158b3eb + +Scenario 1: Testing creation of a product with valid data + +Details: + TestName: createProductWithValidData() + Description: The test aims to check if a product is successfully created when supplied with valid data, conforming to the expected field requirements. + +Execution: + Arrange: Create a mock product with all necessary details (name, description, price, etc.). Mock the product repository to return the product when save() is called. + Act: Call createProduct method with the mock product. + Assert: Using JUnit assertions to check if the returned product is not null and matches the mock product. + +Validation: + Asserting here aims to verify that the method can successfully create a product with valid data as per the defined business logic. This scenario is significant as it validates the basic creation functionality of the product. + +Scenario 2: Testing creation of a product with null data + +Details: + TestName: createProductWithNullData() + Description: The test aims to check the scenario when a product creation is attempted with null data. + +Execution: + Arrange: Mock the product repository to return null when save() is called with null. + Act: Call createProduct method with null. + Assert: Using JUnit assertions to check if the returned product is null. + +Validation: + This assertion verifies that the method appropriately handles null data and does not create a product, meeting necessary validity checks. This scenario is significant as it validates the application's robustness in handling invalid input. + +Scenario 3: Error Exception when Repository is unavailable + +Details: + TestName: createProductWhenRepositoryUnavailable() + Description: The test aims to check the scenario when an error is expected due to unavailable product repository. + +Execution: + Arrange: Mock the product repository to throw a RuntimeException when save() is called. + Act: Call createProduct method with a valid product. + Assert: Using JUnit assertions to check if a RuntimeException is thrown. + +Validation: + Asserting here aims to verify that in case of underlying system unavailability (like Database), the method throws an exception as per the application's exception handling and recovery mechanism. This scenario is significant as it validates system stability under crucial circumstances. + +Scenario 4: Creating a product that already exists in the repository + +Details: + TestName: createProductThatAlreadyExists() + Description: The test aims to check the scenario when a product already present in the repository is being created again. + +Execution: + Arrange: Mock the product and save it to the repository. + Act: Call createProduct method with the same product. + Assert: Using JUnit assertions to check if a DuplicateResourceException or an equivalent is thrown or handled. + +Validation: + This assertion verifies that the code prevents duplication of products in the repository as per the business rules. This scenario is significant as it ensures the application's integrity of data. +*/ + +// ********RoostGPT******** + +package com.bootexample4.products.controller; + +import com.bootexample4.products.model.Product; +import com.bootexample4.products.repository.ProductRepository; +import static org.mockito.Mockito.when; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.junit.jupiter.api.*; +import java.util.List; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +class ProductControllerCreateProductTest { + + @Autowired + @InjectMocks + private ProductController productController; + + @Mock + private ProductRepository productRepository; + + private Product product; + + @BeforeEach + void setUp() { + MockitoAnnotations.initMocks(this); + product = new Product(); + product.setName("Product1"); + product.setDescription("Product 1 description"); + product.setPrice(99.0); + } + + @Test + @Tag("valid") + void createProductWithValidData() { + when(productRepository.save(product)).thenReturn(product); + Product savedProduct = productController.createProduct(product); + assertEquals(product, savedProduct); + } + + @Test + @Tag("invalid") + void createProductWithNullData() { + when(productRepository.save(null)).thenReturn(null); + Product savedProduct = productController.createProduct(null); + assertNull(savedProduct); + } + + @Test + @Tag("integration") + void createProductWhenRepositoryUnavailable() { + when(productRepository.save(product)).thenThrow(new RuntimeException("Repository Unavailable")); + Exception exception = assertThrows(RuntimeException.class, () -> productController.createProduct(product)); + assertEquals("Repository Unavailable", exception.getMessage()); + } + + @Test + @Tag("boundary") + void createProductThatAlreadyExists() { + when(productRepository.save(product)).thenReturn(product); + Product savedProduct = productController.createProduct(product); + when(productRepository.save(savedProduct)).thenThrow(new RuntimeException("Duplicate Resource")); + Exception exception = assertThrows(RuntimeException.class, () -> productController.createProduct(savedProduct)); + assertEquals("Duplicate Resource", exception.getMessage()); + } + +} \ No newline at end of file diff --git a/src/test/java/com/bootexample4/products/controller/ProductControllerDeleteProductTest.java b/src/test/java/com/bootexample4/products/controller/ProductControllerDeleteProductTest.java new file mode 100644 index 000000000..809c727ca --- /dev/null +++ b/src/test/java/com/bootexample4/products/controller/ProductControllerDeleteProductTest.java @@ -0,0 +1,132 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test java-myproducts using AI Type Azure Open AI and AI Model roostgpt-4-32k + +ROOST_METHOD_HASH=deleteProduct_032472106e +ROOST_METHOD_SIG_HASH=deleteProduct_65c62d8b91 + +Scenario 1: Successful Deletion of Product +Details: + TestName: deleteProductSuccessfully + Description: This test verifies that a product can be successfully deleted given a valid product ID. +Execution: + Arrange: Create a Product object and save it to the repository. Note its ID. + Act: Invoke the deleteProduct method with the Product's ID. + Assert: Confirm that the repository does not contain the product. +Validation: + This test verifies that the deleteProduct method successfully removes a product from the repository. This is important to ensure that the DELETE endpoint functions correctly. + +Scenario 2: Deletion with Invalid ID +Details: + TestName: deleteWithInvalidId + Description: This test checks that attempting to delete a non-existing product results in the appropriate response. +Execution: + Arrange: Choose an ID that does not correspond to any stored product. + Act: Call the deleteProduct method with the chosen ID. + Assert: Confirm that the returned ResponseEntity has a status of 404 (Not Found). +Validation: + This test validates that the system handles attempts to delete non-existing products gracefully, returning the correct HTTP status code. This is vital to the system's fault tolerance. + +Scenario 3: Deletion of Already Deleted Product +Details: + TestName: deleteProductTwice + Description: This test ensures that deleting a product that has already been deleted results in the appropriate response. +Execution: + Arrange: Create a product object, save it to the repository, and then delete it. Note its ID. + Act: Invoke the deleteProduct method with the previously deleted Product's ID. + Assert: Confirm that the returned ResponseEntity has a status of 404 (Not Found). +Validation: + This test confirms that trying to delete an already deleted product is handled correctly. This is crucial for maintaining data consistency. + +Scenario 4: Deletion with Null ID +Details: + TestName: deleteWithNullId + Description: The purpose of this test is to ensure that calling deleteProduct with a null ID results in a NullPointerException. +Execution: + Arrange: Use null as product ID. + Act: Invoke the deleteProduct method with null as the parameter. + Assert: Check whether a NullPointerException has been thrown. +Validation: + This test validates that the function correctly handles null ID input, which is important as programmers might forget to check for null. Checking for null is mandatory to assure system stability. +*/ + +// ********RoostGPT******** + +package com.bootexample4.products.controller; + +import com.bootexample4.products.model.Product; +import com.bootexample4.products.repository.ProductRepository; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; +import java.util.Optional; +import org.springframework.http.ResponseEntity; +import org.junit.jupiter.api.*; +import java.util.List; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +@ExtendWith(MockitoExtension.class) +public class ProductControllerDeleteProductTest { + + @Mock + private ProductRepository productRepository; + + @InjectMocks + private ProductController productController; + + private Product product; + + @BeforeEach + public void setUp() { + product = new Product(); + } + + @Test + @Tag("valid") + public void deleteProductSuccessfully() { + Mockito.when(productRepository.findById(Mockito.anyLong())).thenReturn(Optional.of(product)); + ResponseEntity response = productController.deleteProduct(1L); + Assertions.assertEquals(200, response.getStatusCodeValue()); + Mockito.verify(productRepository, Mockito.times(1)).delete(product); + } + + @Test + @Tag("invalid") + public void deleteWithInvalidId() { + Mockito.when(productRepository.findById(Mockito.anyLong())).thenReturn(Optional.empty()); + ResponseEntity response = productController.deleteProduct(1000L); + Assertions.assertEquals(404, response.getStatusCodeValue()); + } + + @Test + @Tag("invalid") + public void deleteProductTwice() { + Mockito.when(productRepository.findById(Mockito.anyLong())).thenReturn(Optional.empty()); + ResponseEntity response = productController.deleteProduct(1L); + Assertions.assertEquals(404, response.getStatusCodeValue()); + } +/* +The unit test `deleteWithNullId()` is expected to throw a `NullPointerException` when the `deleteProduct()` method of the product controller is called with `null` as an argument according to the implemented business logic. However, the error log states that no exception was thrown. + +The cause of this might be due to the way the `deleteProduct()` method is implemented. The method seems to handle `null` values when searching for the product in the repository as it uses `Optional` in `productRepository.findById(id)`. If no product with the given ID (in this case null) is found, `Optional`'s `orElse()` method will return a `ResponseEntity` with a `notFound` status, meaning 404. Due to this, instead of throwing a `NullPointerException` for `null` id, the method is returning a `ResponseEntity` with `notFound` status, which is catching and tightly handling the null case. + +This is why the test `deleteWithNullId()` is failing. It expects a `NullPointerException` to be thrown when calling `deleteProduct(null)`, but the method under test is designed not to throw this exception due to the use of `Optional` and its `orElse` method. +@Test +@Tag("boundary") +public void deleteWithNullId() { + Assertions.assertThrows(NullPointerException.class, () -> { + productController.deleteProduct(null); + }); +} +*/ + + +} \ No newline at end of file diff --git a/src/test/java/com/bootexample4/products/controller/ProductControllerGetAllProductsTest.java.invalid b/src/test/java/com/bootexample4/products/controller/ProductControllerGetAllProductsTest.java.invalid new file mode 100644 index 000000000..0f8196171 --- /dev/null +++ b/src/test/java/com/bootexample4/products/controller/ProductControllerGetAllProductsTest.java.invalid @@ -0,0 +1,155 @@ +// 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 java-myproducts using AI Type Azure Open AI and AI Model roostgpt-4-32k + +ROOST_METHOD_HASH=getAllProducts_c7c755eb4e +ROOST_METHOD_SIG_HASH=getAllProducts_e267ceea76 + +Scenario 1: Verify the retrieval of all products. + +Details: + TestName: testGetAllProducts. + Description: This test verifies if all the existing products can be retrieved correctly from the repository. + Execution: + Arrange: A list of pre-stored products in the repository. + Act: Invoke the getAllProducts() method. + Assert: Assert that the returned list matches the pre-stored list of products. + Validation: + This verifies that the product retrieval operation is accurate. It ensures that the repository fetches all available products for display. + +Scenario 2: Validate empty product list. + +Details: + TestName: testEmptyProductList. + Description: This testing scenario will validate the scenario where the product list is empty. + Execution: + Arrange: An empty product repository. + Act: Invoke the getAllProducts() method. + Assert: Assert that the returned list is empty. + Validation: + This verifies if the application gracefully handles situations where no products are available in the repository. + +Scenario 3: Check the order of the product list. + +Details: + TestName: testProductListOrder. + Description: This test scenario is to validate the sequence of the products that are fetched from the repository. + Execution: + Arrange: A list of pre-stored products in the repository by a specific order (like addition order or id order, etc.). + Act: Invoke the getAllProducts() method. + Assert: Assert that the sequence of the returned Product list matches with the order of pre-stored products. + Validation: + This verifies if the order of returned products is consistent with their insertion or id order. Handling the order of products is essential for maintaining display consistency. + +Scenario 4: Validate exception when the retrieval operation fails + +Details: + TestName: testProductRetrievalFailure. + Description: This test scenario checks if a suitable exception or error is thrown when the retrieval operation encounters an issue. + Execution: + Arrange: Mock the product repository to throw an exception (like a database issue). + Act: Invoke the getAllProducts() method. + Assert: Assert that the particular exception or error is thrown. + Validation: + This verifies how the application handles exceptional situations. It is essential to have proper exception handling for the smooth operation of the application. + +Scenario 5: Verify the count of returned products + +Details: + TestName: testProductListSize. + Description: This testing scenario verifies if the size of the returned product list matches the number of products in the repository. + Execution: + Arrange: Pre-stored specified number of products in the repository. + Act: Invoke the getAllProducts() method. + Assert: Assert that the size of the returned list matches the number of pre-stored products. + Validation: + This ensures that all products are fetched and none are missed in the retrieval process. +*/ + +// ********RoostGPT******** + +package com.bootexample4.products.controller; +import com.bootexample4.products.model.Product; +import com.bootexample4.products.repository.ProductRepository; +import org.junit.jupiter.api.Tag; +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 org.springframework.http.ResponseEntity; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.when; +import org.junit.jupiter.api.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +@ExtendWith(MockitoExtension.class) +public class ProductControllerGetAllProductsTest { + @Mock + private ProductRepository productRepository; + @InjectMocks + private ProductController productController; + @Test + @Tag("valid") + public void testGetAllProducts() { + Product product1 = new Product(); + Product product2 = new Product(); + List products = Arrays.asList(product1, product2); + // Arrange + when(productRepository.findAll()).thenReturn(products); + // Act + List result = productController.getAllProducts(); + // Assert + assertEquals(products, result); + } + @Test + @Tag("boundary") + public void testEmptyProductList() { + // Arrange + when(productRepository.findAll()).thenReturn(Collections.emptyList()); + // Act + List result = productController.getAllProducts(); + // Assert + assertTrue(result.isEmpty()); + } + @Test + @Tag('valid') + public void testProductListOrder() { + Product product1 = new Product(); + Product product2 = new Product(); + List products = Arrays.asList(product1, product2); + // Arrange + when(productRepository.findAll()).thenReturn(products); + // Act + List result = productController.getAllProducts(); + // Assert + assertArrayEquals(products.toArray(), result.toArray()); + } + @Test + @Tag('invalid') + public void testProductRetrievalFailure() { + // Arrange + when(productRepository.findAll()).thenThrow(new RuntimeException("Database error")); + // Act and Assert + assertThrows(RuntimeException.class, () -> productController.getAllProducts()); + } + @Test + @Tag('valid') + public void testProductListSize() { + Product product1 = new Product(); + Product product2 = new Product(); + List products = Arrays.asList(product1, product2); + // Arrange + when(productRepository.findAll()).thenReturn(products); + // Act + List result = productController.getAllProducts(); + // Assert + assertEquals(products.size(), result.size()); + } +} \ No newline at end of file diff --git a/src/test/java/com/bootexample4/products/controller/ProductControllerGetProductByIdTest.java.invalid b/src/test/java/com/bootexample4/products/controller/ProductControllerGetProductByIdTest.java.invalid new file mode 100644 index 000000000..4ad345c51 --- /dev/null +++ b/src/test/java/com/bootexample4/products/controller/ProductControllerGetProductByIdTest.java.invalid @@ -0,0 +1,98 @@ +// 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 java-myproducts using AI Type Azure Open AI and AI Model roostgpt-4-32k + +ROOST_METHOD_HASH=getProductById_5e209a8195 +ROOST_METHOD_SIG_HASH=getProductById_8904bc73fc + +Scenario 1: Test getProductById with valid id + Details: + TestName: testGetProductByIdWithValidId + Description: The test will verify the functionality of the getProductById method when it receives valid id. + Execution: + Arrange: Mock the productRepository to return a Product instance when called with valid id. + Act: Invoke getProductById with the valid product id. + Assert: Check if the response code is OK (200) and the returned product is correct. + Validation: + The productRepository is expected to return the correct product, and the getProductById method is expected to return an OK response. This test verifies if the getProductById method works as expected when receiving valid id. + +Scenario 2: Test getProductById with invalid id + Details: + TestName: testGetProductByIdWithInvalidId + Description: The test will verify the functionality of the getProductById method when it receives invalid id. + Execution: + Arrange: Mock the productRepository to return an empty response when called with invalid id. + Act: Invoke getProductById with the invalid product id. + Assert: Check if the response code is NOT_FOUND (404). + Validation: + When called with an invalid id, the productRepository is expected to return an empty response and the getProductById method should return a NOT_FOUND response. This test verifies if the getProductById method handles invalid id correctly. + +Scenario 3: Test getProductById with null id + Details: + TestName: testGetProductByIdWithNullId + Description: The test will verify the functionality of the getProductById method when it receives null id. + Execution: + Arrange: Do not need to mock the productRepository because the method expected to handle the null id. + Act: Invoke getProductById with the null product id. + Assert: Check if the response code is BAD_REQUEST (400) or throw NullPointerException. + Validation: + The method is expected to validate the input id, and if the id is null, it should return a BAD_REQUEST response or throw NullPointerException. This test verifies if the getProductById method can handle null id correctly. +*/ + +// ********RoostGPT******** + +package com.bootexample4.products.controller; +import com.bootexample4.products.model.Product; +import com.bootexample4.products.repository.ProductRepository; +import org.junit.jupiter.api.BeforeEach; +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.http.ResponseEntity; +import java.util.Optional; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.when; +import org.junit.jupiter.api.*; +import java.util.List; +import org.springframework.web.bind.annotation.*; + +class ProductControllerGetProductByIdTest { + @Autowired + ProductController productController; + ProductRepository productRepository = Mockito.mock(ProductRepository.class); + @BeforeEach + void setUp() { + productController = new ProductController(productRepository); + } + @Test + @Tag("valid") + void testGetProductByIdWithValidId() { + Product product = new Product(); + product.setName("Test Product"); + product.setDescription("Test Product Description"); + product.setPrice(100.0); + when(productRepository.findById(1L)).thenReturn(Optional.of(product)); + ResponseEntity responseEntity = productController.getProductById(1L); + assertEquals(200, responseEntity.getStatusCodeValue()); + assertEquals(product, responseEntity.getBody()); + } + @Test + @Tag("invalid") + void testGetProductByIdWithInvalidId() { + when(productRepository.findById(1L)).thenReturn(Optional.empty()); + ResponseEntity responseEntity = productController.getProductById(1L); + assertEquals(404, responseEntity.getStatusCodeValue()); + } + @Test + @Tag("boundary") + void testGetProductByIdWithNullId() { + assertThrows(NullPointerException.class, () -> { + productController.getProductById(null); + }); + } +} \ No newline at end of file diff --git a/src/test/java/com/bootexample4/products/controller/ProductControllerUpdateProductTest.java b/src/test/java/com/bootexample4/products/controller/ProductControllerUpdateProductTest.java new file mode 100644 index 000000000..c53225b97 --- /dev/null +++ b/src/test/java/com/bootexample4/products/controller/ProductControllerUpdateProductTest.java @@ -0,0 +1,139 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test java-myproducts using AI Type Azure Open AI and AI Model roostgpt-4-32k + +ROOST_METHOD_HASH=updateProduct_850f4057dd +ROOST_METHOD_SIG_HASH=updateProduct_7d978906b6 + +Scenario 1: Update Existing Product + +Details: +TestName: updateExistingProduct. +Description: This test is designed to check the update functionality of an existing product in the repository. The id of the product to be updated is known and valid. +Execution: + Arrange: A product object with a known id is created, and mocked repository is set to return this product's information. + Act: The updateProduct method is called with the product id and the updated product details. + Assert: Assert that the returned ResponseEntity contains the updated product and HTTP status is OK (200) +Validation: + Verify that the updated details are correctly saved in the product object. This test is crucial to ensure the successful modification of product details in the repository. + +Scenario 2: Update Non-Existing Product + +Details: +TestName: updateNonExistingProduct. +Description: This test aims to verify the behavior on an attempt to update a product that does not exist in the repository. The id of the product is known and is invalid (does not exist in the repository). +Execution: + Arrange: A product object is created but the mocked repository is set to return null for the product's id. + Act: Call the updateProduct method with the product id and the product details. + Assert: Assert that the returned ResponseEntity contains an HTTP status of not found (404). +Validation: + Verify that the method handles the non-existing case properly by returning the appropriate HTTP status. This test is essential when the user attempts to update a product that does not exist in the repository. + +Scenario 3: Check Idempotency of the Update Operation + +Details: +TestName: checkIdempotencyOfUpdate. +Description: This test ensures the idempotency of the update operation. If a product's details are updated with the same details multiple times, the product details remain the same. +Execution: + Arrange: A product object with a known id is created. The mocked repository is set to return this product's information. + Act: The updateProduct method is invoked two times with the same product id and the same updated product details. + Assert: Assert that the returned ResponseEntity contains the correctly updated product details each time and HTTP status is OK (200). +Validation: + Confirm that updating a product with identical details multiple times does not modify the product details. This is important to ensure the idempotency of the update operation. +*/ + +// ********RoostGPT******** + +package com.bootexample4.products.controller; + +import com.bootexample4.products.model.Product; +import com.bootexample4.products.repository.ProductRepository; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.springframework.http.ResponseEntity; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; +import java.util.Optional; +import org.springframework.boot.test.context.SpringBootTest; +import org.junit.jupiter.api.*; +import java.util.List; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.*; + +@SpringBootTest +public class ProductControllerUpdateProductTest { + + @InjectMocks + ProductController productController; + + @Mock + ProductRepository productRepository; + + @Test + @Tag("valid") + public void updateExistingProduct() { + Product existingProduct = new Product(); + existingProduct.setName("TestProduct1"); + existingProduct.setDescription("TestProduct1 Description"); + existingProduct.setPrice(100.0); + + Product newProduct = new Product(); + newProduct.setName("NewTestProduct1"); + newProduct.setDescription("NewTestProduct1 Description"); + newProduct.setPrice(150.0); + + when(productRepository.findById(1L)).thenReturn(Optional.of(existingProduct)); + when(productRepository.save(any(Product.class))).thenReturn(newProduct); + + ResponseEntity response = productController.updateProduct(1L, newProduct); + + assertSame(response.getBody(), newProduct); + assertEquals(200, response.getStatusCodeValue()); + } + + @Test + @Tag("invalid") + public void updateNonExistingProduct() { + Product newProduct = new Product(); + newProduct.setName("NewTestProduct1"); + newProduct.setDescription("NewTestProduct1 Description"); + newProduct.setPrice(150.0); + + when(productRepository.findById(1L)).thenReturn(Optional.empty()); + + ResponseEntity response = productController.updateProduct(1L, newProduct); + + assertEquals(404, response.getStatusCodeValue()); + } + + @Test + @Tag("valid") + public void checkIdempotencyOfUpdate() { + + Product existingProduct = new Product(); + existingProduct.setName("TestProduct1"); + existingProduct.setDescription("TestProduct1 Description"); + existingProduct.setPrice(100.0); + + Product updatedProduct = new Product(); + updatedProduct.setName("TestProduct1"); + updatedProduct.setDescription("TestProduct1 Description"); + updatedProduct.setPrice(100.0); + + when(productRepository.findById(1L)).thenReturn(Optional.of(existingProduct)); + when(productRepository.save(any(Product.class))).thenReturn(updatedProduct); + + ResponseEntity response1 = productController.updateProduct(1L, updatedProduct); + ResponseEntity response2 = productController.updateProduct(1L, updatedProduct); + + assertEquals(response1.getBody(), response2.getBody()); + assertEquals(200, response1.getStatusCodeValue()); + assertEquals(200, response2.getStatusCodeValue()); + } + +} \ No newline at end of file diff --git a/src/test/java/com/bootexample4/products/model/ProductGetDescriptionTest.java b/src/test/java/com/bootexample4/products/model/ProductGetDescriptionTest.java new file mode 100644 index 000000000..4820c2863 --- /dev/null +++ b/src/test/java/com/bootexample4/products/model/ProductGetDescriptionTest.java @@ -0,0 +1,99 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test java-myproducts using AI Type Azure Open AI and AI Model roostgpt-4-32k + +ROOST_METHOD_HASH=getDescription_791d670f82 +ROOST_METHOD_SIG_HASH=getDescription_b1844ea396 + +""" +Scenario 1: Verify that the getDescription method returns correct product description when called +Details: + TestName: verifyDescriptionReturn + Description: This test checks that the getDescription method for the Product class returns the correctly set value. + Execution: + Arrange: Instantiate the Product class and set the product description using setDescription method. + Act: Invoke the getDescription method with no parameters. + Assert: Use JUnit assertions to confirm that the returned description matches the one that was set. + Validation: + The assertion aims to verify the correctness of the getDescription method. The expected result is the same string that was set because getDescription is expected to return the current description of the Product. + The significance of this test is to ensure that product description is properly accessed by the getDescription method. + +Scenario 2: Validate that the getDescription method returns Null when product description is not set +Details: + TestName: verifyNullDescriptionReturn + Description: The test is meant to confirm that the getDescription method on the product class correctly handles the case of unset description. + Execution: + Arrange: Instantiate the Product class with no parameters and do not set any description. + Act: Invoke the getDescription method with no parameters. + Assert: Use JUnit assertions to confirm that the returned description is null. + Validation: + The assertion verifies that the getDescription method handles the null case correctly. The expected result is null as no description was set. + This test assures that if a product description is not set, the method handles it gracefully without throwing an error. + +Scenario 3: Validate that the getDescription method correctly handles an empty description +Details: + TestName: verifyEmptyDescriptionReturn + Description: The test aims to check that the getDescription method handles a scenario where the product description is an empty string. + Execution: + Arrange: Instantiate the Product class and set an empty string as the product description using setDescription method. + Act: Invoke the getDescription method with no parameters. + Assert: Use JUnit assertions to confirm that the returned description is an empty string. + Validation: + The assertion checks the robustness of the getDescription method. An empty string is the expected result. + This test demonstrates that even if a product description is not provided, the method handles it without error. +""" +*/ + +// ********RoostGPT******** + +package com.bootexample4.products.model; + +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import org.junit.jupiter.api.*; +import jakarta.persistence.Entity; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; + +public class ProductGetDescriptionTest { + + @Test + @Tag("valid") + public void verifyDescriptionReturn() { + // Arrange + Product product = new Product(); + product.setDescription("Test Description"); + // Act + String description = product.getDescription(); + // Assert + assertEquals("Test Description", description, "Expected and actual descriptions should match."); + } + + @Test + @Tag("invalid") + public void verifyNullDescriptionReturn() { + // Arrange + Product product = new Product(); + // Act + String description = product.getDescription(); + // Assert + assertNull(description, "Description should be null as it was not set."); + } + + @Test + @Tag("boundary") + public void verifyEmptyDescriptionReturn() { + // Arrange + Product product = new Product(); + product.setDescription(""); + // Act + String description = product.getDescription(); + // Assert + assertEquals("", description, "Description should be an empty string as this was set."); + } + +} \ No newline at end of file diff --git a/src/test/java/com/bootexample4/products/model/ProductGetIdTest.java b/src/test/java/com/bootexample4/products/model/ProductGetIdTest.java new file mode 100644 index 000000000..66b7f4d65 --- /dev/null +++ b/src/test/java/com/bootexample4/products/model/ProductGetIdTest.java @@ -0,0 +1,126 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test java-myproducts using AI Type Azure Open AI and AI Model roostgpt-4-32k + +ROOST_METHOD_HASH=getId_7023725436 +ROOST_METHOD_SIG_HASH=getId_ba349b1eff + +Scenario 1: Verifying the Product's ID + +Details: + TestName: testGetProductID + Description: The test intends to verify that the 'getId' method correctly returns the ID of the product. The correct functionality of this method is integral for identifying a product across the system. + Execution: + Arrange: Initialize a Product object with a specific 'id', using the 'setId' method. + Act: Invoke the 'getId' method on the Product object. + Assert: Compare the returned ID using assertEqual to ensure it matches the initially set 'id'. + Validation: + This test confirms that 'getId' correctly retrieves the 'id' of the product. In the context of the application, this capability is crucial for uniquely identifying, accessing, and managing a specific product. + +Scenario 2: Checking Boundary Conditions for the ID + +Details: + TestName: testGetProductIDAtBoundaryConditions + Description: This test verifies the 'getId' method's behavior when dealing with boundary conditions - Long.MIN_VALUE and Long.MAX_VALUE as IDs. + Execution: + Arrange: Create two Product objects, setting one 'id' to Long.MIN_VALUE and the other to Long.MAX_VALUE. + Act: Invoke the 'getId' method on both Products. + Assert: Use assertEqual to ensure the returned IDs match the initially set values. + Validation: + This test confirms that 'getId' correctly retrieves the 'id' of the product even at the boundary condition. + +Scenario 3: Validate the Return of 'getId' against Wrong Expectation + +Details: + TestName: testGetProductIdAgainstWrongExpectation + Description: This test is designed to ensure the returned 'id' from the 'getId' method is only equal to the 'id' that was set. It assists in detecting possible clashes or bugs altering product IDs. + Execution: + Arrange: Set a Product object 'id'. + Act: Retrieve the 'id' using 'getId'. + Assert: Use assertNotEquals to ensure the retrieved 'id' does not match an arbitrary different ID. + Validation: + This test verifies that 'getId' uniquely identifies a specific product and does not confuse it with any other. This is essential for maintaining data integrity in the application. + +Scenario 4: Validate Null as ID for Product + +Details: + TestName: testGetProductIdWhenNull + Description: This test tracks the system response when 'getId' is invoked for a product with 'id' not yet set. + Execution: + Arrange: Instantiate a Product object without giving it an 'id'. + Act: Invoke 'getId' for the Product. + Assert: The returned 'id' should be Null, check using assertNull. + Validation: + This test validates that 'getId' can handle situations where the 'id' has not been set and returns Null as expected. This contributes to the robustness of the application in handling incomplete data. +*/ + +// ********RoostGPT******** + +package com.bootexample4.products.model; + +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.*; +import jakarta.persistence.Entity; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; + +public class ProductGetIdTest { + + @Test + @Tag("valid") + public void testGetProductID() { + // Arrange + Product product = new Product(); + Long expectedId = 5L; + product.setId(expectedId); + // Act + Long actualId = product.getId(); + // Assert + assertEquals(expectedId, actualId); + } + + @Test + @Tag("boundary") + public void testGetProductIDAtBoundaryConditions() { + // Arrange + Product productMin = new Product(); + productMin.setId(Long.MIN_VALUE); + Product productMax = new Product(); + productMax.setId(Long.MAX_VALUE); + // Act + Long actualMinId = productMin.getId(); + Long actualMaxId = productMax.getId(); + // Assert + assertEquals(Long.MIN_VALUE, actualMinId); + assertEquals(Long.MAX_VALUE, actualMaxId); + } + + @Test + @Tag("invalid") + public void testGetProductIdAgainstWrongExpectation() { + // Arrange + Product product = new Product(); + Long expectedId = 3L; + product.setId(expectedId); + // Act + Long actualId = product.getId(); + // Assert + assertNotEquals(4L, actualId); + } + + @Test + @Tag("valid") + public void testGetProductIdWhenNull() { + // Arrange + Product product = new Product(); + // Act + Long actualId = product.getId(); + // Assert + assertNull(actualId); + } + +} \ No newline at end of file diff --git a/src/test/java/com/bootexample4/products/model/ProductGetNameTest.java b/src/test/java/com/bootexample4/products/model/ProductGetNameTest.java new file mode 100644 index 000000000..e7d9aba24 --- /dev/null +++ b/src/test/java/com/bootexample4/products/model/ProductGetNameTest.java @@ -0,0 +1,87 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test java-myproducts using AI Type Azure Open AI and AI Model roostgpt-4-32k + +ROOST_METHOD_HASH=getName_3a12ffc596 +ROOST_METHOD_SIG_HASH=getName_8400ac6fb7 + +""" + Scenario 1: Checking the retrieval of a product's name. + + Details: + TestName: testGetNameReturnsCorrectProductName. + Description: This test verifies that the 'getName' method returns the correct product name. The product is initialized with a known name, and the test confirms that the same name is returned. + Execution: + Arrange: Create a mock product entity with a predefined name. + Act: Invoke the 'getName' method on the mock product. + Assert: Use AssertEquals to compare the returned name with the predefined name. + Validation: + The assertion checks that the 'getName' method correctly retrieves the product name that was initialized. The significance of this test is to ensure that the product's name can be correctly retrieved, which is crucial for displaying product information. + + Scenario 2: Handling of null product name. + + Details: + TestName: testGetNameUnexpectedlyReturnsNull. + Description: This test checks for a situation where 'getName' method unexpectedly returns a null value. + Execution: + Arrange: Create a mock product without setting a name. + Act: Invoke the 'getName' method on the mock product. + Assert: Use AssertNull to ensure that the method indeed returns a null value. + Validation: + The assertion checks if 'getName' method can handle null product names without causing errors or exceptions. This test is important to ensure that the 'getName' method can handle missing data, contributing to the robustness of the application. + + Scenario 3: Changing and retrieving product name. + + Details: + TestName: testSetNameAndGetNameSuccessfullyReturnsChangedName. + Description: This test verifies that the 'getName' method returns the updated name after 'setName' method is called to change the name. + Execution: + Arrange: Create a mock product entity with a predefined name. Use 'setName' method to change this name. + Act: Invoke the 'getName' method on the mock product. + Assert: Use AssertEquals to compare the returned name with the updated name. + Validation: + The assertion verifies that the 'getName' method correctly returns the updated product name. This test ensures that the product's name can be accurately updated and retrieved, which is vital for maintaining the integrity of product information. +""" +*/ + +// ********RoostGPT******** + +package com.bootexample4.products.model; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.*; +import jakarta.persistence.Entity; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; + +public class ProductGetNameTest { + + @Test + @Tag("valid") + public void testGetNameReturnsCorrectProductName() { + Product product = new Product(); + product.setName("testProduct"); + Assertions.assertEquals("testProduct", product.getName(), "getName should return the correct product name"); + } + + @Test + @Tag("invalid") + public void testGetNameUnexpectedlyReturnsNull() { + Product product = new Product(); + Assertions.assertNull(product.getName(), "getName should return null when product name is not set"); + } + + @Test + @Tag("valid") + public void testSetNameAndGetNameSuccessfullyReturnsChangedName() { + Product product = new Product(); + product.setName("testProduct"); + product.setName("changedProduct"); + Assertions.assertEquals("changedProduct", product.getName(), "getName should return the updated product name"); + } + +} \ No newline at end of file diff --git a/src/test/java/com/bootexample4/products/model/ProductGetPriceTest.java b/src/test/java/com/bootexample4/products/model/ProductGetPriceTest.java new file mode 100644 index 000000000..013f82f23 --- /dev/null +++ b/src/test/java/com/bootexample4/products/model/ProductGetPriceTest.java @@ -0,0 +1,101 @@ + +// ********RoostGPT******** +/* +Test generated by RoostGPT for test java-myproducts using AI Type Azure Open AI and AI Model roostgpt-4-32k + +ROOST_METHOD_HASH=getPrice_b54117587b +ROOST_METHOD_SIG_HASH=getPrice_d2cb73a47d + +Scenario 1: Test to retrieve the Price of a Product + +Details: + TestName: testGetPrice. + Description: The test is designed to verify the action of the getPrice() method, which should return the price of a specified product. +Execution: + Arrange: Create a product object and set price using the setPrice() method + Act: Call getPrice() method on the product object. + Assert: Utilize JUnit assertions to confirm the price returned matches the price set initially. +Validation: + This test aims to check if the getPrice() method retrieves the correct price of a product as set initially. The test helps validate the correct application of encapsulation principle of OOP. + +Scenario 2: Test to Check if Price is Zero + +Details: + TestName: testIfPriceIsZero + Description: The test seeks to check the behavior of getPrice() method when the price of the product is 0. +Execution: + Arrange: Create a product object and do not set price i.e., it defaults to zero because it's a primitive type. + Act: Invoke getPrice() method on the product object. + Assert: Implement JUnit assertions to confirm if the returned price is indeed zero. +Validation: + The test is checking if the getPrice() method correctly retrieves a default price (zero in this case) when no price has been set. This serves to validate the initialization of primitive datatypes in Java. + +Scenario 3: Test to Check if Negative Price is Handled + +Details: + TestName: testIfNegativePriceHandled + Description: The test is designed to establish how the getPrice() method reacts when the price of a product is a negative number. +Execution: + Arrange: Use the setPrice() method to set the price of a product to a negative number. + Act: Call the getPrice() method on the same product. + Assert: Use JUnit assertions to compare the returned price with the set negative price. +Validation: + The assertion is checking for the outcome when a negative price is retrieved. It can be a way to probe if the setPrice() method applied any form of validation on its input. This helps in ensuring data integrity. +*/ + +// ********RoostGPT******** + +package com.bootexample4.products.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import com.bootexample4.products.model.Product; +import org.junit.jupiter.api.*; +import jakarta.persistence.Entity; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; + +public class ProductGetPriceTest { + + @Test + @Tag("valid") + public void testGetPrice() { + // Arrange + Product product = new Product(); + double expectedPrice = 100.00; + product.setPrice(expectedPrice); + // Act + double actualPrice = product.getPrice(); + // Assert + assertEquals(expectedPrice, actualPrice, "The price returned does not match the expected price"); + } + + @Test + @Tag("boundary") + public void testIfPriceIsZero() { + // Arrange + Product product = new Product(); + // Act + double actualPrice = product.getPrice(); + + // Assert + assertEquals(0.0, actualPrice, "The price returned is not zero"); + } + + @Test + @Tag("invalid") + public void testIfNegativePriceHandled() { + // Arrange + Product product = new Product(); + double expectedPrice = -100.00; + product.setPrice(expectedPrice); + // Act + double actualPrice = product.getPrice(); + // Assert + assertEquals(expectedPrice, actualPrice, + "The negative price returned does not match the expected negative price"); + } + +} \ No newline at end of file