diff --git a/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java
new file mode 100644
index 0000000..c0331a7
--- /dev/null
+++ b/src/main/java/dev/example/restaurantManager/controller/MenuItemController.java
@@ -0,0 +1,51 @@
+package dev.example.restaurantManager.controller;
+
+import dev.example.restaurantManager.model.MenuItem;
+import dev.example.restaurantManager.service.MenuItemService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/menu-items")
+public class MenuItemController {
+    private final MenuItemService menuItemService;
+
+    public MenuItemController(MenuItemService menuItemService) {
+        this.menuItemService = menuItemService;
+    }
+
+    @PostMapping
+    public ResponseEntity<MenuItem> createMenuItem(@RequestBody MenuItem menuItem) {
+        MenuItem created = menuItemService.createMenuItem(menuItem);
+        return new ResponseEntity<>(created, HttpStatus.CREATED);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<MenuItem> getMenuItem(@PathVariable String id) {
+        return menuItemService.getMenuItemById(id)
+                .map(item -> new ResponseEntity<>(item, HttpStatus.OK))
+                .orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));
+    }
+
+    @GetMapping
+    public ResponseEntity<List<MenuItem>> getAllMenuItems() {
+        List<MenuItem> items = menuItemService.getAllMenuItems();
+        return new ResponseEntity<>(items, HttpStatus.OK);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<MenuItem> updateMenuItem(@PathVariable String id, @RequestBody MenuItem menuItem) {
+        menuItem.setId(Long.valueOf(id));
+        MenuItem updated = menuItemService.updateMenuItem(menuItem);
+        return new ResponseEntity<>(updated, HttpStatus.OK);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteMenuItem(@PathVariable String id) {
+        menuItemService.deleteMenuItem(id);
+        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
+    }
+}
diff --git a/src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java b/src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java
new file mode 100644
index 0000000..5c8465a
--- /dev/null
+++ b/src/main/java/dev/example/restaurantManager/controller/MenuRestaurantController.java
@@ -0,0 +1,64 @@
+package dev.example.restaurantManager.controller;
+
+import dev.example.restaurantManager.model.MenuRestaurant;
+import dev.example.restaurantManager.model.MenuItem;
+import dev.example.restaurantManager.service.MenuRestaurantService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/menus-restaurant")
+public class MenuRestaurantController {
+    private final MenuRestaurantService menuRestaurantService;
+
+    public MenuRestaurantController(MenuRestaurantService menuRestaurantService) {
+        this.menuRestaurantService = menuRestaurantService;
+    }
+
+    @PostMapping
+    public ResponseEntity<MenuRestaurant> createMenu(@RequestBody MenuRestaurant menuRestaurant) {
+        MenuRestaurant created = menuRestaurantService.createMenu(menuRestaurant);
+        return new ResponseEntity<>(created, HttpStatus.CREATED);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<MenuRestaurant> getMenu(@PathVariable String id) {
+        return menuRestaurantService.getMenuById(id)
+                .map(menu -> new ResponseEntity<>(menu, HttpStatus.OK))
+                .orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));
+    }
+
+    @GetMapping
+    public ResponseEntity<List<MenuRestaurant>> getAllMenus() {
+        List<MenuRestaurant> menus = menuRestaurantService.getAllMenus();
+        return new ResponseEntity<>(menus, HttpStatus.OK);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<MenuRestaurant> updateMenu(@PathVariable String id, @RequestBody MenuRestaurant menuRestaurant) {
+        menuRestaurant.setId(id);
+        MenuRestaurant updated = menuRestaurantService.updateMenu(menuRestaurant);
+        return new ResponseEntity<>(updated, HttpStatus.OK);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteMenu(@PathVariable String id) {
+        menuRestaurantService.deleteMenu(id);
+        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
+    }
+
+    @PostMapping("/{menuId}/items")
+    public ResponseEntity<Void> addMenuItemToMenu(@PathVariable String menuId, @RequestBody MenuItem menuItem) {
+        menuRestaurantService.addMenuItemToMenu(menuId, menuItem);
+        return new ResponseEntity<>(HttpStatus.CREATED);
+    }
+
+    @GetMapping("/{menuId}/items")
+    public ResponseEntity<List<MenuItem>> getMenuItems(@PathVariable String menuId) {
+        List<MenuItem> items = menuRestaurantService.getMenuItems(menuId);
+        return new ResponseEntity<>(items, HttpStatus.OK);
+    }
+}
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/MenuItem.java b/src/main/java/dev/example/restaurantManager/model/MenuItem.java
new file mode 100644
index 0000000..572519a
--- /dev/null
+++ b/src/main/java/dev/example/restaurantManager/model/MenuItem.java
@@ -0,0 +1,80 @@
+package dev.example.restaurantManager.model;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.GenericGenerator;
+
+import java.awt.*;
+import java.util.*;
+import java.util.List;
+
+@Entity
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+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<MenuRestaurant> 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 +
+                '}';
+    }
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        MenuItem menuItem = (MenuItem) o;
+        return isSpicy == menuItem.isSpicy &&
+                hasGluten == menuItem.hasGluten &&
+                isAvailable == menuItem.isAvailable &&
+                Objects.equals(id, menuItem.id) &&
+                Objects.equals(name, menuItem.name) &&
+                Objects.equals(description, menuItem.description) &&
+                courseType == menuItem.courseType;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, name, description, isSpicy, hasGluten, isAvailable, courseType);
+    }
+
+}
+
diff --git a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java
index 1d2d819..a122ea1 100644
--- a/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java
+++ b/src/main/java/dev/example/restaurantManager/model/MenuRestaurant.java
@@ -1,20 +1,20 @@
 package dev.example.restaurantManager.model;
 
-import jakarta.persistence.Entity;
-import jakarta.persistence.FetchType;
-import jakarta.persistence.Id;
-import jakarta.persistence.ManyToMany;
+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;
@@ -27,6 +27,15 @@ public class MenuRestaurant  {
     @ManyToMany(mappedBy = "menus", fetch = FetchType.LAZY)
     private List<OrderRestaurant> orders = new ArrayList<>();
 
+    @Getter
+    @ManyToMany(fetch = FetchType.EAGER)
+    @JoinTable(
+            name = "menu_restaurant_menu_item",
+            joinColumns = @JoinColumn(name = "menu_restaurant_id"),
+            inverseJoinColumns = @JoinColumn(name = "menu_item_id")
+    )
+    private List<MenuItem> menuItems = new ArrayList<>();
+
     public MenuRestaurant(String id, String name, Double price, String content, boolean active, boolean water) {
         this.id = id;
         this.name = name;
@@ -34,9 +43,31 @@ public MenuRestaurant(String id, String name, Double price, String content, bool
         this.content = content;
         this.active = active;
         this.water = water;
+        this.orders = new ArrayList<>();
+        this.menuItems = new ArrayList<>();
+    }
+
+    public void addMenuItem(MenuItem menuItem) {
+        this.menuItems.add(menuItem);
+        menuItem.getMenus().add(this);
+    }
+
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        MenuRestaurant that = (MenuRestaurant) o;
+        return Objects.equals(id, that.id) &&
+                Objects.equals(name, that.name);
     }
 
-    //We  might want to exclude 'orders' from toString() to avoid circular references
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, name);
+    }
+
+    // We might want to exclude 'orders' from toString() to avoid circular references
     @Override
     public String toString() {
         return "MenuRestaurant{" +
@@ -47,9 +78,10 @@ public String toString() {
                 ", active=" + active +
                 ", water=" + water +
                 ", ordersCount=" + (orders != null ? orders.size() : 0) +
-                ", orders=" + orders +
+                ", orders=" + orders + '\'' +
+                ", menuItemsCount=" + + (menuItems != null ? menuItems.size() : 0) +
+              //  ", menuItems=" + menuItems +
                 '}';
     }
 
 }
-
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<MenuItem, String> {
+}
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<MenuItem> getMenuItemById(String id);
+
+    List<MenuItem> 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..d8822d9
--- /dev/null
+++ b/src/main/java/dev/example/restaurantManager/service/MenuItemServiceImpl.java
@@ -0,0 +1,43 @@
+package dev.example.restaurantManager.service.impl;
+
+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<MenuItem> getMenuItemById(String id) {
+        return menuItemRepository.findById(id);
+    }
+
+    @Override
+    public List<MenuItem> 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..7ece340
--- /dev/null
+++ b/src/main/java/dev/example/restaurantManager/service/MenuRestaurantService.java
@@ -0,0 +1,24 @@
+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<MenuRestaurant> getMenuById(String id);
+
+    List<MenuRestaurant> getAllMenus();
+
+    MenuRestaurant updateMenu(MenuRestaurant menuRestaurant);
+
+    void deleteMenu(String id);
+
+    void addMenuItemToMenu(String menuId, MenuItem menuItem);
+
+    List<MenuItem> 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<MenuRestaurant> getMenuById(String id) {
+        return menuRestaurantRepository.findById(id);
+    }
+
+    @Override
+    public List<MenuRestaurant> 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<MenuRestaurant> menuRestaurantOpt = menuRestaurantRepository.findById(menuId);
+        if (menuRestaurantOpt.isPresent()) {
+            MenuRestaurant menuRestaurant = menuRestaurantOpt.get();
+            menuRestaurant.addMenuItem(menuItem);
+            menuRestaurantRepository.save(menuRestaurant);
+        }
+    }
+
+    @Override
+    public List<MenuItem> getMenuItems(String menuId) {
+        Optional<MenuRestaurant> menuRestaurantOpt = menuRestaurantRepository.findById(menuId);
+        return menuRestaurantOpt.map(MenuRestaurant::getMenuItems).orElse(null);
+    }
+}
+
diff --git a/src/test/java/dev/example/restaurantManager/MenuAndMenuItemServiceTest.java b/src/test/java/dev/example/restaurantManager/MenuAndMenuItemServiceTest.java
new file mode 100644
index 0000000..b27f9be
--- /dev/null
+++ b/src/test/java/dev/example/restaurantManager/MenuAndMenuItemServiceTest.java
@@ -0,0 +1,99 @@
+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.repository.MenuItemRepository;
+import dev.example.restaurantManager.repository.MenuRestaurantRepository;
+import dev.example.restaurantManager.service.MenuItemService;
+import dev.example.restaurantManager.service.MenuRestaurantService;
+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 java.util.List;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@SpringBootTest
+public class MenuAndMenuItemServiceTest {
+
+    @Autowired
+    private MenuRestaurantService menuRestaurantService;
+
+    @Autowired
+    private MenuItemService menuItemService;
+
+    @Autowired
+    private MenuRestaurantRepository menuRestaurantRepository;
+
+    @Autowired
+    private MenuItemRepository menuItemRepository;
+
+    private MenuRestaurant testMenu;
+    private MenuRestaurant testMenu2;
+    private MenuItem testItem;
+
+    @BeforeEach
+    public void setup() {
+        testMenu = new MenuRestaurant("1", "Lunch Menu", 19.99, "Main course and dessert", true, false);
+        testMenu2 = new MenuRestaurant("2", "Dinner Menu", 19.99, "Main course and dessert", true, false);
+        testItem = new MenuItem("Burger", "Beef burger with cheese", false, true, true, CourseType.MAIN);
+    }
+
+    @Test
+    public void createMenuRestaurantTest() {
+        MenuRestaurant createdMenu = menuRestaurantService.createMenu(testMenu);
+
+        assertThat(createdMenu).isNotNull();
+        assertThat(createdMenu.getId()).isNotNull();
+        assertThat(createdMenu.getName()).isEqualTo(testMenu.getName());
+    }
+
+    @Test
+    public void createMenuItemTest() {
+        MenuItem createdItem = menuItemService.createMenuItem(testItem);
+
+        assertThat(createdItem).isNotNull();
+        assertThat(createdItem.getId()).isNotNull();
+        assertThat(createdItem.getName()).isEqualTo(testItem.getName());
+    }
+
+    @Test
+    public void getAllMenusTest() {
+        menuRestaurantService.createMenu(testMenu);
+        menuRestaurantService.createMenu(testMenu2);
+
+        List<MenuRestaurant> allMenus = menuRestaurantService.getAllMenus();
+        assertThat(allMenus).isNotEmpty();
+        assertThat(allMenus).extracting(MenuRestaurant::getName).contains("Lunch Menu", "Dinner Menu");
+    }
+
+    @Test
+    public void addMenuItemToMenuTest() {
+        MenuRestaurant savedMenu = menuRestaurantService.createMenu(testMenu);
+        MenuItem savedItem = menuItemService.createMenuItem(testItem);
+
+        menuRestaurantService.addMenuItemToMenu(savedMenu.getId(), savedItem);
+
+        Optional<MenuRestaurant> updatedMenu = menuRestaurantService.getMenuById(savedMenu.getId());
+        assertThat(updatedMenu.get().getMenuItems()).contains(savedItem);
+    }
+
+    @Test
+    public void getMenuItemsFromMenuTest() {
+        MenuRestaurant savedMenu = menuRestaurantService.createMenu(testMenu);
+        MenuItem savedItem1 = menuItemService.createMenuItem(new MenuItem("Pasta", "Spaghetti with tomato sauce", false, false, true, CourseType.MAIN));
+        MenuItem savedItem2 = menuItemService.createMenuItem(new MenuItem("Ice Cream", "Vanilla ice cream", false, false, true, CourseType.DESSERT));
+
+        menuRestaurantService.addMenuItemToMenu(savedMenu.getId(), savedItem1);
+        menuRestaurantService.addMenuItemToMenu(savedMenu.getId(), savedItem2);
+
+        List<MenuItem> menuItems = menuRestaurantService.getMenuItems(savedMenu.getId());
+        assertThat(menuItems).contains(savedItem1, savedItem2);
+    }
+
+
+}
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<MenuRestaurant> 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<MenuItem> 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<MenuRestaurant> 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<MenuRestaurant> menuFound = menuRestaurantRepository.findById("M01");
+                System.out.println("--------------------");
+                System.out.println("Menu ID: " + menuFound.get().getId());
+
+                Optional<MenuItem> 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<MenuItem> 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
index a3c8f84..f9d9d59 100644
--- a/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java
+++ b/src/test/java/dev/example/restaurantManager/RelationshipsOrderRestaurantTest.java
@@ -29,9 +29,9 @@ public class RelationshipsOrderRestaurantTest {
         @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);
+                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);
@@ -115,9 +115,9 @@ public void TestCreateOrder() {
 
         @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);
+                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);