Changes according to the review comments,

Added test cases.

.gitignore

+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+build/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
\ No newline at end of file

build.gradle

@@ -2,7 +2,7 @@ plugins {
     id 'java'
 }
 
-group 'org.example'
+group 'com.retailstore.ordermanagement'
 version '1.0-SNAPSHOT'
 
 repositories {
@@ -19,6 +19,8 @@ dependencies {
     annotationProcessor 'org.projectlombok:lombok:1.18.22'
     // https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api
     testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.8.2'
+// https://mvnrepository.com/artifact/org.mockito/mockito-core
+    testImplementation group: 'org.mockito', name: 'mockito-inline', version: '3.4.4'
 }
 
 test {

src/main/java/com/retailstore/ordermanagement/application/OrderManagement.java

-package com.retail_store.order_management.application;
+package com.retailstore.ordermanagement.application;
 
-import com.retail_store.order_management.service.RetailStore;
-import com.retail_store.order_management.service.RetailStoreService;
+import com.retailstore.ordermanagement.service.RetailStoreService;
+import com.retailstore.ordermanagement.service.RetailStoreServiceImpl;
+import com.retailstore.ordermanagement.utils.DBUtil;
+import lombok.extern.java.Log;
 
+import java.sql.SQLException;
 import java.util.Scanner;
-import java.util.logging.Logger;
 
-import static com.retail_store.order_management.utils.Utility.getInt;
+import static com.retailstore.ordermanagement.utils.InputUtil.validateInputNumber;
 
 /**
  * The project run starts from here
  */
+@Log
 public class OrderManagement {
     private Scanner scanner;
-    private final Logger logger;
 
     /**
      * No-Arg Constructor for class OrderManagement with their private
@@ -23,7 +25,6 @@ public class OrderManagement {
         System.setProperty("java.util.logging.SimpleFormatter.format",
                 "%5$s %n");
         this.scanner = new Scanner(System.in);
-        this.logger = Logger.getLogger(OrderManagement.class.getName());
     }
 
     /**
@@ -40,44 +41,49 @@ public class OrderManagement {
         String enterForMenu = "Please enter 5 for menu";
 
         boolean flag = true;
-        logger.info("Welcome to RetailStore Business Management");
-        RetailStore gap = new RetailStoreService();
+        log.info("Welcome to RetailStore Business Management");
+        RetailStoreService gap = new RetailStoreServiceImpl();
         String menu = "\n------------------------\nMenu\n------------------------\n" +
                 option1 + "\n------------------------\n" +
                 option2 + "\n------------------------\n" +
                 option3 + "\n------------------------\n" +
                 option4;
-        logger.info(menu);
+        log.info(menu);
         while (flag) {
             int menuOption;
-            menuOption = getInt();
+            menuOption = validateInputNumber();
             switch (menuOption) {
                 case 1:
                     gap.addProducts();
-                    logger.info("\n------------------------\nPlease enter 5 for menu\n------------------------\n" +
-                            "To exit please enter 4\n------------------------\n" +
-                            "To Add more enter 1\n------------------------\n");
+                    log.info("\n------------------------\n" + enterForMenu + "\n------------------------\n" +
+                            toExit + "\n------------------------\n" +
+                            toAddMore + "\n------------------------\n");
                     break;
                 case 2:
                     gap.placeOrders();
-                    logger.info("\n------------------------\nPlease enter 5 for menu\n------------------------\n" +
-                            "To exit please enter 4");
+                    log.info("\n------------------------\n" + enterForMenu + "\n------------------------\n" +
+                            toExit);
                     break;
                 case 3:
                     gap.showOrders();
-                    logger.info("\n------------------------\nPlease enter 5 for menu\n------------------------\n" +
-                            "To exit please enter 4");
+                    log.info("\n------------------------\n" + enterForMenu + "\n------------------------\n" +
+                            toExit);
                     break;
                 case 4:
-                    logger.info("Good Bye.");
+                    log.info("Good Bye.");
                     flag = false;
+                    try {
+                        DBUtil.getConnection().close();
+                    } catch (SQLException e) {
+                        log.warning(e.getMessage());
+                    }
                     break;
                 case 5:
-                    logger.info(menu);
+                    log.info(menu);
                     break;
                 default:
-                    logger.warning("\n------------------------\nPlease enter valid menu option\n------------------------\n");
-                    logger.info(menu);
+                    log.warning("\n------------------------\nPlease enter valid menu option\n------------------------\n");
+                    log.info(menu);
             }
         }
     }

src/main/java/com/retailstore/ordermanagement/constants/Category.java

-package com.retail_store.order_management.constants;
+package com.retailstore.ordermanagement.constants;
 
 /**
  * Here using Enum class types as the requirement has constants to

src/main/java/com/retailstore/ordermanagement/constants/Color.java

-package com.retail_store.order_management.constants;
+package com.retailstore.ordermanagement.constants;
 
 /**
  * Enumeration class of name Color

src/main/java/com/retailstore/ordermanagement/constants/Gender.java

-package com.retail_store.order_management.constants;
+package com.retailstore.ordermanagement.constants;
 
 /**
  * Enumeration class of name Gender
@@ -11,7 +11,7 @@ public enum Gender {
      */
     EXIT(0, "exit"), MEN(1, "Men"), WOMEN(2, "Women");
     int option;
-    String gender;
+    String getName;
 
     /**
      * Method is used to return option value
@@ -30,7 +30,7 @@ public enum Gender {
      * @return
      */
     public String getGender() {
-        return gender;
+        return getName;
     }
 
     /**
@@ -41,6 +41,6 @@ public enum Gender {
      */
     Gender(int option, String gender) {
         this.option = option;
-        this.gender = gender;
+        this.getName = gender;
     }
 }

src/main/java/com/retailstore/ordermanagement/constants/Size.java

-package com.retail_store.order_management.constants;
+package com.retailstore.ordermanagement.constants;
 
 /**
  * Enumeration class name Size

src/main/java/com/retailstore/ordermanagement/model/Order.java

-package com.retail_store.order_management.model;
+package com.retailstore.ordermanagement.model;
 
 import lombok.AllArgsConstructor;
 import lombok.Builder;

src/main/java/com/retailstore/ordermanagement/model/OrderedProduct.java

-package com.retail_store.order_management.model;
+package com.retailstore.ordermanagement.model;
 
 
-import com.retail_store.order_management.constants.Category;
-import com.retail_store.order_management.constants.Color;
-import com.retail_store.order_management.constants.Gender;
-import com.retail_store.order_management.constants.Size;
+import com.retailstore.ordermanagement.constants.Category;
+import com.retailstore.ordermanagement.constants.Color;
+import com.retailstore.ordermanagement.constants.Gender;
+import com.retailstore.ordermanagement.constants.Size;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 

src/main/java/com/retailstore/ordermanagement/model/Product.java

-package com.retail_store.order_management.model;
+package com.retailstore.ordermanagement.model;
 
 
-import com.retail_store.order_management.constants.Category;
-import com.retail_store.order_management.constants.Color;
-import com.retail_store.order_management.constants.Gender;
-import com.retail_store.order_management.constants.Size;
+import com.retailstore.ordermanagement.constants.Category;
+import com.retailstore.ordermanagement.constants.Color;
+import com.retailstore.ordermanagement.constants.Gender;
+import com.retailstore.ordermanagement.constants.Size;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 

src/main/java/com/retailstore/ordermanagement/service/ProductService.java

@@ -14,7 +14,7 @@ import java.util.Map;
  * This is an interface to filter the products according to
  * respective of taken methods in this interface
  */
-public interface ProductFilter {
+public interface ProductService {
     /**
      * This is an abstract method gives the
      * categories of product according selection of gender type

src/main/java/com/retailstore/ordermanagement/service/RetailStoreService.java

@@ -12,7 +12,7 @@ import java.util.Collection;
  * In this interface there present different abstract methods to perform
  * various functions of the project
  */
-public interface RetailStore {
+public interface RetailStoreService {
     /**
      * This abstract method is used to add the products seemly according to the
      * given process in the console, if added then shows message accordingly

src/main/java/com/retailstore/ordermanagement/utils/DBUtil.java

@@ -9,14 +9,14 @@ import java.sql.SQLException;
  * This is a final class in which all the configurations of the database are present to
  * establish the connection to the database to the project
  */
-public final class Database {
+public final class DBUtil {
     private static Connection connection;
 
     /**
      * Private constructor that will not
      * allow to create object
      */
-    private Database() {
+    private DBUtil() {
     }
 
     /**

src/main/java/com/retailstore/ordermanagement/utils/InputUtil.java

 package com.retailstore.ordermanagement.utils;
 
-import com.retailstore.ordermanagement.application.OrderManagement;
 import com.retailstore.ordermanagement.constants.Category;
 import com.retailstore.ordermanagement.constants.Color;
 import com.retailstore.ordermanagement.constants.Gender;
 import com.retailstore.ordermanagement.constants.Size;
 import com.retailstore.ordermanagement.model.Order;
 import com.retailstore.ordermanagement.service.RetailStoreService;
+import lombok.extern.java.Log;
 
 import java.util.*;
 import java.util.logging.Logger;
@@ -17,14 +17,15 @@ import java.util.logging.Logger;
  * Class used to import the values of the option given in the console and print accordingly
  * of the required choice chosen
  */
-public class Utility {
+@Log
+public class InputUtil {
     private static final Scanner SCANNER = null;
     private static final Logger LOGGER = null;
 
     /**
      * No argument constructor
      */
-    private Utility() {
+    private InputUtil() {
     }
 
     /**
@@ -38,11 +39,11 @@ public class Utility {
         Category categoryValue;
         String categoryOptions = Arrays.stream(Category.values()).filter(category -> !category.equals(Category.EXIT)).map(category -> "(" + category.getOption() + ")" + category).reduce((categories, category) -> categories + " " + category).get() + "\nPress 0 to go back.";
         if (check) {
-            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
+            log.info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
         }
         int option = validateInputNumber();
         categoryValue = Arrays.stream(Category.values()).filter(category -> category.getOption() == option).findFirst().orElseGet(() -> {
-            getLogger().info("\n------------------------\n+Please enter valid category\n------------------------\n" + categoryOptions + "\n------------------------\n");
+            log.info("\n------------------------\n+Please enter valid category\n------------------------\n" + categoryOptions + "\n------------------------\n");
             return getCategory(false, message);
         });
         return categoryValue.equals(Category.EXIT) ? null : categoryValue;
@@ -59,11 +60,11 @@ public class Utility {
         Size sizeValue;
         String categoryOptions = Arrays.stream(Size.values()).filter(size -> !size.equals(Size.EXIT)).map(size -> "(" + size.getOption() + ")" + size).reduce((sizes, size) -> sizes + " " + size).get() + "\nPress 0 to go back.";
         if (check) {
-            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
+            log.info("\n------------------------\n" + message + "\n------------------------\n" + categoryOptions + "\n------------------------\n");
         }
         int option = validateInputNumber();
         sizeValue = Arrays.stream(Size.values()).filter(size -> size.getOption() == option).findFirst().orElseGet(() -> {
-            getLogger().info("\n------------------------\nPlease enter valid category\n------------------------\n" + categoryOptions + "\n------------------------\n");
+            log.info("\n------------------------\nPlease enter valid category\n------------------------\n" + categoryOptions + "\n------------------------\n");
             return getSize(false, message);
         });
         return sizeValue.equals(Size.EXIT) ? null : sizeValue;
@@ -80,11 +81,11 @@ public class Utility {
         Gender genderValue;
         String genderOptions = Arrays.stream(Gender.values()).filter(gender -> !gender.equals(Gender.EXIT)).map(gender -> "(" + gender.getOption() + ")" + gender).reduce((genders, gender) -> genders + " " + gender).get() + "\nPress 0 to go back.";
         if (check) {
-            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + genderOptions + "\n------------------------\n");
+            log.info("\n------------------------\n" + message + "\n------------------------\n" + genderOptions + "\n------------------------\n");
         }
         int option = validateInputNumber();
         genderValue = Arrays.stream(Gender.values()).filter(gender -> gender.getOption() == option).findFirst().orElseGet(() -> {
-            getLogger().info("\n------------------------\nPlease enter valid gender\n------------------------\n" + genderOptions + "\n------------------------\n");
+            log.info("\n------------------------\nPlease enter valid gender\n------------------------\n" + genderOptions + "\n------------------------\n");
             return getGender(false, message);
         });
         return genderValue.equals(Gender.EXIT) ? null : genderValue;
@@ -101,11 +102,11 @@ public class Utility {
         Color colorValue;
         String colorOptions = Arrays.stream(Color.values()).filter(color -> !color.equals(Color.EXIT)).map(color -> "(" + color.getOption() + ")" + color).reduce((categories, category) -> categories + " " + category).get() + "\nPress 0 to go back.";
         if (check) {
-            getLogger().info("\n------------------------\n" + message + "\n------------------------\n" + colorOptions + "\n------------------------\n");
+            log.info("\n------------------------\n" + message + "\n------------------------\n" + colorOptions + "\n------------------------\n");
         }
         int option = validateInputNumber();
         colorValue = Arrays.stream(Color.values()).filter(color -> color.getOption() == option).findFirst().orElseGet(() -> {
-            getLogger().info("\n------------------------\n+Please enter valid color\n------------------------\n" + colorOptions + "\n------------------------\n");
+            log.info("\n------------------------\n+Please enter valid color\n------------------------\n" + colorOptions + "\n------------------------\n");
             return getColor(false, message);
         });
         return colorValue.equals(Color.EXIT) ? null : colorValue;
@@ -123,7 +124,7 @@ public class Utility {
         double number;
         Scanner scanner = new Scanner(System.in);
         if (flag) {
-            getLogger().info(message);
+            log.info(message);
         }
         try {
             number = scanner.nextDouble();
@@ -132,7 +133,7 @@ public class Utility {
             }
             return number;
         } catch (InputMismatchException e) {
-            getLogger().warning("\n------------------------\nPlease enter valid price\n------------------------\n");
+            log.warning("\n------------------------\nPlease enter valid price\n------------------------\n");
             scanner.reset();
             return validateInputPrice(false, message);
         }
@@ -154,7 +155,7 @@ public class Utility {
             }
             return number;
         } catch (Exception e) {
-            getLogger().warning(e.getMessage() + "\n------------------------\nPlease enter valid number\n------------------------\n");
+            log.warning(e.getMessage() + "\n------------------------\nPlease enter valid number\n------------------------\n");
             scanner.reset();
             return validateInputNumber();
         }
@@ -174,22 +175,14 @@ public class Utility {
             if (phoneNumber == null || phoneNumber.isBlank() || phoneNumber.isEmpty() || phoneNumber.length() != 10) {
                 throw new RuntimeException("Please enter valid number");
             }
+            Long.parseLong(phoneNumber);
         } catch (Exception e) {
-            getLogger().warning("Please enter valid phone number");
+            log.warning("Please enter valid phone number");
             return phoneNumberValidator();
         }
         return phoneNumber;
     }
 
-    /**
-     * This method is used to create a singleton
-     * logger object that is used throughout the application
-     *
-     * @return
-     */
-    public static Logger getLogger() {
-        return LOGGER == null ? Logger.getLogger(OrderManagement.class.getName()) : LOGGER;
-    }
 
     /**
      * This method is used to create a singleton
@@ -201,6 +194,10 @@ public class Utility {
         return SCANNER == null ? new Scanner(System.in) : SCANNER;
     }
 
+    public static String getScannerLine() {
+        return getScanner().nextLine();
+    }
+
     /**
      * This method is used to give a valid number that present in the stock range
      *
@@ -208,15 +205,15 @@ public class Utility {
      */
     public static Map<Size, Integer> getProductSizes() {
         Map<Size, Integer> productSizes = new LinkedHashMap<>();
-        getLogger().info("Please enter the available stock for particular sizes \n Number of products with size S");
+        log.info("Please enter the available stock for particular sizes \n Number of products with size S");
         productSizes.put(Size.S, validateInputNumber());
-        getLogger().info("Number of products with size M");
+        log.info("Number of products with size M");
         productSizes.put(Size.M, validateInputNumber());
-        getLogger().info("Number of products with size L");
+        log.info("Number of products with size L");
         productSizes.put(Size.L, validateInputNumber());
-        getLogger().info("Number of products with size XL");
+        log.info("Number of products with size XL");
         productSizes.put(Size.XL, validateInputNumber());
-        getLogger().info("Number of products with size XXL");
+        log.info("Number of products with size XXL");
         productSizes.put(Size.XXL, validateInputNumber());
         return productSizes;
     }

src/test/java/com/retailstore/ordermanagement/service/ProductServiceTest.java

@@ -11,17 +11,20 @@ import org.junit.jupiter.api.Test;
 import org.mockito.Mock;
 
 import java.sql.Connection;
-import java.util.*;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
 import java.util.stream.Collectors;
 
-class ProductFilterTest {
+class ProductServiceTest {
     @Mock
     Connection connection;
-    RetailStoreService service;
+    RetailStoreServiceImpl service;
 
     @BeforeEach
     void createretailsStoreObject() {
-        service = new RetailStoreService();
+        service = new RetailStoreServiceImpl();
     }
 
     @AfterEach
@@ -31,7 +34,7 @@ class ProductFilterTest {
 
     @Test
     void getCategoriesByGenderTest() {
-        Map<Integer, Category> categoryMap = new HashMap<>();
+        Map<Integer, Category> categoryMap = new LinkedHashMap<>();
         categoryMap.put(1, Category.SWEATSHIRTS);
         categoryMap.put(2, Category.T_SHIRTS);
         categoryMap.put(3, Category.SHIRTS);
@@ -57,7 +60,7 @@ class ProductFilterTest {
 
     @Test
     void getColorsByGenderAndCategoryTest() {
-        Map<Integer, Color> colorMap = new HashMap<>();
+        Map<Integer, Color> colorMap = new LinkedHashMap<>();
         colorMap.put(1, Color.BLUE);
         colorMap.put(2, Color.GREY);
         colorMap.put(3, Color.BLACK);
@@ -69,7 +72,7 @@ class ProductFilterTest {
     @Test
     void getOrdersTest() {
         List<Order> orderList = new ArrayList<>();
-        Map<Integer, Order> ordersMap = new HashMap<>();
+        Map<Integer, Order> ordersMap = new LinkedHashMap<>();
         Assertions.assertEquals(ordersMap, service.getOrders(connection));
     }
 }
\ No newline at end of file

src/test/java/com/retailstore/ordermanagement/service/RetailStoreServiceTest.java

@@ -4,83 +4,49 @@ import com.retailstore.ordermanagement.constants.Category;
 import com.retailstore.ordermanagement.constants.Color;
 import com.retailstore.ordermanagement.constants.Gender;
 import com.retailstore.ordermanagement.constants.Size;
-import com.retailstore.ordermanagement.model.Order;
-import com.retailstore.ordermanagement.model.OrderedProduct;
-import com.retailstore.ordermanagement.utils.Utility;
-import org.junit.jupiter.api.AfterEach;
+import com.retailstore.ordermanagement.utils.InputUtil;
 import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.MockedStatic;
 import org.mockito.Mockito;
-import org.mockito.Spy;
 
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
 import java.sql.Connection;
 import java.time.LocalDate;
 import java.time.LocalTime;
-import java.util.ArrayList;
 import java.util.LinkedHashMap;
-import java.util.List;
 import java.util.Map;
+import java.util.Scanner;
 
-class RetailStoreTest {
+class RetailStoreServiceTest {
     @Mock
     Connection connection;
-    RetailStoreService service;
-    @Spy
-    @InjectMocks
-    Utility utility;
-
-    @BeforeEach
-    void createretailsStoreObject() {
-        service = new RetailStoreService();
-    }
-
-    @AfterEach
-    void removeretailsStoreObject() {
-        service = null;
-    }
+    RetailStoreServiceImpl service;
 
     @Test
     void addProducts() {
-        LinkedHashMap<Size, Integer> sizeMap = new LinkedHashMap<>();
+        Scanner scanner = Mockito.mock(Scanner.class);
+        Map<Size, Integer> sizeMap = new LinkedHashMap<>();
         sizeMap.put(Size.S, 2);
         sizeMap.put(Size.M, 2);
         sizeMap.put(Size.L, 2);
         sizeMap.put(Size.XL, 2);
         sizeMap.put(Size.XXL, 2);
-        Mockito.when(utility.productIdGenerator()).thenReturn("TestMethod" + LocalDate.now() + LocalTime.now());
-        Mockito.when(Utility.getScanner().nextLine()).thenReturn("TestProduct");
-        Mockito.when(Utility.getCategory(true, "Test check")).thenReturn(Category.JEANS);
-        Mockito.when(Utility.getColor(true, "Test check")).thenReturn(Color.BLACK);
-        Mockito.when(Utility.getGender(true, "Test check")).thenReturn(Gender.WOMEN);
-        Mockito.when(Utility.getDouble(true, "Test price")).thenReturn(1350.00);
-        Mockito.when(Utility.getProductSizes()).thenReturn(sizeMap);
-        Assertions.assertEquals(true, service.addProducts());
-    }
-
-    @Test
-    void placeOrders() {
-
+        try (MockedStatic<InputUtil> inputUtil = Mockito.mockStatic(InputUtil.class)) {
+
+            inputUtil.when(() -> InputUtil.productIdGenerator()).thenReturn("TestMethod" + LocalDate.now() + LocalTime.now());
+            String input = "Test Input";
+            InputStream in = new ByteArrayInputStream(input.getBytes());
+            System.setIn(in);
+            inputUtil.when(() -> InputUtil.validateInputNumber()).thenReturn(2);
+            inputUtil.when(() -> InputUtil.getCategory(true, "Test check")).thenReturn(Category.JEANS);
+            inputUtil.when(() -> InputUtil.getColor(true, "Test check")).thenReturn(Color.BLACK);
+            inputUtil.when(() -> InputUtil.getGender(true, "Test check")).thenReturn(Gender.WOMEN);
+            inputUtil.when(() -> InputUtil.validateInputPrice(true, "Test price")).thenReturn(1350.00);
+            inputUtil.when(() -> InputUtil.getProductSizes()).thenReturn(sizeMap);
         }
-
-    @Test
-    void showOrdersTest() {
-        Map<Integer, Order> ordersMap = Mockito.mock(LinkedHashMap.class);
-        List<OrderedProduct> orderedProductList = Mockito.mock(ArrayList.class);
-        ordersMap.put(1, new Order("10bc46f3#Order", LocalDate.now(), LocalTime.now(), "Customer", "9633214574", 2500.00, new ArrayList<OrderedProduct>()));
-        Mockito.when(service.getOrders(connection)).thenReturn(ordersMap);
-    }
-
-    @Test
-    void createOrder() {
-        ArrayList<OrderedProduct> orderedProducts = new ArrayList<>();
-        orderedProducts.add(new OrderedProduct("test1", "testname", Category.JEANS, Color.BLACK, 1200.00, Gender.MEN, Size.L, 2));
-//        Mockito.when(getGender(true, "Test check")).thenReturn(Gender.WOMEN);
-    }
-
-    @Test
-    void addProductToCart() {
+        Assertions.assertEquals(true, service.addProducts());
     }
 }
\ No newline at end of file