implemented CombinedSchema#describePropertiesTo()

Author: erosb

core/src/main/java/org/everit/json/schema/CombinedSchema.java

@@ -15,12 +15,16 @@
  */
 package org.everit.json.schema;
 
+import org.everit.json.schema.internal.JSONPrinter;
+
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
 import java.util.stream.Collectors;
 
+import static java.lang.String.format;
+
 /**
  * Validator for {@code allOf}, {@code oneOf}, {@code anyOf} schemas.
  */
@@ -78,33 +82,63 @@ public interface ValidationCriterion {
     /**
      * Validation criterion for {@code allOf} schemas.
      */
-    public static final ValidationCriterion ALL_CRITERION = (subschemaCount, matchingCount) -> {
-        if (matchingCount < subschemaCount) {
-            throw new ValidationException(null, String.format("only %d subschema matches out of %d",
-                    matchingCount, subschemaCount), "allOf");
+    public static final ValidationCriterion ALL_CRITERION = new ValidationCriterion() {
+
+        @Override
+        public void validate(int subschemaCount, int matchingCount) {
+            if (matchingCount < subschemaCount) {
+                throw new ValidationException(null,
+                        format("only %d subschema matches out of %d", matchingCount, subschemaCount),
+                        "allOf"
+                );
+            }
         }
+
+        @Override
+        public String toString() {
+            return "allOf";
+        }
+
     };
 
     /**
      * Validation criterion for {@code anyOf} schemas.
      */
-    public static final ValidationCriterion ANY_CRITERION = (subschemaCount, matchingCount) -> {
-        if (matchingCount == 0) {
-            throw new ValidationException(null, String.format(
-                    "no subschema matched out of the total %d subschemas",
-                    subschemaCount), "anyOf");
+    public static final ValidationCriterion ANY_CRITERION = new ValidationCriterion() {
+
+        @Override
+        public void validate(int subschemaCount, int matchingCount) {
+            if (matchingCount == 0) {
+                throw new ValidationException(null, format(
+                        "no subschema matched out of the total %d subschemas",
+                        subschemaCount), "anyOf");
+            }
+        }
+
+        @Override
+        public String toString() {
+            return "anyOf";
         }
     };
 
     /**
      * Validation criterion for {@code oneOf} schemas.
      */
-    public static final ValidationCriterion ONE_CRITERION = (subschemaCount, matchingCount) -> {
-        if (matchingCount != 1) {
-            throw new ValidationException(null, String.format("%d subschemas matched instead of one",
-                    matchingCount), "oneOf");
-        }
-    };
+    public static final ValidationCriterion ONE_CRITERION =
+            new ValidationCriterion() {
+
+                @Override
+                public void validate(int subschemaCount, int matchingCount) {
+                    if (matchingCount != 1) {
+                        throw new ValidationException(null, format("%d subschemas matched instead of one",
+                                matchingCount), "oneOf");
+                    }
+                }
+
+                @Override public String toString() {
+                    return "oneOf";
+                }
+            };
 
     public static Builder allOf(final Collection<Schema> schemas) {
         return builder(schemas).criterion(ALL_CRITERION);
@@ -204,6 +238,14 @@ public boolean equals(Object o) {
         }
     }
 
+    @Override
+    void describePropertiesTo(JSONPrinter writer) {
+        writer.key(criterion.toString());
+        writer.array();
+        subschemas.forEach(subschema -> subschema.describeTo(writer));
+        writer.endArray();
+    }
+
     @Override
     public int hashCode() {
         return Objects.hash(super.hashCode(), subschemas, criterion);

core/src/test/java/org/everit/json/schema/CombinedSchemaTest.java

@@ -17,15 +17,20 @@
 
 import nl.jqno.equalsverifier.EqualsVerifier;
 import nl.jqno.equalsverifier.Warning;
+import org.json.JSONObject;
 import org.junit.Assert;
 import org.junit.Test;
 
 import java.util.Arrays;
 import java.util.List;
 
+import static java.util.Arrays.asList;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
+
 public class CombinedSchemaTest {
 
-    private static final List<Schema> SUBSCHEMAS = Arrays.asList(
+    private static final List<Schema> SUBSCHEMAS = asList(
             NumberSchema.builder().multipleOf(10).build(),
             NumberSchema.builder().multipleOf(3).build());
 
@@ -51,17 +56,17 @@ public void anyCriterionSuccess() {
 
     @Test(expected = ValidationException.class)
     public void anyOfInvalid() {
-        CombinedSchema.anyOf(Arrays.asList(
+        CombinedSchema.anyOf(asList(
                 StringSchema.builder().maxLength(2).build(),
                 StringSchema.builder().minLength(4).build()))
                 .build().validate("foo");
     }
 
     @Test
     public void factories() {
-        CombinedSchema.allOf(Arrays.asList(BooleanSchema.INSTANCE));
-        CombinedSchema.anyOf(Arrays.asList(BooleanSchema.INSTANCE));
-        CombinedSchema.oneOf(Arrays.asList(BooleanSchema.INSTANCE));
+        CombinedSchema.allOf(asList(BooleanSchema.INSTANCE));
+        CombinedSchema.anyOf(asList(BooleanSchema.INSTANCE));
+        CombinedSchema.oneOf(asList(BooleanSchema.INSTANCE));
     }
 
     @Test(expected = ValidationException.class)
@@ -104,7 +109,7 @@ public void reportCauses() {
             CombinedSchema.allOf(SUBSCHEMAS).build().validate(24);
             Assert.fail("did not throw exception");
         } catch (ValidationException e) {
-            Assert.assertEquals(1, e.getCausingExceptions().size());
+            assertEquals(1, e.getCausingExceptions().size());
         }
     }
 
@@ -116,4 +121,17 @@ public void equalsVerifier() {
                 .verify();
     }
 
+    @Test
+    public void toStringTest() {
+        CombinedSchema subject = CombinedSchema
+                .allOf(asList(BooleanSchema.INSTANCE, NullSchema.INSTANCE))
+                .build();
+        JSONObject actual = new JSONObject(subject.toString());
+        assertTrue(ObjectComparator.deepEquals(new JSONObject("{\"allOf\":["
+                + BooleanSchema.INSTANCE.toString()
+                + ", "
+                + NullSchema.INSTANCE
+                + "]}"), actual));
+    }
+
 }