refactor: Hoist parameter coercion into ValueCoercion helper

Author: thced

src/main/java/com/retailsvc/http/internal/RequestPreparationFilter.java

@@ -11,10 +11,6 @@
 import com.retailsvc.http.spec.Parameter;
 import com.retailsvc.http.spec.RequestBody;
 import com.retailsvc.http.spec.Spec;
-import com.retailsvc.http.spec.schema.BooleanSchema;
-import com.retailsvc.http.spec.schema.IntegerSchema;
-import com.retailsvc.http.spec.schema.NumberSchema;
-import com.retailsvc.http.spec.schema.Schema;
 import com.retailsvc.http.validate.ValidationError;
 import com.retailsvc.http.validate.Validator;
 import com.sun.net.httpserver.Filter;
@@ -128,48 +124,10 @@ private void validateParameters(
         }
         continue;
       }
-      validator.validate(coerceParameterValue(value, p.schema(), pointer), p.schema(), pointer);
+      validator.validate(ValueCoercion.coerce(value, p.schema(), pointer), p.schema(), pointer);
     }
   }
 
-  /**
-   * Converts a raw parameter string into a typed value matching the schema's primitive kind, so the
-   * validator (which is faithful to JSON Schema {@code type} semantics) sees the value the spec
-   * describes rather than its string serialization. Strings that fail to parse are passed through
-   * unchanged so the validator surfaces a {@code type} error with the original input.
-   */
-  private static Object coerceParameterValue(String raw, Schema schema, String pointer) {
-    return switch (schema) {
-      case IntegerSchema _ -> {
-        try {
-          yield Long.parseLong(raw);
-        } catch (NumberFormatException _) {
-          throw new ValidationException(
-              new ValidationError(pointer, "type", "expected integer", raw));
-        }
-      }
-      case NumberSchema _ -> {
-        try {
-          yield Double.parseDouble(raw);
-        } catch (NumberFormatException _) {
-          throw new ValidationException(
-              new ValidationError(pointer, "type", "expected number", raw));
-        }
-      }
-      case BooleanSchema _ -> {
-        if ("true".equals(raw)) {
-          yield Boolean.TRUE;
-        }
-        if ("false".equals(raw)) {
-          yield Boolean.FALSE;
-        }
-        throw new ValidationException(
-            new ValidationError(pointer, "type", "expected boolean", raw));
-      }
-      default -> raw;
-    };
-  }
-
   private Object validateAndParseBody(HttpExchange exchange, Operation op, byte[] body) {
     Optional<RequestBody> rb = op.requestBody();
     if (rb.isEmpty()) {

src/main/java/com/retailsvc/http/internal/ValueCoercion.java

@@ -0,0 +1,46 @@
+package com.retailsvc.http.internal;
+
+import com.retailsvc.http.ValidationException;
+import com.retailsvc.http.spec.schema.BooleanSchema;
+import com.retailsvc.http.spec.schema.IntegerSchema;
+import com.retailsvc.http.spec.schema.NumberSchema;
+import com.retailsvc.http.spec.schema.Schema;
+import com.retailsvc.http.validate.ValidationError;
+
+/** Coerces wire-format strings (parameters, form-field values) to the target schema type. */
+public final class ValueCoercion {
+
+  private ValueCoercion() {}
+
+  public static Object coerce(String raw, Schema schema, String pointer) {
+    return switch (schema) {
+      case IntegerSchema _ -> {
+        try {
+          yield Long.parseLong(raw);
+        } catch (NumberFormatException _) {
+          throw new ValidationException(
+              new ValidationError(pointer, "type", "expected integer", raw));
+        }
+      }
+      case NumberSchema _ -> {
+        try {
+          yield Double.parseDouble(raw);
+        } catch (NumberFormatException _) {
+          throw new ValidationException(
+              new ValidationError(pointer, "type", "expected number", raw));
+        }
+      }
+      case BooleanSchema _ -> {
+        if ("true".equals(raw)) {
+          yield Boolean.TRUE;
+        }
+        if ("false".equals(raw)) {
+          yield Boolean.FALSE;
+        }
+        throw new ValidationException(
+            new ValidationError(pointer, "type", "expected boolean", raw));
+      }
+      default -> raw;
+    };
+  }
+}

src/test/java/com/retailsvc/http/internal/ValueCoercionTest.java

@@ -0,0 +1,85 @@
+package com.retailsvc.http.internal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.retailsvc.http.ValidationException;
+import com.retailsvc.http.spec.schema.BooleanSchema;
+import com.retailsvc.http.spec.schema.IntegerSchema;
+import com.retailsvc.http.spec.schema.NumberSchema;
+import com.retailsvc.http.spec.schema.Schema;
+import com.retailsvc.http.spec.schema.StringSchema;
+import com.retailsvc.http.spec.schema.TypeName;
+import java.util.Map;
+import java.util.Set;
+import org.junit.jupiter.api.Test;
+
+class ValueCoercionTest {
+
+  private final Schema intSchema = anIntegerSchema();
+  private final Schema numSchema = aNumberSchema();
+  private final Schema boolSchema = aBooleanSchema();
+  private final Schema strSchema = aStringSchema();
+
+  @Test
+  void coercesIntegerString() {
+    assertThat(ValueCoercion.coerce("42", intSchema, "/a")).isEqualTo(42L);
+  }
+
+  @Test
+  void coercesNumberString() {
+    assertThat(ValueCoercion.coerce("3.14", numSchema, "/a")).isEqualTo(3.14);
+  }
+
+  @Test
+  void coercesBooleanTrue() {
+    assertThat(ValueCoercion.coerce("true", boolSchema, "/a")).isEqualTo(Boolean.TRUE);
+  }
+
+  @Test
+  void coercesBooleanFalse() {
+    assertThat(ValueCoercion.coerce("false", boolSchema, "/a")).isEqualTo(Boolean.FALSE);
+  }
+
+  @Test
+  void leavesStringSchemaUntouched() {
+    assertThat(ValueCoercion.coerce("hello", strSchema, "/a")).isEqualTo("hello");
+  }
+
+  @Test
+  void integerCoercionFailureThrowsValidationException() {
+    assertThatThrownBy(() -> ValueCoercion.coerce("abc", intSchema, "/a"))
+        .isInstanceOf(ValidationException.class)
+        .extracting("error.pointer", "error.keyword")
+        .containsExactly("/a", "type");
+  }
+
+  @Test
+  void numberCoercionFailureThrowsValidationException() {
+    assertThatThrownBy(() -> ValueCoercion.coerce("not-a-number", numSchema, "/x"))
+        .isInstanceOf(ValidationException.class);
+  }
+
+  @Test
+  void booleanCoercionFailureThrowsValidationException() {
+    assertThatThrownBy(() -> ValueCoercion.coerce("yes", boolSchema, "/b"))
+        .isInstanceOf(ValidationException.class);
+  }
+
+  private static IntegerSchema anIntegerSchema() {
+    return new IntegerSchema(
+        Set.of(TypeName.INTEGER), null, null, null, null, null, null, Map.of());
+  }
+
+  private static NumberSchema aNumberSchema() {
+    return new NumberSchema(Set.of(TypeName.NUMBER), null, null, null, null, null, null, Map.of());
+  }
+
+  private static BooleanSchema aBooleanSchema() {
+    return new BooleanSchema(Set.of(TypeName.BOOLEAN), Map.of());
+  }
+
+  private static StringSchema aStringSchema() {
+    return new StringSchema(Set.of(TypeName.STRING), null, null, null, null, null, Map.of());
+  }
+}