diff --git a/src/main/java/dev/example/restaurantManager/model/CourseType.java b/src/main/java/dev/example/restaurantManager/model/CourseType.java new file mode 100644 index 0000000..4f21359 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/CourseType.java @@ -0,0 +1,7 @@ +package dev.example.restaurantManager.model; + +public enum CourseType { + STARTER, + MAIN, + DESSERT +} diff --git a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java index 1e2dd12..7c730ae 100644 --- a/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/EatInOrderRestaurant.java @@ -19,9 +19,9 @@ public class EatInOrderRestaurant extends OrderRestaurant { public EatInOrderRestaurant(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, ArrayList menus, + double totalPayment, boolean paid, ArrayList orderMenuQties, ArrayList tableRestaurants) { - super(id, date, waiter, peopleQty, totalPayment, paid, menus); + super(id, date, waiter, peopleQty, totalPayment, paid, orderMenuQties); this.tableRestaurants = tableRestaurants; } diff --git a/src/main/java/dev/example/restaurantManager/model/MenuItem.java b/src/main/java/dev/example/restaurantManager/model/MenuItem.java new file mode 100644 index 0000000..1e0aa79 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/MenuItem.java @@ -0,0 +1,60 @@ +package dev.example.restaurantManager.model; + +import jakarta.persistence.*; +import lombok.Data; +import lombok.Getter; +import org.hibernate.annotations.GenericGenerator; + +import java.awt.*; +import java.util.ArrayList; +import java.util.List; +import java.util.HashSet; +import java.util.Set; +import java.util.UUID; + +@Entity +@Data +public class MenuItem { + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + + private String name; + private String description; + private boolean isSpicy; + private boolean hasGluten; + private boolean isAvailable; + + @Enumerated(EnumType.STRING) + private CourseType courseType; + + @ManyToMany(mappedBy = "menuItems", fetch = FetchType.LAZY) + private List menus = new ArrayList<>(); + + // Constructor + public MenuItem(String name, String description, boolean isSpicy, boolean hasGluten, boolean isAvailable, CourseType courseType) { + this.name = name; + this.description = description; + this.isSpicy = isSpicy; + this.hasGluten = hasGluten; + this.isAvailable = isAvailable; + this.courseType = courseType; + } + + + // Constructors, getters, and setters + @Override + public String toString() { + return "MenuItem{" + + "id=" + id + + ", name='" + name + '\'' + + ", description='" + description + '\'' + + ", isSpicy=" + isSpicy + + ", hasGluten=" + hasGluten + + ", isAvailable=" + isAvailable + + ", courseType=" + courseType + + // ", menus=" + menus + + '}'; + } +} + diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java index e916706..7da1df8 100644 --- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java @@ -6,15 +6,21 @@ import jakarta.persistence.Id; import jakarta.persistence.ManyToMany; import lombok.*; +import jakarta.persistence.*; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.Getter; +import lombok.NoArgsConstructor; + import java.util.ArrayList; import java.util.List; import java.util.Objects; @Data -@AllArgsConstructor @NoArgsConstructor +@AllArgsConstructor @Entity -public class MenuRestaurant { +public class MenuRestaurant { @Id private String id; @@ -24,9 +30,23 @@ public class MenuRestaurant { private boolean active; private boolean water; - @JsonIgnore + /*@JsonIgnore @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY) - private List orders = new ArrayList<>(); + private List orders = new ArrayList<>();*/ + + @Getter + @ManyToMany(fetch = FetchType.LAZY) + @JoinTable( + name = "menu_restaurant_menu_item", + joinColumns = @JoinColumn(name = "menu_restaurant_id"), + inverseJoinColumns = @JoinColumn(name = "menu_item_id") + ) + private List menuItems; + + //PRA04 relationship + @OneToMany(mappedBy = "menuRestaurantMapped", cascade = CascadeType.ALL, + fetch = FetchType.LAZY) + private List orderMenuQty = new ArrayList<>(); public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water) { this.id = id; @@ -35,10 +55,20 @@ public MenuRestaurant(String id, String name, Double price, String content, bool this.content = content; this.active = active; this.water = water; + this.orderMenuQty = new ArrayList<>(); + this.menuItems = new ArrayList<>(); + } + + public void addMenuItem(MenuItem menuItem) { + this.menuItems.add(menuItem); + menuItem.getMenus().add(this); + } + + public void addOrderMenuQty(OrderMenuQty orderMenuQty) { + this.orderMenuQty.add(orderMenuQty); + orderMenuQty.setMenuRestaurantMapped(this); } - //We might want to exclude 'orders' from toString() - // to avoid circular references @Override public String toString() { return "MenuRestaurant{" + @@ -48,6 +78,9 @@ public String toString() { ", content='" + content + '\'' + ", active=" + active + ", water=" + water + + ", orderMenuQtyCount=" + (orderMenuQty != null ? orderMenuQty.size() : 0) + + ", menuItemsCount=" + + (menuItems != null ? menuItems.size() : 0) + + // ", menuItems=" + menuItems + '}'; } @@ -73,4 +106,3 @@ public int hashCode() { } } - diff --git a/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java new file mode 100644 index 0000000..8879b81 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/model/OrderMenuQty.java @@ -0,0 +1,47 @@ +package dev.example.restaurantManager.model; + +import jakarta.persistence.*; +import lombok.*; +import jakarta.persistence.criteria.Order; +import org.hibernate.annotations.GenericGenerator; + +import java.awt.*; +import java.util.Objects; + +@Data +@Entity +@NoArgsConstructor +@AllArgsConstructor +public class OrderMenuQty { + @Id + @GeneratedValue(generator = "UUID") + @GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator") + private String id; + + @ManyToOne + @JoinColumn(name = "order_id") + private OrderRestaurant orderRestaurantMapped; + + @ManyToOne + @JoinColumn(name = "menu_id") + private MenuRestaurant menuRestaurantMapped; + + private int quantity; + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof OrderMenuQty)) return false; + OrderMenuQty that = (OrderMenuQty) o; + return quantity == that.quantity && + Objects.equals(id, that.id) && + Objects.equals(orderRestaurantMapped, that.orderRestaurantMapped) && + Objects.equals(menuRestaurantMapped, that.menuRestaurantMapped); + } + + @Override + public int hashCode() { + return Objects.hash(id, orderRestaurantMapped, menuRestaurantMapped, quantity); + } + +} diff --git a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java index 994b5a4..031a953 100644 --- a/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/OrderRestaurant.java @@ -1,6 +1,7 @@ package dev.example.restaurantManager.model; import java.util.ArrayList; +import java.util.Collection; import java.util.Date; import java.util.List; import com.fasterxml.jackson.annotation.JsonIgnore; @@ -24,7 +25,7 @@ public class OrderRestaurant { private double totalPayment; private boolean paid; - @JsonIgnore + /*@JsonIgnore @ManyToMany(fetch = FetchType.LAZY , cascade = {CascadeType.PERSIST, CascadeType.MERGE}) @JoinTable( @@ -32,18 +33,20 @@ public class OrderRestaurant { joinColumns = @JoinColumn(name = "ORDER_RESTAURANT_FK_ID"), inverseJoinColumns = @JoinColumn(name = "MENU_RESTAURANT_FK_ID") ) - private List menus = new ArrayList<>(); + private List menus = new ArrayList<>();*/ - public List addMenu(MenuRestaurant menu) { - this.menus.add(menu); - menu.getOrders().add(this); - return this.menus; + @OneToMany(mappedBy = "orderRestaurantMapped", cascade = CascadeType.ALL, + fetch = FetchType.LAZY) + private ArrayList orderMenuQty; + + public void addOrderMenuQty(OrderMenuQty orderMenuQty) { + this.orderMenuQty.add(orderMenuQty); + orderMenuQty.setOrderRestaurantMapped(this); // Set the back reference } - public List removeMenu(MenuRestaurant menu) { - this.menus.remove(menu); - menu.getOrders().remove(this); - return this.menus; + public void removeOrderMenuQty(OrderMenuQty orderMenuQty) { + this.orderMenuQty.remove(orderMenuQty); + orderMenuQty.setOrderRestaurantMapped(null); // Clear the back reference } @Override @@ -55,9 +58,12 @@ public String toString() { ", peopleQty=" + peopleQty + ", totalPayment=" + totalPayment + ", paid=" + paid + - ", menusCount=" + (menus != null ? menus.size() : 0) + - ", menus=" + menus + + ", orderMenuQtyCount=" + (orderMenuQty != null ? orderMenuQty.size() : 0) + + ", orderMenuQty=" + orderMenuQty + '}'; } + public Collection getOrderMenuQtyList() { + return null; + } } \ No newline at end of file diff --git a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java index 6375dc2..5a4a34d 100644 --- a/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java +++ b/src/main/java/dev/example/restaurantManager/model/ShippingOrderRestaurant.java @@ -16,9 +16,9 @@ public class ShippingOrderRestaurant extends OrderRestaurant { private String riderName; public ShippingOrderRestaurant(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, ArrayList menus, + double totalPayment, boolean paid, ArrayList orderMenuQties, String address, String city, String riderName) { - super(id, date, waiter, peopleQty, totalPayment, paid, menus); + super(id, date, waiter, peopleQty, totalPayment, paid, orderMenuQties); this.address = address; this.city = city; this.riderName = riderName; diff --git a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java index e285789..dde4c3f 100644 --- a/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java +++ b/src/main/java/dev/example/restaurantManager/model/TakeAwayOrder.java @@ -19,11 +19,11 @@ public class TakeAwayOrder extends OrderRestaurant { // Constructor for TakeAwayOrder with the WHOLE DATA fields public TakeAwayOrder(String id, Date date, String waiter, int peopleQty, - double totalPayment, boolean paid, ArrayList menus, + double totalPayment, boolean paid, ArrayList orderMenuQties, Customer customerTakeAway) { // THIS PART is SUPERCLASS - super(id, date, waiter, peopleQty, totalPayment, paid, menus); + super(id, date, waiter, peopleQty, totalPayment, paid, orderMenuQties); // THIS PART is SUBCLASS this.customerTakeAway = customerTakeAway; } diff --git a/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java b/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java new file mode 100644 index 0000000..e683303 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/MenuItemRepository.java @@ -0,0 +1,7 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.MenuItem; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface MenuItemRepository extends JpaRepository { +} diff --git a/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java new file mode 100644 index 0000000..2549482 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/repository/OrderMenuQtyRepository.java @@ -0,0 +1,7 @@ +package dev.example.restaurantManager.repository; + +import dev.example.restaurantManager.model.OrderMenuQty; +import org.springframework.data.jpa.repository.JpaRepository; + +public interface OrderMenuQtyRepository extends JpaRepository { +} diff --git a/src/main/java/dev/example/restaurantManager/service/MenuItemService.java b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java new file mode 100644 index 0000000..a31eab9 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemService.java @@ -0,0 +1,18 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuItem; + +import java.util.List; +import java.util.Optional; + +public interface MenuItemService { + MenuItem createMenuItem(MenuItem menuItem); + + Optional getMenuItemById(String id); + + List getAllMenuItems(); + + MenuItem updateMenuItem(MenuItem menuItem); + + void deleteMenuItem(String id); +} diff --git a/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java new file mode 100644 index 0000000..4bd0562 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java @@ -0,0 +1,43 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.repository.MenuItemRepository; +import dev.example.restaurantManager.service.MenuItemService; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.Optional; + +@Service +public class MenuItemServiceImpl implements MenuItemService { + + @Autowired + private MenuItemRepository menuItemRepository; + + @Override + public MenuItem createMenuItem(MenuItem menuItem) { + return menuItemRepository.save(menuItem); + } + + @Override + public Optional getMenuItemById(String id) { + return menuItemRepository.findById(id); + } + + @Override + public List getAllMenuItems() { + return menuItemRepository.findAll(); + } + + @Override + public MenuItem updateMenuItem(MenuItem menuItem) { + return menuItemRepository.save(menuItem); + } + + @Override + public void deleteMenuItem(String id) { + menuItemRepository.deleteById(id); + } +} diff --git a/src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java new file mode 100644 index 0000000..5f098d0 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java @@ -0,0 +1,23 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.MenuItem; + +import java.util.List; +import java.util.Optional; + +public interface MenuRestaurantService { + MenuRestaurant createMenu(MenuRestaurant menuRestaurant); + + Optional getMenuById(String id); + + List getAllMenus(); + + MenuRestaurant updateMenu(MenuRestaurant menuRestaurant); + + void deleteMenu(String id); + + void addMenuItemToMenu(String menuId, MenuItem menuItem); + + List getMenuItems(String menuId); +} diff --git a/src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java new file mode 100644 index 0000000..d8d5857 --- /dev/null +++ b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantServiceImpl.java @@ -0,0 +1,65 @@ +package dev.example.restaurantManager.service; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.repository.MenuRestaurantRepository; +import dev.example.restaurantManager.repository.MenuItemRepository; +import dev.example.restaurantManager.service.MenuRestaurantService; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.util.List; +import java.util.Optional; + +@Service +public class MenuRestaurantServiceImpl implements MenuRestaurantService { + + @Autowired + private MenuRestaurantRepository menuRestaurantRepository; + + @Autowired + private MenuItemRepository menuItemRepository; + + @Override + public MenuRestaurant createMenu(MenuRestaurant menuRestaurant) { + return menuRestaurantRepository.save(menuRestaurant); + } + + @Override + public Optional getMenuById(String id) { + return menuRestaurantRepository.findById(id); + } + + @Override + public List getAllMenus() { + return menuRestaurantRepository.findAll(); + } + + @Override + public MenuRestaurant updateMenu(MenuRestaurant menuRestaurant) { + return menuRestaurantRepository.save(menuRestaurant); + } + + @Override + public void deleteMenu(String id) { + menuRestaurantRepository.deleteById(id); + } + + @Override + public void addMenuItemToMenu(String menuId, MenuItem menuItem) { + Optional menuRestaurantOpt = menuRestaurantRepository.findById(menuId); + if (menuRestaurantOpt.isPresent()) { + MenuRestaurant menuRestaurant = menuRestaurantOpt.get(); + menuRestaurant.addMenuItem(menuItem); + menuRestaurantRepository.save(menuRestaurant); + } + } + + @Override + public List getMenuItems(String menuId) { + Optional menuRestaurantOpt = menuRestaurantRepository.findById(menuId); + return menuRestaurantOpt.map(MenuRestaurant::getMenuItems).orElse(null); + } +} + diff --git a/src/test/java/dev/example/restaurantManager/MenuAndMenuItemServiceLayerTest.java b/src/test/java/dev/example/restaurantManager/MenuAndMenuItemServiceLayerTest.java new file mode 100644 index 0000000..4f01064 --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/MenuAndMenuItemServiceLayerTest.java @@ -0,0 +1,37 @@ +package dev.example.restaurantManager; + +import dev.example.restaurantManager.model.CourseType; +import dev.example.restaurantManager.model.MenuItem; +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.service.MenuItemService; +import dev.example.restaurantManager.service.MenuRestaurantService; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; + +import java.util.List; + +import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; + +@SpringBootTest +public class MenuAndMenuItemServiceLayerTest { + + @Autowired + private MenuRestaurantService menuRestaurantService; + @Autowired + private MenuItemService menuItemService; + + @Test + public void testAddMenuItemToMenu() { + MenuRestaurant menu = new MenuRestaurant("M04", "Vegan Menu", 15.99, "Salad and juice", true, true); + MenuItem item = new MenuItem("Juice", "Freshly squeezed juice", false, true, true, CourseType.STARTER); + + menuRestaurantService.createMenu(menu); + menuItemService.createMenuItem(item); + menuRestaurantService.addMenuItemToMenu("M04", item); + + List items = menuRestaurantService.getMenuItems("M04"); + assertThat(items).isNotEmpty(); + } + +} diff --git a/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java new file mode 100644 index 0000000..08aed3a --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/OrderMenuQtyTest.java @@ -0,0 +1,108 @@ +package dev.example.restaurantManager; + +import static org.junit.jupiter.api.Assertions.*; + +import dev.example.restaurantManager.model.MenuRestaurant; +import dev.example.restaurantManager.model.OrderMenuQty; +import dev.example.restaurantManager.model.OrderRestaurant; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; + +import java.util.Date; + +@DataJpaTest +public class OrderMenuQtyTest { + + private OrderMenuQty orderMenuQty; + private OrderRestaurant orderRestaurant; + private MenuRestaurant menuRestaurant; + + @BeforeEach + public void setUp() { + // Set up a sample OrderRestaurant object + orderRestaurant = new OrderRestaurant(); + orderRestaurant.setId("1"); + orderRestaurant.setDate(new Date()); + orderRestaurant.setWaiter("John Doe"); + orderRestaurant.setPeopleQty(2); + orderRestaurant.setTotalPayment(100.0); + orderRestaurant.setPaid(false); + + // Set up a sample MenuRestaurant object + menuRestaurant = new MenuRestaurant(); + menuRestaurant.setId("menu1"); + menuRestaurant.setName("Spaghetti"); + menuRestaurant.setPrice(12.99); + menuRestaurant.setContent("Pasta with tomato sauce"); + menuRestaurant.setActive(true); + menuRestaurant.setWater(false); + + // Set up the OrderMenuQty object + orderMenuQty = new OrderMenuQty(); + orderMenuQty.setQuantity(3); // Set quantity + orderMenuQty.setOrderRestaurantMapped(orderRestaurant); // Set the order relationship + orderMenuQty.setMenuRestaurantMapped(menuRestaurant); // Set the menu relationship + } + + @Test + public void testOrderMenuQtyCreation() { + assertNotNull(orderMenuQty); + assertEquals(3, orderMenuQty.getQuantity()); + assertNotNull(orderMenuQty.getOrderRestaurantMapped()); + assertEquals("1", orderMenuQty.getOrderRestaurantMapped().getId()); + assertNotNull(orderMenuQty.getMenuRestaurantMapped()); + assertEquals("menu1", orderMenuQty.getMenuRestaurantMapped().getId()); + } + + @Test + public void testOrderMenuQtyRelationship() { + assertEquals(orderRestaurant, orderMenuQty.getOrderRestaurantMapped()); + assertEquals(menuRestaurant, orderMenuQty.getMenuRestaurantMapped()); + } + + @Test + public void testSettersAndGetters() { + orderMenuQty.setQuantity(5); + assertEquals(5, orderMenuQty.getQuantity()); + + OrderRestaurant newOrderRestaurant = new OrderRestaurant(); + newOrderRestaurant.setId("2"); + orderMenuQty.setOrderRestaurantMapped(newOrderRestaurant); + assertEquals("2", orderMenuQty.getOrderRestaurantMapped().getId()); + + MenuRestaurant newMenuRestaurant = new MenuRestaurant(); + newMenuRestaurant.setId("menu2"); + orderMenuQty.setMenuRestaurantMapped(newMenuRestaurant); + assertEquals("menu2", orderMenuQty.getMenuRestaurantMapped().getId()); + } + + @Test + public void testEqualsAndHashCode() { + OrderMenuQty anotherOrderMenuQty = new OrderMenuQty(); + anotherOrderMenuQty.setId(orderMenuQty.getId()); + anotherOrderMenuQty.setQuantity(3); + anotherOrderMenuQty.setOrderRestaurantMapped(orderRestaurant); + anotherOrderMenuQty.setMenuRestaurantMapped(menuRestaurant); + + assertEquals(orderMenuQty, anotherOrderMenuQty); + assertEquals(orderMenuQty.hashCode(), anotherOrderMenuQty.hashCode()); + + anotherOrderMenuQty.setQuantity(4); + assertNotEquals(orderMenuQty, anotherOrderMenuQty); + } + + + @Test + public void testAddOrderMenuQty() { + // Add OrderMenuQty to MenuRestaurant + menuRestaurant.addOrderMenuQty(orderMenuQty); + + // Assert that the OrderMenuQty is added + assertEquals(1, menuRestaurant.getOrderMenuQty().size()); + assertEquals(orderMenuQty, menuRestaurant.getOrderMenuQty().get(0)); + + // Assert that the menuRestaurantMapped property is set correctly in OrderMenuQty + assertEquals(menuRestaurant, orderMenuQty.getMenuRestaurantMapped()); + } +} diff --git a/src/test/java/dev/example/restaurantManager/RelationshipsMenuToMenuItemsTest.java b/src/test/java/dev/example/restaurantManager/RelationshipsMenuToMenuItemsTest.java new file mode 100644 index 0000000..a7cf9cb --- /dev/null +++ b/src/test/java/dev/example/restaurantManager/RelationshipsMenuToMenuItemsTest.java @@ -0,0 +1,148 @@ +package dev.example.restaurantManager; + +import dev.example.restaurantManager.model.*; +import dev.example.restaurantManager.repository.*; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; + +@DataJpaTest +public class RelationshipsMenuToMenuItemsTest { + + @Autowired + private MenuRestaurantRepository menuRestaurantRepository; + @Autowired + private MenuItemRepository menuItemRepository; + + @Test + public void TestCreateMenu() { + // Create sample menus + MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); + MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); + MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); + // Save sample menus + menuRestaurantRepository.save(menuRestaurant1); + menuRestaurantRepository.save(menuRestaurant2); + menuRestaurantRepository.save(menuRestaurant3); + // Create a list of all menus + ArrayList menus = new ArrayList<>(); + menus.addAll(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)); + + // Print the number of menus + System.out.println("Menus"); + System.out.println("Total number of menus: " + menus.size() + " menus."); + System.out.println("--------------------"); + // Print all menus + for (MenuRestaurant menu : menus) { + System.out.println("Menu ID: " + menu.getId()); + System.out.println(menu); + System.out.println("--------------------"); + } + } + + @Test + public void TestCreateMenuItems() { + //Create menu items + MenuItem item1 = new MenuItem("Burger", "A tasty beef burger", false, true, true, CourseType.MAIN); + MenuItem item2 = new MenuItem("Fries", "Dulce de leche ice cream", false, true, true, CourseType.DESSERT); + MenuItem item3 = new MenuItem("Pizza", "Delicious margherita pizza", false, true, true, CourseType.MAIN); + MenuItem item4 = new MenuItem("Salad", "Fresh mixed salad", false, false, true, CourseType.STARTER); + //Save menu items + menuItemRepository.save(item1); + menuItemRepository.save(item2); + menuItemRepository.save(item3); + menuItemRepository.save(item4); + + // Create a list of all menu items + ArrayList items = new ArrayList<>(); + items.addAll(Arrays.asList(item1, item2, item3, item4)); + + // Print the number of menu items + System.out.println("Menu items"); + System.out.println("Total number of menu items: " + items.size() + " items."); + System.out.println("--------------------"); + // Print all menu items + for (MenuItem item : items) { + System.out.println("Item ID: " + item.getId()); + System.out.println(item); + System.out.println("--------------------"); + } + } + + @Test + public void TestAssignMenuItemToMenu() { + + //Create menu items + MenuItem item1 = new MenuItem("Burger", "A tasty beef burger", false, true, true, CourseType.MAIN); + MenuItem item2 = new MenuItem("Fries", "Dulce de leche ice cream", false, true, true, CourseType.DESSERT); + MenuItem item3 = new MenuItem("Pizza", "Delicious margherita pizza", false, true, true, CourseType.MAIN); + MenuItem item4 = new MenuItem("Salad", "Fresh mixed salad", false, false, true, CourseType.STARTER); + //Save menu items + menuItemRepository.save(item1); + menuItemRepository.save(item2); + menuItemRepository.save(item3); + menuItemRepository.save(item4); + // Create sample menus + MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); + MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); + MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); + // Save sample menus + menuRestaurantRepository.save(menuRestaurant1); + menuRestaurantRepository.save(menuRestaurant2); + menuRestaurantRepository.save(menuRestaurant3); + + //Add items + menuRestaurant1.addMenuItem(item1); + menuRestaurant1.addMenuItem(item2); + menuRestaurant2.addMenuItem(item3); + menuRestaurant3.addMenuItem(item4); + + menuRestaurantRepository.saveAll(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)); + + // Create a list of all menus + ArrayList menus = new ArrayList<>(); + menus.addAll(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)); + + // Print the number of menus + System.out.println("Menus"); + System.out.println("Total number of menus: " + menus.size() + " menus."); + System.out.println("--------------------"); + // Print all menus + for (MenuRestaurant menu : menus) { + System.out.println("Menu ID: " + menu.getId()); + System.out.println(menu); + System.out.println("--------------------"); + } + + //when + Optional menuFound = menuRestaurantRepository.findById("M01"); + System.out.println("--------------------"); + System.out.println("Menu ID: " + menuFound.get().getId()); + + Optional menuItemOneFound = menuItemRepository.findById(String.valueOf(item1.getId())); + System.out.println("--------------------"); + System.out.println("Menu Item ID: " + menuItemOneFound.get().getId()); + System.out.println("Menu Item Name: " + menuItemOneFound.get().getName()); + + + Optional menuItemTwoFound = menuItemRepository.findById(String.valueOf(item2.getId())); + System.out.println("--------------------"); + System.out.println("Menu Item ID: " + menuItemTwoFound.get().getId()); + System.out.println("Menu Item Name: " + menuItemTwoFound.get().getName()); + + + // then + assertThat(menuFound).isPresent(); + assertThat(menuFound.get().getMenuItems().size()).isEqualTo(2); + assertThat(menuFound.get().getMenuItems().get(0).getName()).isEqualTo(item1.getName()); + assertThat(menuFound.get().getMenuItems().get(1).getName()).isEqualTo(item2.getName()); + + } + + +} \ No newline at end of file diff --git a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java deleted file mode 100644 index 35e2078..0000000 --- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java +++ /dev/null @@ -1,501 +0,0 @@ -package dev.example.restaurantManager; - -import dev.example.restaurantManager.model.*; -import dev.example.restaurantManager.repository.*; -import org.junit.jupiter.api.Test; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; -import java.util.*; -import static org.assertj.core.api.Assertions.assertThat; - -@DataJpaTest -public class RelationshipsOrderRestaurantTest { - -@Autowired -private TakeAwayOrderRepository takeAwayOrderRepository; -@Autowired -private CustomerRepository customerRepository; -@Autowired -private MenuRestaurantRepository menuRestaurantRepository; -@Autowired -private OrderRestaurantRepository orderRestaurantRepository; -@Autowired -private TableRestaurantRepository tableRestaurantRepository; -@Autowired -private EatInOrderRestaurantRepository eatInOrderRestaurantRepository; - - @Test - public void TestCreateOrder() { - // Create sample menus - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02","Pizza Menu", 12.99, "Pizza and salad", true, false, null); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); - // Save sample menus - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - // Create sample customers - Customer customer1 = new Customer("C1", "John", "john@email.com", "123-456-7890", 30, false, false); - Customer customer2 = new Customer("C2", "Sarah", "sarah@email.com", "234-567-8901", 25, true, false); - Customer customer3 = new Customer("C3", "Emily", "emily@email.com", "345-678-9012", 35, false, false); - Customer customer4 = new Customer("C4", "David", "david@email.com", "456-789-0123", 40, true, false); - Customer customer5 = new Customer("C5", "Anna", "anna@email.com", "567-890-1234", 28, false, false); - Customer customer6 = new Customer("C6", "Mark", "mark@email.com", "678-901-2345", 45, true, false); - Customer customer7 = new Customer("C7", "Paul", "paul@email.com", "789-012-3456", 33, false, false); - Customer customer8 = new Customer("C8", "Linda", "linda@email.com", "890-123-4567", 38, true, false); - Customer customer9 = new Customer("C9", "George", "george@email.com", "901-234-5678", 50, false, false); - - // Create sample tables - TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); - TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); - - // Create 3 ShippingOrder objects - OrderRestaurant shippingOrder1 = new ShippingOrderRestaurant("SO1", new Date(), "John", 2, 21.98, false, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant1)), "123 Main St", "New York", "Mike"); - OrderRestaurant shippingOrder2 = new ShippingOrderRestaurant("SO2", new Date(), "Sarah", 1, 12.99, true, new ArrayList<>(Arrays.asList(menuRestaurant2)), "456 Elm St", "Los Angeles", "Tom"); - OrderRestaurant shippingOrder3 = new ShippingOrderRestaurant("SO3", new Date(), "Emily", 3, 32.97, false, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)), "789 Oak St", "Chicago", "Lisa"); - - // Create 3 EatInOrder objects - OrderRestaurant eatInOrder1 = new EatInOrderRestaurant("EO1", new Date(), "David", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant1, menuRestaurant2, menuRestaurant2)), new ArrayList<>(Arrays.asList(table1))); - OrderRestaurant eatInOrder2 = new EatInOrderRestaurant("EO2", new Date(), "Anna", 2, 21.98, false, new ArrayList<>(Arrays.asList(menuRestaurant2, menuRestaurant3)), new ArrayList<>(Arrays.asList(table2))); - OrderRestaurant eatInOrder3 = new EatInOrderRestaurant("EO3", new Date(), "Mark", 6, 65.94, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3)), new ArrayList<>(Arrays.asList(table1, table2))); - - // Create 3 TakeAwayOrder objects - OrderRestaurant takeAwayOrder1 = new TakeAwayOrder("TO1", new Date(), "Alice", 1, 10.99, true, new ArrayList<>(Arrays.asList(menuRestaurant1)), customer1 ); - OrderRestaurant takeAwayOrder2 = new TakeAwayOrder("TO2", new Date(), "Bob", 2, 21.98, false, new ArrayList<>(Arrays.asList(menuRestaurant2, menuRestaurant3)), customer3 ); - OrderRestaurant takeAwayOrder3 = new TakeAwayOrder("TO3", new Date(), "Charlie", 3, 32.97, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)), customer5); - OrderRestaurant takeAwayOrder4 = new TakeAwayOrder("TO4", new Date(), "Charlie", 3, 32.97, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3, menuRestaurant3)), customer9); - - // Create a list of all orders - ArrayList orders = new ArrayList<>(); - orders.addAll(Arrays.asList(shippingOrder1, shippingOrder2, shippingOrder3, - eatInOrder1, eatInOrder2, eatInOrder3, - takeAwayOrder1, takeAwayOrder2, takeAwayOrder3, takeAwayOrder4)); - - // Print the number of orders - System.out.println("Orders"); - System.out.println("Total number of orders: " + orders.size() + " orders."); - System.out.println("--------------------"); - // Print all orders - for (OrderRestaurant order : orders) { - System.out.println("Order ID: " + order.getId()); - System.out.println(order); - System.out.println("--------------------"); - } - - // Save the customer with JPA Repository to use in order T11 - customerRepository.save(customer1); - // let's create an order to save and test - // we do not create orderToSave as OrderRestaurant but - // as TakeAwayOrder to AVOID casting because - // in this test is easier to work with - TakeAwayOrder orderToSave = new TakeAwayOrder( - "T11", new Date(), "Alice", 1, 10.99, - true, new ArrayList<>(Arrays.asList(menuRestaurant1)), null ); - // we assign the customer to the order - //((TakeAwayOrder) orderToSave).setCustomerTakeAway(customer1); - orderToSave.setCustomerTakeAway(customer1); - // Save the order with JPA Repository - //takeAwayOrderRepository.save(orderToSave); - takeAwayOrderRepository.save(orderToSave); - - - // when - Optional found = takeAwayOrderRepository.findById("T11"); - System.out.println("--------------------"); - System.out.println("TakeAwayOrder ID: " + found.get().getId()); - System.out.println(found.get()); - // then - assertThat(found).isPresent(); - assertThat(found.get().getCustomerTakeAway().getName().equals(customer1.getName())); - - System.out.println("--------------------"); - } - - @Test - public void TestCreateOrderMenu () { - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02","Pizza Menu", 12.99, "Pizza and salad", true, false, null); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03","Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); - // Save sample menus - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - // Create 3 Order objects and assign menus - OrderRestaurant orderRestaurant1 = new OrderRestaurant("O01", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); - OrderRestaurant orderRestaurant2 = new OrderRestaurant("O02", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant3))); - OrderRestaurant orderRestaurant3 = new OrderRestaurant("O03", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant2))); - - // Save sample orders - orderRestaurantRepository.save(orderRestaurant1); - //orderRestaurantRepository.save(orderRestaurant2); - //orderRestaurantRepository.save(orderRestaurant3); - - - // when - Optional found = orderRestaurantRepository.findById("O01"); - System.out.println("--------------------"); - System.out.println("Order ID: " + found.get().getId()); - System.out.println(found.get()); - // then - assertThat(found).isPresent(); - assertThat(found.get().getMenus().get(0).getName().equals(menuRestaurant1.getName())); - } - - // java.lang.StackOverflowError toString - @Test - public void TestCreateOrderMenu_stackOverflow () { - // Create sample menus - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, - "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02","Pizza Menu", - 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03","Salad Menu", - 8.99, "Mixed salad and dressing", true, true); - // Save sample menus - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - // Create 3 Order objects and assign menus - OrderRestaurant orderRestaurant1 = new OrderRestaurant("O01", new Date(), "John", 4, 43.96, - true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); - OrderRestaurant orderRestaurant2 = new OrderRestaurant("O02", new Date(), "John", 4, 43.96, true, - new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant3))); - OrderRestaurant orderRestaurant3 = new OrderRestaurant("O03", new Date(), "John", 4, 43.96, true, - new ArrayList<>(Arrays.asList(menuRestaurant2))); - - // Save sample orders - orderRestaurantRepository.save(orderRestaurant1); - //orderRestaurantRepository.save(orderRestaurant2); - //orderRestaurantRepository.save(orderRestaurant3); - - // set menus to orders and save - menuRestaurant1.getOrders().add(orderRestaurant1); - menuRestaurantRepository.save(menuRestaurant1); - - // when - Optional found = orderRestaurantRepository.findById("O01"); - System.out.println("--------------------"); - System.out.println("Order ID: " + found.get().getId()); - // stack-overflow toString does not work in this case - //System.out.println(found.get()); - - Optional menuFound = menuRestaurantRepository.findById("M01"); - System.out.println("--------------------"); - System.out.println("Menu ID: " + menuFound.get().getId()); - // stack-overflow toString does not work in this case - //System.out.println(menuFound.get()); - - // then - assertThat(found).isPresent(); - assertThat(found.get().getMenus().get(0).getName().equals(menuRestaurant1.getName())); - } - - // Adding Menus to an Order: Verifies that menus can be added to an order - // and the association is correctly persisted in the database. - @Test - public void testAddingMenusToOrder() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - // Save sample menus - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create an order and add menus - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>()); - order.addMenu(menuRestaurant1); - order.addMenu(menuRestaurant2); - order.addMenu(menuRestaurant3); - orderRestaurantRepository.save(order); - - // Retrieve the order and assert the menus - Optional foundOrder = orderRestaurantRepository.findById("O01"); - assertThat(foundOrder).isPresent(); - assertThat(foundOrder.get().getMenus()).hasSize(3); - // Since we've implemented equals() and hashCode() methods based on - // the compilation of all fields except for orders. - // This avoids potential circular reference issues while still providing a comprehensive comparison of the menu items. - // we can now use contains() to check if the retrieved menus match the original ones - assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); - // Retrieve the menus and assert the order - assertThat(foundOrder.get().getMenus()) - .extracting("id") - .containsExactlyInAnyOrder("M01", "M02", "M03"); - assertThat(foundOrder.get().getMenus()) - .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) - .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, menuRestaurant3); - } - - // Adding Menus to an Order: Verifies that menus can be added to an order - @Test - public void testAddingRepeatedMenusToOrder() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - // Save sample menus - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create an order and add menus - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>()); - order.addMenu(menuRestaurant1); - order.addMenu(menuRestaurant2); - order.addMenu(menuRestaurant2); - order.addMenu(menuRestaurant3); - order.addMenu(menuRestaurant3); - order.addMenu(menuRestaurant3); - orderRestaurantRepository.save(order); - - // Retrieve the order and assert the menus - Optional foundOrder = orderRestaurantRepository.findById("O01"); - assertThat(foundOrder).isPresent(); - assertThat(foundOrder.get().getMenus()).hasSize(6); - // Since we've implemented equals() and hashCode() methods based on - // the compilation of all fields except for orders. - // This avoids potential circular reference issues while still providing a comprehensive comparison of the menu items. - // we can now use contains() to check if the retrieved menus match the original ones - assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3); - // Retrieve the menus and assert the order - assertThat(foundOrder.get().getMenus()) - .extracting("id") - .containsExactlyInAnyOrder("M01", "M02", "M02","M03, M03, M03"); - assertThat(foundOrder.get().getMenus()) - .usingElementComparator(Comparator.comparing(MenuRestaurant::getId)) - .containsExactlyInAnyOrder(menuRestaurant1, menuRestaurant2, menuRestaurant2, menuRestaurant3, menuRestaurant3, menuRestaurant3 ); - } - - // Removing Menus from an Order: Checks that menus can be removed from an order - // and the changes are reflected in the database. - @Test - public void testRemovingMenusFromOrder() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Retrieve the updated order after deleting the menu - System.out.println("List of menus AFTER DELETION:"); - menuRestaurantRepository.findAll().forEach(System.out::println); - - // Create an order with multiple menus and save it - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); - orderRestaurantRepository.save(order); - - // Retrieve the order, remove a menu, and save the updated order - Optional foundOrder = orderRestaurantRepository.findById("O01"); - assertThat(foundOrder).isPresent(); - OrderRestaurant updatedOrder = foundOrder.get(); - // Let's remove the second menu - //updatedOrder.removeMenu(menuRestaurant2); - updatedOrder.removeMenu(updatedOrder.getMenus().get(1)); - orderRestaurantRepository.save(updatedOrder); - - // Retrieve the updated order and assert the menus - Optional updatedOrderOptional = orderRestaurantRepository.findById("O01"); - // print the menus - System.out.println("Menus: " + updatedOrderOptional.get().getMenus()); - // assert the menus have been removed - assertThat(updatedOrderOptional).isPresent(); - assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); - assertThat(updatedOrderOptional.get().getMenus()).contains(menuRestaurant1, menuRestaurant3); - assertThat(updatedOrderOptional.get().getMenus()).doesNotContain(menuRestaurant2); - - // Retrieve the updated order after deleting the menu - System.out.println("List of menus AFTER DELETION:"); - menuRestaurantRepository.findAll().forEach(System.out::println); - } - - @Test - public void testRemovingMenus_NO_Relationship() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create an order with multiple menus and save it - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2))); - orderRestaurantRepository.save(order); - - // Retrieve the order, remove a menu, and save the updated order - Optional foundOrder = orderRestaurantRepository.findById("O01"); - assertThat(foundOrder).isPresent(); - - menuRestaurantRepository.delete(menuRestaurant3); - // Retrieve the updated order after deleting the menu - System.out.println("List of menus AFTER DELETION:"); - menuRestaurantRepository.findAll().forEach(System.out::println); - - // We CAN NOT delete a menu that has a relationship - /*menuRestaurantRepository.delete(menuRestaurant2); - // Retrieve the updated order after deleting the menu - System.out.println("List of menus AFTER DELETION:"); - menuRestaurantRepository.findAll().forEach(System.out::println);*/ - - - - } - - // Removing Menus from an Order: Checks that menus can be removed from an order - // and the changes are reflected in the database. - // BE CAREFUL! This test should fail. - @Test - public void testRemovingMenusFromOrder_butNotRelationship() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create an order with multiple menus and save it - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, - 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); - orderRestaurantRepository.save(order); - - // Let's remove the second menu - menuRestaurantRepository.delete(menuRestaurant2); - - // Retrieve the updated order after deleting the menu - System.out.println("List of menus AFTER DELETION:"); - menuRestaurantRepository.findAll().forEach(System.out::println); - - // Retrieve the updated order and assert the menus - Optional updatedOrderOptional = orderRestaurantRepository.findById("O01"); - // print the menus - System.out.println("Menus: " + updatedOrderOptional.get().getMenus()); - // assert the menus have been removed - assertThat(updatedOrderOptional).isPresent(); - assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); - - } - - - // Cascading Deletion of Menus and Orders: Ensures that the deletion of a menu - // or an order correctly cascades to the associated records in the order-menu join table. - /*@Test - public void testCascadingDeletionOfMenusAndOrders() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create an order with multiple menus and save it - OrderRestaurant order = new OrderRestaurant("O01", new Date(), "John", 4, 43.96, true, - new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3))); - orderRestaurantRepository.save(order); - - // Delete the menu and verify the cascade deletion of the order-menu association - Optional foundOrder = orderRestaurantRepository.findById("O01"); - assertThat(foundOrder).isPresent(); - OrderRestaurant updatedOrder = foundOrder.get(); - updatedOrder.removeMenu(menuRestaurant2); - //menuRestaurantRepository.delete(menuRestaurant2); - orderRestaurantRepository.save(updatedOrder); - Optional updatedOrderOptional = orderRestaurantRepository.findById("O01"); - assertThat(updatedOrderOptional).isPresent(); - assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); - assertThat(updatedOrderOptional.get().getMenus()).contains(menuRestaurant1, menuRestaurant3); - assertThat(updatedOrderOptional.get().getMenus()).doesNotContain(menuRestaurant2); - - // Delete the order and verify the cascade deletion of the order-menu association - orderRestaurantRepository.delete(order); - Optional menuRestaurant1Optional = menuRestaurantRepository.findById("M01"); - Optional menuRestaurant2Optional = menuRestaurantRepository.findById("M02"); - Optional menuRestaurant3Optional = menuRestaurantRepository.findById("M03"); - assertThat(menuRestaurant1Optional).isPresent(); - assertThat(menuRestaurant2Optional).isPresent(); - assertThat(menuRestaurant3Optional).isPresent(); - assertThat(menuRestaurant1Optional.get().getOrders()).isEmpty(); - assertThat(menuRestaurant2Optional.get().getOrders()).isEmpty(); - assertThat(menuRestaurant3Optional.get().getOrders()).isEmpty(); - }*/ - - // Adding Menus to an EatInOrder: Verifies that menus can be added - // to an EatInOrderRestaurant and the association is correctly persisted in the database. - /*@Test - public void testAddingMenusToEatInOrder() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false, null); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create sample tables and save them - TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); - TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); - tableRestaurantRepository.save(table1); - tableRestaurantRepository.save(table2); - - // Create an EatInOrder and add menus - EatInOrderRestaurant eatInOrder = new EatInOrderRestaurant("EO1", new Date(), "John", 4, 43.96, true, new ArrayList<>(), new ArrayList<>(Arrays.asList(table1, table2))); - eatInOrder.addMenu(menuRestaurant1); - eatInOrder.addMenu(menuRestaurant2); - eatInOrder.addMenu(menuRestaurant3); - eatInOrderRestaurantRepository.save(eatInOrder); - - // Retrieve the EatInOrder and assert the menus - Optional foundOrder = (Optional) eatInOrderRestaurantRepository.findById("EO1"); - assertThat(foundOrder).isPresent(); - assertThat(foundOrder.get().getMenus()).hasSize(3); - assertThat(foundOrder.get().getMenus()).contains(menuRestaurant1, menuRestaurant2, menuRestaurant3); - } - - // Removing Menus from an EatInOrder: Checks that menus can be removed from an EatInOrder - // and the changes are reflected in the database. - @Test - public void testRemovingMenusFromEatInOrder() { - // Create sample menus and save them - MenuRestaurant menuRestaurant1 = new MenuRestaurant("M01", "Burger Menu", 10.99, "Burger, fries, and drink", true, true, null); - MenuRestaurant menuRestaurant2 = new MenuRestaurant("M02", "Pizza Menu", 12.99, "Pizza and salad", true, false, null); - MenuRestaurant menuRestaurant3 = new MenuRestaurant("M03", "Salad Menu", 8.99, "Mixed salad and dressing", true, true, null); - menuRestaurantRepository.save(menuRestaurant1); - menuRestaurantRepository.save(menuRestaurant2); - menuRestaurantRepository.save(menuRestaurant3); - - // Create sample tables and save them - TableRestaurant table1 = new TableRestaurant("T1", "Window Table", 4, false); - TableRestaurant table2 = new TableRestaurant("T2", "Corner Table", 2, true); - tableRestaurantRepository.save(table1); - tableRestaurantRepository.save(table2); - - // Create an EatInOrder with multiple menus and save it - EatInOrderRestaurant eatInOrder = new EatInOrderRestaurant("EO1", new Date(), "John", 4, 43.96, true, new ArrayList<>(Arrays.asList(menuRestaurant1, menuRestaurant2, menuRestaurant3)), new ArrayList<>(Arrays.asList(table1, table2))); - eatInOrderRestaurantRepository.save(eatInOrder); - - // Retrieve the EatInOrder, remove a menu, and save the updated order - Optional foundOrder = (Optional) eatInOrderRestaurantRepository.findById("EO1"); - assertThat(foundOrder).isPresent(); - EatInOrderRestaurant updatedOrder = foundOrder.get(); - updatedOrder.removeMenu(menuRestaurant2); - orderRestaurantRepository.save(updatedOrder); - - // Retrieve the updated EatInOrder and assert the menus - Optional updatedOrderOptional = (Optional) eatInOrderRestaurantRepository.findById("EO1"); - assertThat(updatedOrderOptional).isPresent(); - assertThat(updatedOrderOptional.get().getMenus()).hasSize(2); - assertThat(updatedOrderOptional.get().getMenus()).contains(menuRestaurant1, menuRestaurant3); - assertThat(updatedOrderOptional.get().getMenus()).doesNotContain(menuRestaurant2); - - }*/ - -}