chore: Improve test coverage and leverage parametrized tests more

Author: en-milie

pom.xml

@@ -35,7 +35,8 @@
         <sonar.coverage.exclusions>
             **/*TestCaseExporter*.*, **/*CatsTestCase*.*, **/*CatsTestReport*.*, **/*Aspect*.*, **/*CatsMain*.*,
             **/*VersionProvider*.*, **/*ReflectionConfig*.*,**/*TimeExecution*.*, **/*FormEncoder*.*,
-            **/*HttpContent*.*, **/*MultipartProcessor*.*, **Entry.*, **/*ConsoleUtils*.*, **/*Mutator*.*,**/*ModelUtils.*
+            **/*HttpContent*.*, **/*MultipartProcessor*.*, **Entry.*, **/*ConsoleUtils*.*, **/*Mutator*.*,**/*ModelUtils.*,
+            **/*HttpHeaders*.*
         </sonar.coverage.exclusions>
         <sonar.cpd.exclusions>**/*Generator*.*,**/*Fuzzer*.*</sonar.cpd.exclusions>
         <sonar.coverage.jacoco.xmlReportPaths>target/jacoco-report/jacoco.xml</sonar.coverage.jacoco.xmlReportPaths>

src/main/java/com/endava/cats/generator/format/api/FormatGeneratorUtil.java

@@ -117,7 +117,7 @@ public static String generateFromPattern(String pattern) {
      * @return random number
      */
     public static int randomNumber(int digits) {
-        int min = (int) Math.pow(10, digits - 1);
+        int min = (int) Math.pow(10, digits - 1d);
         int max = (int) Math.pow(10, digits);
         return randomInRange(min, max);
     }

src/main/java/com/endava/cats/generator/format/impl/CronExpressionGenerator.java

@@ -4,7 +4,6 @@
 import com.endava.cats.generator.format.api.OpenAPIFormat;
 import com.endava.cats.generator.format.api.PropertySanitizer;
 import com.endava.cats.generator.format.api.ValidDataFormatGenerator;
-import com.endava.cats.util.CatsRandom;
 import com.endava.cats.util.CatsUtil;
 import io.swagger.v3.oas.models.media.Schema;
 import jakarta.inject.Singleton;
@@ -47,7 +46,7 @@ public List<String> matchingFormats() {
     @Override
     public Object generate(Schema<?> schema) {
         String generated = CatsUtil.selectRandom(COMMON_CRON_EXPRESSIONS);
-        
+
         return DataFormat.matchesPatternOrNull(schema, generated);
     }
 }

src/main/java/com/endava/cats/util/CatsFaker.java

@@ -344,7 +344,6 @@ public class CompanyFaker {
         public String name() {
             Map<String, Object> companyData = (Map<String, Object>) data.get("company");
             List<String> suffixes = (List<String>) companyData.get("suffix");
-            NameFaker nameFaker = new NameFaker();
             return nameFaker.lastName() + " " + randomElement(suffixes);
         }
 

src/main/java/com/endava/cats/util/HttpHeaders.java

@@ -9,4 +9,8 @@ public final class HttpHeaders {
     public static final String USER_AGENT = "User-Agent";
     public static final String CONTENT_LENGTH = "Content-Length";
     public static final String TRANSFER_ENCODING = "Transfer-Encoding";
+
+    private HttpHeaders() {
+        //ntd
+    }
 }

src/main/java/com/endava/cats/util/JsonUtils.java

@@ -254,14 +254,14 @@ public static boolean equalAsJson(String json1, String json2) {
             JsonNode n1 = SIMPLE_OBJECT_MAPPER.readTree(json1);
             JsonNode n2 = SIMPLE_OBJECT_MAPPER.readTree(json2);
             return n1.equals(n2); // object key order does NOT matter
-        } catch (Exception e1) {
+        } catch (Exception _) {
             try {
                 String j1 = StringEscapeUtils.unescapeJson(json1).replaceAll("(^[\"'])|([\"']$)", "");
                 String j2 = StringEscapeUtils.unescapeJson(json2).replaceAll("(^[\"'])|([\"']$)", "");
                 JsonNode n1 = SIMPLE_OBJECT_MAPPER.readTree(j1);
                 JsonNode n2 = SIMPLE_OBJECT_MAPPER.readTree(j2);
                 return n1.equals(n2);
-            } catch (Exception e2) {
+            } catch (Exception _) {
                 return json1.equalsIgnoreCase(json2);
             }
         }

src/main/java/com/endava/cats/util/external/MediaType.java

@@ -33,15 +33,32 @@ private MediaType(String type, String subtype, Map<String, String> parameters) {
         this.parameters = Collections.unmodifiableMap(new LinkedHashMap<>(parameters));
     }
 
+    /**
+     * Creates a new media type with the given type and subtype.
+     *
+     * @param type    the media type
+     * @param subtype the media subtype
+     * @return the media type
+     */
     public static MediaType create(String type, String subtype) {
         return new MediaType(type, subtype, Map.of());
     }
 
     /**
-     * Parses strings like:
-     * - "application/json"
-     * - "application/json; charset=UTF-8"
-     * - "text/plain; charset=\"utf-8\"; format=flowed"
+     * Parses a media type string into a MediaType object.
+     * <p>
+     * Supports parsing of:
+     * - Simple media types: "application/json"
+     * - Media types with charset: "application/json; charset=UTF-8"
+     * - Media types with multiple parameters: "text/plain; charset=\"utf-8\"; format=flowed"
+     * <p>
+     * Parameter names and values are normalized according to HTTP standards.
+     * Type and subtype are converted to lowercase.
+     *
+     * @param input the media type string to parse
+     * @return the parsed MediaType object
+     * @throws NullPointerException     if input is null
+     * @throws IllegalArgumentException if input is empty or malformed
      */
     public static MediaType parse(String input) {
         Objects.requireNonNull(input, "input");
@@ -62,7 +79,9 @@ public static MediaType parse(String input) {
         Map<String, String> params = new LinkedHashMap<>();
         for (int i = 1; i < parts.length; i++) {
             String p = parts[i].trim();
-            if (p.isEmpty()) continue;
+            if (p.isEmpty()) {
+                continue;
+            }
 
             int eq = p.indexOf('=');
             if (eq <= 0 || eq == p.length() - 1) {
@@ -84,34 +103,87 @@ public static MediaType parse(String input) {
         return new MediaType(type, subtype, params);
     }
 
+    /**
+     * Returns the primary type of this media type.
+     * <p>
+     * For example, "application" in "application/json".
+     *
+     * @return the primary type, normalized to lowercase
+     */
     public String type() {
         return type;
     }
 
+    /**
+     * Returns the subtype of this media type.
+     * <p>
+     * For example, "json" in "application/json".
+     *
+     * @return the subtype, normalized to lowercase
+     */
     public String subtype() {
         return subtype;
     }
 
+    /**
+     * Checks if this media type contains a wildcard in either the type or subtype.
+     * <p>
+     * Examples of wildcards:
+     * <ul>
+     * <li>"&#42;/&#42;" (matches any type)</li>
+     * <li>"text/&#42;" (matches any text subtype)</li>
+     * </ul>
+     *
+     * @return true if type or subtype is "&#42;", false otherwise
+     */
     public boolean hasWildcard() {
         return "*".equals(type) || "*".equals(subtype);
     }
 
+    /**
+     * Returns the charset parameter of this media type, if present and valid.
+     * <p>
+     * If the charset parameter is not present, blank, or refers to an unknown/invalid
+     * charset name, returns an empty Optional.
+     *
+     * @return an Optional containing the Charset if valid, or empty otherwise
+     */
     public Optional<Charset> charset() {
         String cs = parameters.get("charset");
         if (cs == null || cs.isBlank()) return Optional.empty();
         try {
             return Optional.of(Charset.forName(cs));
-        } catch (Exception e) {
+        } catch (Exception _) {
             // unknown/invalid charset => behave safely
             return Optional.empty();
         }
     }
 
+    /**
+     * Returns a new MediaType with the specified charset parameter.
+     * <p>
+     * The charset name is normalized to lowercase.
+     *
+     * @param charset the charset to set
+     * @return a new MediaType with the charset parameter
+     * @throws NullPointerException if charset is null
+     */
     public MediaType withCharset(Charset charset) {
         Objects.requireNonNull(charset, "charset");
         return withParameter("charset", charset.name().toLowerCase(Locale.ROOT));
     }
 
+    /**
+     * Returns a new MediaType with the specified parameter added or replaced.
+     * <p>
+     * Parameter names are normalized to lowercase. If the parameter already exists,
+     * its value is replaced. The charset parameter value is also normalized to lowercase.
+     *
+     * @param attribute the parameter name
+     * @param value     the parameter value
+     * @return a new MediaType with the parameter
+     * @throws NullPointerException if attribute or value is null
+     */
     public MediaType withParameter(String attribute, String value) {
         Objects.requireNonNull(attribute, "attribute");
         Objects.requireNonNull(value, "value");
@@ -128,11 +200,25 @@ public MediaType withParameter(String attribute, String value) {
         return new MediaType(type, subtype, copy);
     }
 
+    /**
+     * Returns a new MediaType with all parameters removed.
+     * <p>
+     * If this media type has no parameters, returns this instance.
+     *
+     * @return a MediaType without parameters
+     */
     public MediaType withoutParameters() {
         if (parameters.isEmpty()) return this;
         return new MediaType(type, subtype, Map.of());
     }
 
+    /**
+     * Returns an unmodifiable map of all parameters.
+     * <p>
+     * Parameter names are normalized to lowercase. The map preserves insertion order.
+     *
+     * @return an unmodifiable map of parameters
+     */
     public Map<String, String> parameters() {
         return parameters;
     }
@@ -162,8 +248,6 @@ public int hashCode() {
         return Objects.hash(type, subtype, parameters);
     }
 
-    // ---------- helpers ----------
-
     private static String normalizeToken(String token) {
         String t = Objects.requireNonNull(token, "token").trim();
         if (t.isEmpty()) throw new IllegalArgumentException("Invalid token: empty");
@@ -188,6 +272,29 @@ private static String quoteIfNeeded(String v) {
         return v;
     }
 
+    /**
+     * Checks if this media type matches the specified media type.
+     * <p>
+     * Matching rules:
+     * <ul>
+     * <li>Wildcards ("&#42;") in the other media type match any value</li>
+     * <li>Type and subtype must match (unless wildcarded)</li>
+     * <li>All parameters in the other media type must be present in this media type with the same values</li>
+     * <li>This media type may have additional parameters not present in the other</li>
+     * </ul>
+     * <p>
+     * Examples:
+     * <ul>
+     * <li>"application/json" matches "application/json"</li>
+     * <li>"application/json" matches "&#42;/&#42;"</li>
+     * <li>"text/plain; charset=utf-8" matches "text/plain"</li>
+     * <li>"text/plain" does NOT match "text/plain; charset=utf-8"</li>
+     * </ul>
+     *
+     * @param other the media type to match against
+     * @return true if this media type matches the other, false otherwise
+     * @throws NullPointerException if other is null
+     */
     public boolean is(MediaType other) {
         Objects.requireNonNull(other, "other");