From 96cda680478fa08b16817271ede711292d0b7a56 Mon Sep 17 00:00:00 2001 From: AlexKano10 Date: Tue, 5 Nov 2024 12:31:01 +0100 Subject: [PATCH 1/6] Refactor MenuItem to abstract class, created MainCourse and Dessert subclasses, and added IMenuItem interface for common behaviors. --- .../restaurantManager/model/Dessert.java | 42 +++++++++++++++++++ .../restaurantManager/model/MainCourse.java | 38 +++++++++++++++++ .../restaurantManager/model/MenuItem.java | 17 +++++++- .../model/interfaces/IMenuItem.java | 19 +++++++++ .../utilities/DataLoader.java | 5 ++- 5 files changed, 119 insertions(+), 2 deletions(-) create mode 100644 src/main/java/dev/example/restaurantManager/model/Dessert.java create mode 100644 src/main/java/dev/example/restaurantManager/model/MainCourse.java create mode 100644 src/main/java/dev/example/restaurantManager/model/interfaces/IMenuItem.java diff --git a/src/main/java/dev/example/restaurantManager/model/Dessert.java b/src/main/java/dev/example/restaurantManager/model/Dessert.java new file mode 100644 index 0000000..d5fa468 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/Dessert.java @@ -0,0 +1,42 @@ +package dev.example.restaurantManager.model; + + +import jakarta.persistence.DiscriminatorValue; +import jakarta.persistence.Entity; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@Entity +@DiscriminatorValue("DESSERT") + +public class Dessert extends MenuItem { + + private boolean isGlutenFree; // indicates if the dessert is gluten-free + private String flavor; //Flavor of dessert + private int sweetnessLevel; //Sweetness Level on a scale from 1 to 10; + + //Constructor that inherits from MenuItem and initializes dessert specific attributes. + + public Dessert (String id, String name, String description, double price, boolean isGlutenFree, String flavor, int sweetnessLevel){ + super(id, name, description, price); // Calls the constructor of the parent class (MenuItem) + this.isGlutenFree = isGlutenFree; // Initializes the gluten-free attribute + this.flavor = flavor; // Initializes the flavor attribute + this.sweetnessLevel = sweetnessLevel; // Initializes the sweetness level attribute + + } + + //method to get a summary of dessert + public String getDessertSummary() { + return String.format("%s - %s (Price: %.2f, Gluten Free: %b, Flavor: %s, Sweetness Level: %d)", + getName(), getDescription(), getPrice(), isGlutenFree, flavor, sweetnessLevel); + } + + public boolean isSuitableForDiet(String dietaryNeed) { + if(dietaryNeed.equalsIgnoreCase("gluten-free")){ + return isGlutenFree; //Checks if the dessert is gluten-free + } + return false; //Default case + } +} diff --git a/src/main/java/dev/example/restaurantManager/model/MainCourse.java b/src/main/java/dev/example/restaurantManager/model/MainCourse.java new file mode 100644 index 0000000..9fdc2a0 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/MainCourse.java @@ -0,0 +1,38 @@ +package dev.example.restaurantManager.model; + +import jakarta.persistence.DiscriminatorValue; +import jakarta.persistence.Entity; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@Entity +@DiscriminatorValue("MAIN_COURSE") +public class MainCourse extends MenuItem { + + private String sideDish; // "chips" or "salad" + private int calories; // calories content of the main course + private boolean chefRecommendation;// Indicates if it's a chef's special recommendation + + //constructor inheriting from MenuItem and initializing MainCourse - specific attributes. + public MainCourse(String id, String name, String description, double price, String sideDish, int calories, boolean chefRecommendation){ + super(id, name, description, price); // Calls the constructor of MenuItem + this.sideDish = sideDish; // Sets the side dish + this.calories = calories; // Sets the calories + this.chefRecommendation = chefRecommendation; // Marks if it's a chef's recommendation + } + + public String getFullDescription() { + return String.format("%s - %s (Price: %.2f, Side Dish: %s, Calories: %d, Chef Recommended: %b)", + getName(), getDescription(), getPrice(), sideDish, calories, chefRecommendation); + } + + public boolean isHealthy() { + return calories < 500; // Example threshold for healthy + } + + public int comparePrice(MainCourse other) { + return Double.compare(this.getPrice(), other.getPrice()); // Compares prices of two main courses + } +} diff --git a/src/main/java/dev/example/restaurantManager/model/MenuItem.java b/src/main/java/dev/example/restaurantManager/model/MenuItem.java index d1ba851..8e3db33 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuItem.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuItem.java @@ -1,5 +1,6 @@ package dev.example.restaurantManager.model; +import dev.example.restaurantManager.model.interfaces.IMenuItem; import jakarta.persistence.*; import lombok.AllArgsConstructor; import lombok.Data; @@ -10,9 +11,13 @@ @AllArgsConstructor @NoArgsConstructor @Entity -public class MenuItem { +@Inheritance(strategy = InheritanceType.SINGLE_TABLE) +@DiscriminatorColumn(name = "item_type", discriminatorType = DiscriminatorType.STRING) + +public abstract class MenuItem implements IMenuItem { @Id + @GeneratedValue(strategy = GenerationType.AUTO) private String id; private String name; private String description; @@ -27,4 +32,14 @@ public MenuItem(String id, String name, String description, double price) { this.description = description; this.price = price; } + + @Override + public String getItemType() { + // You can return the class type as the item type + return this.getClass().getSimpleName(); + } + @Override + public String getSummary() { + return String.format("%s - %s (Price: %.2f)", name, description, price); + } } \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/interfaces/IMenuItem.java b/src/main/java/dev/example/restaurantManager/model/interfaces/IMenuItem.java new file mode 100644 index 0000000..d9049e0 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/interfaces/IMenuItem.java @@ -0,0 +1,19 @@ +package dev.example.restaurantManager.model.interfaces; + +public interface IMenuItem { + + //Method to get the name of the menu item + String getName(); + + //Method to get the description of the menu item + String getDescription(); + + //Method to get the price of the menu item + double getPrice(); + + //Method to get the item type + String getItemType(); + + //Method to provide a summary of the menu item + String getSummary(); +} diff --git a/src/main/java/dev/example/restaurantManager/utilities/DataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/DataLoader.java index 760cf2a..1513f34 100644 --- a/src/main/java/dev/example/restaurantManager/utilities/DataLoader.java +++ b/src/main/java/dev/example/restaurantManager/utilities/DataLoader.java @@ -96,7 +96,8 @@ private void createTables() { // we are going to create 25 menu items // and save them in the H2 local database - private void createMenuItems() { + private void createMenuItems() { + /* for (int i = 0; i < 25; i++) { MenuItem menuItem = new MenuItem( UUID.randomUUID().toString(), @@ -106,6 +107,8 @@ private void createMenuItems() { ); menuItemRepository.save(menuItem); } + */ + } // we are going to create 15 menus From 2c350519a373f1e7e9907ee3626ab9fa1d2c3ac1 Mon Sep 17 00:00:00 2001 From: AlexKano10 Date: Wed, 6 Nov 2024 12:59:36 +0100 Subject: [PATCH 2/6] Updated MenuItemRepository to support MainCourse and Dessert querying --- .../repository/MenuItemRepository.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java b/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java index cfe3f40..29b98b2 100644 --- a/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java +++ b/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java @@ -1,7 +1,21 @@ package dev.example.restaurantManager.repository; +import dev.example.restaurantManager.model.Dessert; +import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; + +import java.util.List; public interface MenuItemRepository extends JpaRepository { + + // Búsqueda solo de main courses + @Query("SELECT m FROM MainCourse m") + List findAllMainCourses(); + + // Búsqueda solo de desserts + @Query("SELECT d FROM Dessert d") + List findAllDesserts(); + } \ No newline at end of file From 7c3e10589b4dc174c5bedbb6c06addab3d36d822 Mon Sep 17 00:00:00 2001 From: AlexKano10 Date: Wed, 6 Nov 2024 13:08:39 +0100 Subject: [PATCH 3/6] Update service layer to handle CRUD operations for MainCourse and Dessert subclasses --- .../service/MenuItemServiceImpl.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java index ccce3d3..b31224d 100644 --- a/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java @@ -1,5 +1,7 @@ package dev.example.restaurantManager.service; +import dev.example.restaurantManager.model.Dessert; +import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; import dev.example.restaurantManager.repository.MenuItemRepository; import org.springframework.beans.factory.annotation.Autowired; @@ -13,22 +15,39 @@ public class MenuItemServiceImpl implements MenuItemService { @Autowired private MenuItemRepository menuItemRepository; + //Retrieve all MenuItems including subtypes @Override public List getAllMenuItems() { return menuItemRepository.findAll(); } + //Save a generic Menu item @Override public MenuItem createMenuItem(MenuItem menuItem) { menuItem.setId(UUID.randomUUID().toString()); return menuItemRepository.save(menuItem); } + //Save a MainCourse + public MainCourse createMainCourse(MainCourse mainCourse){ + mainCourse.setId(UUID.randomUUID().toString()); + return menuItemRepository.save(mainCourse); + } + + //Save Dessert + + public Dessert createDessert(Dessert dessert){ + dessert.setId(UUID.randomUUID().toString()); + return menuItemRepository.save(dessert); + } + + //Retrieve a MenuItem by ID @Override public MenuItem getMenuItemById(String id) { return menuItemRepository.findById(id).orElse(null); } + //Update an existing MenuItem @Override public MenuItem updateMenuItem(String id, MenuItem menuItemDetails) { MenuItem menuItem = menuItemRepository.findById(id).orElse(null); From 606b2b3a388e4d7e6e22b413eb280ae2cff09143 Mon Sep 17 00:00:00 2001 From: AlexKano10 Date: Wed, 6 Nov 2024 13:18:49 +0100 Subject: [PATCH 4/6] Update MenuItemController to support CRUD operations for MainCourse and Dessert subclasses --- .../controller/MenuItemController.java | 24 +++++++++++++++++++ .../service/MenuItemService.java | 6 +++++ 2 files changed, 30 insertions(+) diff --git a/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java index fbcc2ac..5af60bb 100644 --- a/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java +++ b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java @@ -1,5 +1,7 @@ package dev.example.restaurantManager.controller; +import dev.example.restaurantManager.model.Dessert; +import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; import dev.example.restaurantManager.service.MenuItemService; import org.springframework.beans.factory.annotation.Autowired; @@ -16,17 +18,22 @@ public class MenuItemController { @Autowired private MenuItemService menuItemService; + // Get all MenuItems (including MainCourse and Dessert) + @GetMapping public ResponseEntity> getAllMenuItems() { List menuItems = menuItemService.getAllMenuItems(); return new ResponseEntity<>(menuItems, HttpStatus.OK); } + // Create a MenuItem (can be a MainCourse, Dessert, or other MenuItem) + @PostMapping public ResponseEntity createMenuItem(@RequestBody MenuItem menuItem) { MenuItem newMenuItem = menuItemService.createMenuItem(menuItem); return new ResponseEntity<>(newMenuItem, HttpStatus.CREATED); } + // Get a MenuItem by ID (including MainCourse and Dessert) @GetMapping("/{id}") public ResponseEntity getMenuItemById(@PathVariable String id) { @@ -36,6 +43,7 @@ public ResponseEntity getMenuItemById(@PathVariable String id) { } return new ResponseEntity<>(HttpStatus.NOT_FOUND); } + // Update an existing MenuItem @PutMapping("/{id}") public ResponseEntity updateMenuItem(@PathVariable String id, @RequestBody MenuItem menuItemDetails) { @@ -45,6 +53,7 @@ public ResponseEntity updateMenuItem(@PathVariable String id, @Request } return new ResponseEntity<>(HttpStatus.NOT_FOUND); } + // Delete a MenuItem by ID @DeleteMapping("/{id}") public ResponseEntity deleteMenuItem(@PathVariable String id) { @@ -54,10 +63,25 @@ public ResponseEntity deleteMenuItem(@PathVariable String id) { } return new ResponseEntity<>(HttpStatus.NOT_FOUND); } + // Get the count of all MenuItems @GetMapping("/count") public ResponseEntity countMenuItems() { long count = menuItemService.countMenuItems(); return new ResponseEntity<>(count, HttpStatus.OK); } + + // Endpoint to create a MainCourse + @PostMapping("/maincourse") + public ResponseEntity createMainCourse(@RequestBody MainCourse mainCourse){ + MainCourse newMainCourse = menuItemService.createMainCourse(mainCourse); + return new ResponseEntity<>(newMainCourse, HttpStatus.CREATED); + } + + @PostMapping("/dessert") + public ResponseEntity createDessert (@RequestBody Dessert dessert){ + Dessert newDessert = menuItemService.createDessert(dessert); + return new ResponseEntity<>(newDessert,HttpStatus.CREATED); + } + } \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/service/MenuItemService.java b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java index b45c30f..2e87a50 100644 --- a/src/main/java/dev/example/restaurantManager/service/MenuItemService.java +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java @@ -1,5 +1,7 @@ package dev.example.restaurantManager.service; +import dev.example.restaurantManager.model.Dessert; +import dev.example.restaurantManager.model.MainCourse; import dev.example.restaurantManager.model.MenuItem; import java.util.List; @@ -10,4 +12,8 @@ public interface MenuItemService { MenuItem updateMenuItem(String id, MenuItem menuItemDetails); boolean deleteMenuItem(String id); long countMenuItems(); + + // New methods for MainCourse and Dessert + MainCourse createMainCourse(MainCourse mainCourse); + Dessert createDessert(Dessert dessert); } \ No newline at end of file From c1c8048a277270e40fc9826e6445ad4600445c6e Mon Sep 17 00:00:00 2001 From: AlexKano10 Date: Wed, 6 Nov 2024 13:35:08 +0100 Subject: [PATCH 5/6] updated Faker to generate MainCourse and Dessert items with specific attribute --- .../utilities/DataLoader.java | 53 +++++++++++++++---- 1 file changed, 42 insertions(+), 11 deletions(-) diff --git a/src/main/java/dev/example/restaurantManager/utilities/DataLoader.java b/src/main/java/dev/example/restaurantManager/utilities/DataLoader.java index 1513f34..cce88a5 100644 --- a/src/main/java/dev/example/restaurantManager/utilities/DataLoader.java +++ b/src/main/java/dev/example/restaurantManager/utilities/DataLoader.java @@ -96,19 +96,50 @@ private void createTables() { // we are going to create 25 menu items // and save them in the H2 local database - private void createMenuItems() { - /* + private void createMenuItems() { + + // Listas predefinidas para los valores de sideDish, salad y dessert + List sideDishes = Arrays.asList("Fries", "Rice", "Mashed Potatoes", "Grilled Vegetables", "Garlic Bread"); + List flavors = Arrays.asList("Chocolate", "Vanilla", "Strawberry", "Lemon", "Banana"); + List desserts = Arrays.asList("Chocolate Cake", "Ice Cream", "Apple Pie", "Cheesecake", "Tiramisu"); + + // Crear 25 elementos de menú de tipo MainCourse o Dessert for (int i = 0; i < 25; i++) { - MenuItem menuItem = new MenuItem( - UUID.randomUUID().toString(), - faker.food().dish(), - faker.food().ingredient() + " " + faker.food().ingredient() , - faker.number().randomDouble(2, 5, 30) - ); - menuItemRepository.save(menuItem); - } - */ + // Decidir aleatoriamente si el menú será un MainCourse o un Dessert + boolean isMainCourse = faker.random().nextBoolean(); + + if (isMainCourse) { + // Crear un MainCourse + MainCourse mainCourse = new MainCourse( + UUID.randomUUID().toString(), + faker.food().dish(), + faker.food().ingredient() + " " + faker.food().ingredient(), + faker.number().randomDouble(2, 5, 30), + sideDishes.get(faker.random().nextInt(sideDishes.size())), // Selecciona un side dish aleatorio + faker.number().numberBetween(200, 800), // Calorías + faker.random().nextBoolean() // Chef Recommendation + ); + + // Guardar el MainCourse + menuItemRepository.save(mainCourse); + + } else { + // Crear un Dessert + Dessert dessert = new Dessert( + UUID.randomUUID().toString(), + desserts.get(faker.random().nextInt(desserts.size())), + faker.food().ingredient() + " " + faker.food().ingredient(), + faker.number().randomDouble(2, 3, 15), + faker.random().nextBoolean(), // Gluten Free + flavors.get(faker.random().nextInt(flavors.size())), // Flavor + faker.number().numberBetween(1, 10) // Sweetness Level + ); + + // Guardar el Dessert + menuItemRepository.save(dessert); + } + } } // we are going to create 15 menus From e3ba15af160e4fb155b325905911cfdec1f2d255 Mon Sep 17 00:00:00 2001 From: AlexKano10 Date: Thu, 7 Nov 2024 12:18:49 +0100 Subject: [PATCH 6/6] Create MenuItemTest class with persistence, type verification, and basic CRUD tests for MainCourse and Dessert --- .../RestaurantManagerApplication.java | 7 + .../restaurantManager/model/MenuItem.java | 2 +- src/main/resources/application.properties | 2 +- src/test/java/MenuItemTest.java | 215 ++++++++++++++++++ 4 files changed, 224 insertions(+), 2 deletions(-) create mode 100644 src/test/java/MenuItemTest.java diff --git a/src/main/java/dev/example/restaurantManager/RestaurantManagerApplication.java b/src/main/java/dev/example/restaurantManager/RestaurantManagerApplication.java index d10fad7..e729f63 100644 --- a/src/main/java/dev/example/restaurantManager/RestaurantManagerApplication.java +++ b/src/main/java/dev/example/restaurantManager/RestaurantManagerApplication.java @@ -1,13 +1,20 @@ package dev.example.restaurantManager; +import dev.example.restaurantManager.utilities.DataLoader; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.context.annotation.Bean; @SpringBootApplication public class RestaurantManagerApplication { + public static void main(String[] args) { SpringApplication.run(RestaurantManagerApplication.class, args); } + + } \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/MenuItem.java b/src/main/java/dev/example/restaurantManager/model/MenuItem.java index 8e3db33..9835883 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuItem.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuItem.java @@ -17,7 +17,7 @@ public abstract class MenuItem implements IMenuItem { @Id - @GeneratedValue(strategy = GenerationType.AUTO) + private String id; private String name; private String description; diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index cfb2150..56fa3b7 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -1,7 +1,7 @@ spring.application.name=restaurantManager # application.properties -spring.profiles.active=local +spring.profiles.active=memory diff --git a/src/test/java/MenuItemTest.java b/src/test/java/MenuItemTest.java new file mode 100644 index 0000000..a256602 --- /dev/null +++ b/src/test/java/MenuItemTest.java @@ -0,0 +1,215 @@ +import dev.example.restaurantManager.RestaurantManagerApplication; +import dev.example.restaurantManager.model.Dessert; +import dev.example.restaurantManager.model.MainCourse; +import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.repository.MenuItemRepository; +import jakarta.transaction.Transactional; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.Optional; +import java.util.UUID; + +@SpringBootTest(classes = RestaurantManagerApplication.class)public class MenuItemTest { + + @Autowired + private MenuItemRepository menuItemRepository; + + @BeforeEach + public void setUp(){ + //Clean database before each test + menuItemRepository.deleteAll(); + } + + @Test + public void testMainCourseCreationAndPersistence(){ + //Create a MainCourse Object with specific data + + MainCourse mainCourse = new MainCourse( + UUID.randomUUID().toString(), + "Chicken parmesan", + "Fired chicken with Parmesan cheese", + 12.50, + "salad", + 450, + true + ); + + //save to repository + menuItemRepository.save(mainCourse); + + //retrieve the object since database using the ID + + Optional retrievedMainCourse = menuItemRepository.findById(mainCourse.getId()); + + //verify that the object was saved and retrieved correctly + assertThat(retrievedMainCourse).isPresent(); + assertThat(retrievedMainCourse.get().getName()).isEqualTo(mainCourse.getName()); + assertThat(retrievedMainCourse.get().getDescription()).isEqualTo(mainCourse.getDescription()); + assertThat(retrievedMainCourse.get().getPrice()).isEqualTo(mainCourse.getPrice()); + + // Print a message confirming it was saved correctly + System.out.println("MainCourse saved successfully: " + retrievedMainCourse.get().getName()); + + } + + @Test + public void testDessertCreationAndPersistence() { + // Create object dessert + Dessert dessert = new Dessert( + UUID.randomUUID().toString(), + "Chocolate Cake", + "Rich chocolate dessert", + 6.00, + false, + "Chocolate", + 8 + ); + + // saved database + menuItemRepository.save(dessert); + + // retrieved object of database find by id + Optional retrievedDessert = menuItemRepository.findById(dessert.getId()); + + // verify is saved and confirming + assertThat(retrievedDessert).isPresent(); + assertThat(retrievedDessert.get().getName()).isEqualTo(dessert.getName()); + assertThat(retrievedDessert.get().getDescription()).isEqualTo(dessert.getDescription()); + assertThat(retrievedDessert.get().getPrice()).isEqualTo(dessert.getPrice()); + + // Print a message confirming it was saved correctly + System.out.println("Dessert saved successfully: " + retrievedDessert.get().getName()); + } + + @Test + @Transactional + public void testSaveAndRetrieveAllMenuItems() { + //create objects MainCourse and Dessert + + MainCourse mainCourse = new MainCourse( + UUID.randomUUID().toString(), + "Steak", + "Grilled steak with potatoes", + 20.00, + "fries", + 600, + false + ); + + Dessert dessert = new Dessert(UUID.randomUUID().toString(), + "Apple Pie", + "Traditional apple pie", + 5.50, + true, + "Apple", + 6); + + //saved both objets in database + + menuItemRepository.save(mainCourse); + menuItemRepository.save(dessert); + + //verify that both objects can retrieve + Iterable allMenuItems = menuItemRepository.findAll(); + System.out.println("All Menu Items:"); + for (MenuItem menuItem : allMenuItems) { + System.out.println(menuItem.getName() + ": " + menuItem.getDescription()); + } + assertThat(allMenuItems).hasSize(2); + assertThat(menuItemRepository.count()).isEqualTo(2); + + } + + @Test + public void testUpdateMainCourse() { + // Create and save MainCourse + MainCourse savedMainCourse = menuItemRepository.save(new MainCourse( + UUID.randomUUID().toString(), + "Chicken Parmesan", + "Breaded chicken with cheese", + 14.00, + "vegetable", + 500, + true + )); + + savedMainCourse.setName("Chicken Crispy"); + + //save update maincourse + + MainCourse updateMainCourse = menuItemRepository.save(savedMainCourse); + + //verify updated + + assertThat(updateMainCourse.getName()).isEqualTo("Chicken Crispy"); + + + } + + @Test + public void testDeleteMainCourse() { + // Create and save MainCourse + MenuItem savedMainCourse = menuItemRepository.save(new MainCourse( + UUID.randomUUID().toString(), + "Beef Wellington", + "Tender beef wrapped in pastry", + 25.00, + "vegetables", + 700, + false + )); + + // Delete the item + menuItemRepository.delete(savedMainCourse); + + // Verifi that the item doesn't exists in the database + Optional deletedItem = menuItemRepository.findById(savedMainCourse.getId()); + assertThat(deletedItem).isNotPresent(); + } + + @Test + public void testGetItemType() { + // Create a MainCourse and Dessert + MenuItem mainCourse = new MainCourse( + UUID.randomUUID().toString(), // Generar un ID único + "Grilled Chicken", + "Grilled chicken with vegetables", + 12.50, + "vegetable", + 500, + true + ); + + MenuItem dessert = new Dessert( + UUID.randomUUID().toString(), + "Chocolate Cake", + "Rich chocolate dessert", + 6.00, + false, + "Chocolate", + 8 + ); + + // check that the type is correct before saving. + assertThat(mainCourse.getItemType()).isEqualTo("MainCourse"); + assertThat(dessert.getItemType()).isEqualTo("Dessert"); + + // save in database + menuItemRepository.save(mainCourse); + menuItemRepository.save(dessert); + + // retrieved and verify the type is correct. + Optional retrievedMainCourse = menuItemRepository.findById(mainCourse.getId()); + Optional retrievedDessert = menuItemRepository.findById(dessert.getId()); + + assertThat(retrievedMainCourse).isPresent(); + assertThat(retrievedMainCourse.get().getItemType()).isEqualTo("MainCourse"); + + assertThat(retrievedDessert).isPresent(); + assertThat(retrievedDessert.get().getItemType()).isEqualTo("Dessert"); + } +}