Merge Feat/perf/ParameterValidator into release/v2.0.0

src/main/java/edu/group5/app/utils/ParameterValidator.java

@@ -0,0 +1,71 @@
+package edu.group5.app.utils;
+
+import java.math.BigDecimal;
+/**
+ * ParameterValidator is a utility class that provides static methods for validating various types of parameters.
+ * It includes methods for checking strings, integers, objects, and BigDecimal values to ensure they meet specific 
+ * criteria such as not being null, not being blank, or being positive.
+ * 
+ */
+public final class ParameterValidator {
+
+  /**
+   * Validates that a string parameter is not null and not blank.
+   * @param stringArg the string parameter to validate
+   * @param variableName the name of the variable being validated, used in exception messages
+   * @throws IllegalArgumentException if the string is null or blank
+   */
+  public static final void stringChecker(String stringArg, String variableName) throws IllegalArgumentException {
+    nullCheck(stringArg, variableName);
+    if (stringArg.isBlank()) {
+      throw new IllegalArgumentException(String.format("%s can't be blank", variableName));
+    }
+  }
+
+  /**
+   * Validates that an integer parameter is not null and is a positive integer.
+   * @param intArg the integer parameter to validate
+   * @param variableName the name of the variable being validated, used in exception messages
+   * @throws IllegalArgumentException if the integer is null or not a positive integer
+   */
+  public static final void intChecker(int intArg, String variableName) throws IllegalArgumentException {
+    if (intArg <= 0) {
+      throw new IllegalArgumentException(String.format("%s must be a positive integer", variableName));
+    }
+  }
+
+  /**
+   * Validates that an object parameter is not null.
+   * @param objectArg the object parameter to validate
+   * @param variableName the name of the variable being validated, used in exception messages
+   * @throws IllegalArgumentException if the object is null
+   */
+  public static final void objectChecker(Object objectArg, String variableName) throws IllegalArgumentException {
+    nullCheck(objectArg, variableName);
+  }
+
+  /**
+   * Validates that a BigDecimal parameter is not null and is greater than zero.
+   * @param bigDecimalArg the BigDecimal parameter to validate
+   * @param variableName the name of the variable being validated, used in exception messages
+   * @throws IllegalArgumentException if the BigDecimal is null or not greater than zero
+   */
+  public static final void bigDecimalChecker(BigDecimal bigDecimalArg, String variableName) throws IllegalArgumentException {
+    nullCheck(bigDecimalArg, variableName);
+    if (bigDecimalArg.compareTo(BigDecimal.ZERO) <= 0) {
+      throw new IllegalArgumentException(String.format("%s must be larger than 0", variableName));
+    }
+  }
+
+  /**
+   * Helper method to check if a variable is null and throw an IllegalArgumentException with a formatted message if it is.
+   * @param variable the variable to check for null
+   * @param variableName the name of the variable being checked, used in the exception message
+   * @throws IllegalArgumentException if the variable is null
+   */
+  private static final void nullCheck(Object variable, String variableName) throws IllegalArgumentException {
+    if (variable == null) {
+      throw new IllegalArgumentException(String.format("%s can't be null", variableName));
+    }
+  }
+}

src/test/java/edu/group5/app/utils/ParameterValidatorTest.java

@@ -0,0 +1,63 @@
+package edu.group5.app.utils;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ParameterValidatorTest {
+
+  @Test
+  void testValidatorDoesNotThrowWithValidParameters() {
+    assertDoesNotThrow(() -> ParameterValidator.stringChecker("valid", "validString"));
+    assertDoesNotThrow(() -> ParameterValidator.intChecker(1, "positiveInt"));
+    assertDoesNotThrow(() -> ParameterValidator.objectChecker(new Object(), "validObject"));
+    assertDoesNotThrow(() -> ParameterValidator.bigDecimalChecker(java.math.BigDecimal.valueOf(1), "positiveBigDecimal"));
+  }
+
+  @Test
+  void testValidatorThrowsWithStringChecker() {
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+      ParameterValidator.stringChecker(null, "nullString");
+    });
+    IllegalArgumentException exception2 = assertThrows(IllegalArgumentException.class, () -> {
+      ParameterValidator.stringChecker("", "emptyString");
+    });
+    IllegalArgumentException exception3 = assertThrows(IllegalArgumentException.class, () -> {
+      ParameterValidator.stringChecker("   ", "blankString");
+    });
+    assertEquals("nullString can't be null", exception.getMessage());
+    assertEquals("emptyString can't be blank", exception2.getMessage());
+    assertEquals("blankString can't be blank", exception3.getMessage());
+  }
+
+  @Test
+  void testValidatorThrowsWithIntChecker() {
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+      ParameterValidator.intChecker(-1, "negativeInt");
+    });
+    assertEquals("negativeInt must be a positive integer", exception.getMessage());
+  }
+
+  @Test
+  void testValidatorThrowsWithObjectChecker() {
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+      ParameterValidator.objectChecker(null, "nullObject");
+    });
+    assertEquals("nullObject can't be null", exception.getMessage());
+  }
+
+  @Test
+  void testValidatorThrowsWithBigDecimalChecker() {
+    IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+      ParameterValidator.bigDecimalChecker(null, "nullBigDecimal");
+    });
+    IllegalArgumentException exception2 = assertThrows(IllegalArgumentException.class, () -> {
+      ParameterValidator.bigDecimalChecker(java.math.BigDecimal.valueOf(-1), "negativeBigDecimal");
+    });
+    IllegalArgumentException exception3 = assertThrows(IllegalArgumentException.class, () -> {
+    ParameterValidator.bigDecimalChecker(java.math.BigDecimal.ZERO, "zeroBigDecimal");
+    });
+    assertEquals("nullBigDecimal can't be null", exception.getMessage());
+    assertEquals("negativeBigDecimal must be larger than 0", exception2.getMessage());
+    assertEquals("zeroBigDecimal must be larger than 0", exception3.getMessage());
+  }
+}