feat: Implement combinator validation in DefaultValidator

Replace the four UnsupportedOperationException branches for allOf /
anyOf / oneOf / not with real validation. allOf propagates the first
failing branch; anyOf short-circuits on first match; oneOf evaluates
all branches and asserts exactly one matches; not inverts the inner
result. Adds 9 unit tests covering pass/fail per combinator.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: thced

src/main/java/com/retailsvc/http/validate/DefaultValidator.java

@@ -64,10 +64,14 @@ case EnumSchema(List<Object> values) ->
           require(values.contains(value), pointer, "enum", "value not in enum");
       case ConstSchema(Object expected) ->
           require(Objects.equals(expected, value), pointer, "const", "value does not equal const");
-      case OneOfSchema _ -> throw new UnsupportedOperationException("oneOf not yet supported");
-      case AnyOfSchema _ -> throw new UnsupportedOperationException("anyOf not yet supported");
-      case AllOfSchema _ -> throw new UnsupportedOperationException("allOf not yet supported");
-      case NotSchema _ -> throw new UnsupportedOperationException("not not yet supported");
+      case AllOfSchema(List<Schema> parts) -> {
+        for (Schema p : parts) {
+          validate(value, p, pointer);
+        }
+      }
+      case AnyOfSchema(List<Schema> options) -> validateAnyOf(value, options, pointer);
+      case OneOfSchema(List<Schema> options) -> validateOneOf(value, options, pointer);
+      case NotSchema(Schema inner) -> validateNot(value, inner, pointer);
     }
   }
 
@@ -290,4 +294,44 @@ static void require(boolean condition, String pointer, String keyword, String me
       throw new ValidationException(new ValidationError(pointer, keyword, message, null));
     }
   }
+
+  private void validateAnyOf(Object value, List<Schema> options, String pointer) {
+    for (Schema o : options) {
+      try {
+        validate(value, o, pointer);
+        return;
+      } catch (ValidationException ignored) {
+        // try next branch
+      }
+    }
+    fail(pointer, "anyOf", "did not match any anyOf branch", value);
+  }
+
+  private void validateOneOf(Object value, List<Schema> options, String pointer) {
+    int matched = 0;
+    for (Schema o : options) {
+      try {
+        validate(value, o, pointer);
+        matched++;
+      } catch (ValidationException ignored) {
+        // count misses
+      }
+    }
+    if (matched != 1) {
+      fail(
+          pointer,
+          "oneOf",
+          "matched " + matched + " of " + options.size() + " oneOf branches",
+          value);
+    }
+  }
+
+  private void validateNot(Object value, Schema inner, String pointer) {
+    try {
+      validate(value, inner, pointer);
+    } catch (ValidationException expected) {
+      return;
+    }
+    fail(pointer, "not", "value matched 'not' schema", value);
+  }
 }

src/test/java/com/retailsvc/http/validate/DefaultValidatorDispatchTest.java

@@ -3,9 +3,13 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import com.retailsvc.http.ValidationException;
+import com.retailsvc.http.spec.schema.AllOfSchema;
+import com.retailsvc.http.spec.schema.AnyOfSchema;
 import com.retailsvc.http.spec.schema.BooleanSchema;
+import com.retailsvc.http.spec.schema.NotSchema;
 import com.retailsvc.http.spec.schema.NullSchema;
 import com.retailsvc.http.spec.schema.OneOfSchema;
+import com.retailsvc.http.spec.schema.StringSchema;
 import com.retailsvc.http.spec.schema.TypeName;
 import java.util.List;
 import java.util.Set;
@@ -43,10 +47,86 @@ void booleanSchemaRejectsString() {
     assertThatThrownBy(() -> v.validate("x", schema, "/v")).isInstanceOf(ValidationException.class);
   }
 
+  private StringSchema stringSchema(Integer min, Integer max) {
+    return new StringSchema(Set.of(TypeName.STRING), null, min, max, null, null);
+  }
+
   @Test
-  void combinatorThrowsUnsupported() {
-    var schema = new OneOfSchema(List.of());
-    assertThatThrownBy(() -> v.validate("x", schema, "/v"))
-        .isInstanceOf(UnsupportedOperationException.class);
+  void allOfPassesWhenAllBranchesPass() {
+    var schema = new AllOfSchema(List.of(stringSchema(1, null), stringSchema(null, 10)));
+    v.validate("hello", schema, "/v");
+  }
+
+  @Test
+  void allOfPropagatesFirstFailingBranch() {
+    var schema = new AllOfSchema(List.of(stringSchema(1, null), stringSchema(null, 3)));
+    assertThatThrownBy(() -> v.validate("hello", schema, "/v"))
+        .isInstanceOf(ValidationException.class)
+        .extracting(t -> ((ValidationException) t).error().keyword())
+        .isEqualTo("maxLength");
+  }
+
+  @Test
+  void anyOfPassesWhenOneBranchPasses() {
+    var schema = new AnyOfSchema(List.of(stringSchema(100, null), stringSchema(null, 10)));
+    v.validate("hello", schema, "/v");
+  }
+
+  @Test
+  void anyOfFailsWhenNoBranchMatches() {
+    var schema = new AnyOfSchema(List.of(stringSchema(100, null), stringSchema(null, 2)));
+    assertThatThrownBy(() -> v.validate("hello", schema, "/v"))
+        .isInstanceOf(ValidationException.class)
+        .extracting(t -> ((ValidationException) t).error().keyword())
+        .isEqualTo("anyOf");
+  }
+
+  @Test
+  void oneOfPassesWhenExactlyOneBranchMatches() {
+    // value "hello" — len 5. branch[0] requires min 100 (fails), branch[1] max 10 (passes).
+    var schema = new OneOfSchema(List.of(stringSchema(100, null), stringSchema(null, 10)));
+    v.validate("hello", schema, "/v");
+  }
+
+  @Test
+  void oneOfFailsWhenZeroBranchesMatch() {
+    var schema = new OneOfSchema(List.of(stringSchema(100, null), stringSchema(null, 2)));
+    assertThatThrownBy(() -> v.validate("hello", schema, "/v"))
+        .isInstanceOf(ValidationException.class)
+        .satisfies(
+            t -> {
+              var err = ((ValidationException) t).error();
+              org.assertj.core.api.Assertions.assertThat(err.keyword()).isEqualTo("oneOf");
+              org.assertj.core.api.Assertions.assertThat(err.message()).contains("matched 0 of 2");
+            });
+  }
+
+  @Test
+  void oneOfFailsWhenTwoBranchesMatch() {
+    // value "hello" — both branches accept.
+    var schema = new OneOfSchema(List.of(stringSchema(null, 10), stringSchema(1, null)));
+    assertThatThrownBy(() -> v.validate("hello", schema, "/v"))
+        .isInstanceOf(ValidationException.class)
+        .satisfies(
+            t -> {
+              var err = ((ValidationException) t).error();
+              org.assertj.core.api.Assertions.assertThat(err.keyword()).isEqualTo("oneOf");
+              org.assertj.core.api.Assertions.assertThat(err.message()).contains("matched 2 of 2");
+            });
+  }
+
+  @Test
+  void notPassesWhenInnerFails() {
+    var schema = new NotSchema(stringSchema(100, null));
+    v.validate("hello", schema, "/v");
+  }
+
+  @Test
+  void notFailsWhenInnerPasses() {
+    var schema = new NotSchema(stringSchema(null, 10));
+    assertThatThrownBy(() -> v.validate("hello", schema, "/v"))
+        .isInstanceOf(ValidationException.class)
+        .extracting(t -> ((ValidationException) t).error().keyword())
+        .isEqualTo("not");
   }
 }