initial test for checking validation events; hashCode/equals added

erosb · erosb · commit eab8bb10dddd · 2018-12-06T16:05:45.000+01:00
diff --git a/core/src/main/java/org/everit/json/schema/ConditionalSchemaValidatingVisitor.java b/core/src/main/java/org/everit/json/schema/ConditionalSchemaValidatingVisitor.java
@@ -1,10 +1,9 @@
 package org.everit.json.schema;
 
+import static java.util.Objects.requireNonNull;
 
 import java.util.Arrays;
 
-import static java.util.Objects.requireNonNull;
-
 class ConditionalSchemaValidatingVisitor extends Visitor {
 
     private final Object subject;
@@ -35,7 +34,7 @@ void visitIfSchema(Schema ifSchema) {
         if (conditionalSchema.getIfSchema().isPresent()) {
             ifSchemaException = owner.getFailureOfSchema(ifSchema, subject);
         }
-        owner.reportSchemaMatchEvent(ifSchema, ifSchemaException);
+        //        owner.reportSchemaMatchEvent(ifSchema, ifSchemaException);
     }
 
     @Override
@@ -50,10 +49,10 @@ void visitThenSchema(Schema thenSchema) {
                         "then",
                         conditionalSchema.getSchemaLocation());
 
-                owner.reportSchemaMatchEvent(thenSchema, failure);
+                //                owner.reportSchemaMatchEvent(thenSchema, failure);
                 owner.failure(failure);
             } else {
-                owner.reportSchemaMatchEvent(thenSchema, null);
+                //                owner.reportSchemaMatchEvent(thenSchema, null);
             }
         }
     }
@@ -70,10 +69,10 @@ void visitElseSchema(Schema elseSchema) {
                         "else",
                         conditionalSchema.getSchemaLocation());
 
-                owner.reportSchemaMatchEvent(elseSchema, failure);
+                //                owner.reportSchemaMatchEvent(elseSchema, failure);
                 owner.failure(failure);
             }
-            owner.reportSchemaMatchEvent(elseSchema, null);
+            //            owner.reportSchemaMatchEvent(elseSchema, null);
         }
     }
 
diff --git a/core/src/main/java/org/everit/json/schema/ValidatingVisitor.java b/core/src/main/java/org/everit/json/schema/ValidatingVisitor.java
@@ -10,9 +10,9 @@
 import java.util.Collection;
 import java.util.List;
 
+import org.everit.json.schema.listener.CombinedSchemaMismatchEvent;
+import org.everit.json.schema.listener.CombinedSchemaValidationEvent;
 import org.everit.json.schema.listener.SchemaReferencedEvent;
-import org.everit.json.schema.listener.SubschemaMatchEvent;
-import org.everit.json.schema.listener.SubschemaMismatchEvent;
 import org.json.JSONArray;
 import org.json.JSONObject;
 
@@ -157,7 +157,7 @@ void visitCombinedSchema(CombinedSchema combinedSchema) {
             if (null != exception) {
                 failures.add(exception);
             }
-            reportSchemaMatchEvent(subschema, exception);
+            reportSchemaMatchEvent(combinedSchema, subschema, exception);
         }
         int matchingCount = subschemas.size() - failures.size();
         try {
@@ -177,12 +177,14 @@ void visitConditionalSchema(ConditionalSchema conditionalSchema) {
         conditionalSchema.accept(new ConditionalSchemaValidatingVisitor(subject, this));
     }
 
-    void reportSchemaMatchEvent(Schema schema, ValidationException rval) {
+    void reportSchemaMatchEvent(CombinedSchema schema, Schema subschema, ValidationException failure) {
         if (validationListener != null) {
-            if (rval == null) {
-                validationListener.subschemaMatch(new SubschemaMatchEvent(schema));
+            if (failure == null) {
+                validationListener.combinedSchemaMatch(new CombinedSchemaValidationEvent(schema, subschema, subject));
+                //                validationListener.subschemaMatch(new SubschemaMatchEvent(schema));
             } else {
-                validationListener.subschemaMismatch(new SubschemaMismatchEvent(schema, rval));
+                validationListener.combinedSchemaMismatch(new CombinedSchemaMismatchEvent(schema, subschema, subject, failure));
+                //                validationListener.subschemaMismatch(new SubschemaMismatchEvent(schema, rval));
             }
         }
     }
diff --git a/core/src/main/java/org/everit/json/schema/ValidationListener.java b/core/src/main/java/org/everit/json/schema/ValidationListener.java
@@ -1,32 +1,35 @@
 package org.everit.json.schema;
 
+import org.everit.json.schema.listener.CombinedSchemaMismatchEvent;
+import org.everit.json.schema.listener.CombinedSchemaValidationEvent;
+import org.everit.json.schema.listener.ConditionalSchemaMismatchEvent;
+import org.everit.json.schema.listener.ConditionalSchemaValidationEvent;
+import org.everit.json.schema.listener.MismatchEvent;
 import org.everit.json.schema.listener.SchemaReferencedEvent;
-import org.everit.json.schema.listener.SubschemaMatchEvent;
-import org.everit.json.schema.listener.SubschemaMismatchEvent;
 
 /**
  * Interface to capture which schemas are matching against a specific event in the {@link ValidatingVisitor}.
  */
 public interface ValidationListener {
 
-    void subschemaMatch(SubschemaMatchEvent matchEvent);
+    void mismatch(MismatchEvent event);
 
-    void subschemaMismatch(SubschemaMismatchEvent mismatchEvent);
+    void combinedSchemaMatch(CombinedSchemaValidationEvent event);
 
-    void schemaReferenced(SchemaReferencedEvent referencedEvent);
+    void combinedSchemaMismatch(CombinedSchemaMismatchEvent event);
 
-    // --
+    void schemaReferenced(SchemaReferencedEvent event);
 
-    void ifSchemaMatch();
+    void ifSchemaMatch(ConditionalSchemaValidationEvent event);
 
-    void ifSchemaMismatch();
+    void ifSchemaMismatch(ConditionalSchemaMismatchEvent event);
 
-    void thenSchemaMatch();
+    void thenSchemaMatch(ConditionalSchemaValidationEvent event);
 
-    void thenSchemaMismatch();
+    void thenSchemaMismatch(ConditionalSchemaMismatchEvent event);
 
-    void elseSchemaMatch();
+    void elseSchemaMatch(ConditionalSchemaValidationEvent event);
 
-    void elseSchemaMismatch();
+    void elseSchemaMismatch(ConditionalSchemaMismatchEvent event);
 }
 
diff --git a/core/src/main/java/org/everit/json/schema/listener/CombinedSchemaMismatchEvent.java b/core/src/main/java/org/everit/json/schema/listener/CombinedSchemaMismatchEvent.java
@@ -1,18 +1,37 @@
 package org.everit.json.schema.listener;
 
+import java.util.Objects;
+
 import org.everit.json.schema.CombinedSchema;
+import org.everit.json.schema.Schema;
 import org.everit.json.schema.ValidationException;
 
 public class CombinedSchemaMismatchEvent extends CombinedSchemaValidationEvent implements MismatchEvent {
 
     private final ValidationException failure;
 
-    protected CombinedSchemaMismatchEvent(CombinedSchema schema, Object instance, ValidationException failure) {
-        super(schema, instance);
+    public CombinedSchemaMismatchEvent(CombinedSchema schema, Schema subSchema, Object instance, ValidationException failure) {
+        super(schema, subSchema, instance);
         this.failure = failure;
     }
 
     @Override public ValidationException getFailure() {
         return failure;
     }
+
+    @Override public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof CombinedSchemaMismatchEvent))
+            return false;
+        if (!super.equals(o))
+            return false;
+        CombinedSchemaMismatchEvent that = (CombinedSchemaMismatchEvent) o;
+        return failure.equals(that.failure);
+    }
+
+    @Override public int hashCode() {
+        return Objects.hash(super.hashCode(), failure);
+    }
+
 }
diff --git a/core/src/main/java/org/everit/json/schema/listener/CombinedSchemaValidationEvent.java b/core/src/main/java/org/everit/json/schema/listener/CombinedSchemaValidationEvent.java
@@ -1,11 +1,18 @@
 package org.everit.json.schema.listener;
 
 import org.everit.json.schema.CombinedSchema;
+import org.everit.json.schema.Schema;
 
 public class CombinedSchemaValidationEvent extends ValidationEvent<CombinedSchema> {
 
-    protected CombinedSchemaValidationEvent(CombinedSchema schema, Object instance) {
+    private final Schema subSchema;
+
+    public CombinedSchemaValidationEvent(CombinedSchema schema, Schema subSchema, Object instance) {
         super(schema, instance);
+        this.subSchema = subSchema;
     }
 
+    public Schema getSubSchema() {
+        return subSchema;
+    }
 }
diff --git a/core/src/main/java/org/everit/json/schema/listener/ConditionalSchemaMismatchEvent.java b/core/src/main/java/org/everit/json/schema/listener/ConditionalSchemaMismatchEvent.java
@@ -1,5 +1,7 @@
 package org.everit.json.schema.listener;
 
+import java.util.Objects;
+
 import org.everit.json.schema.ConditionalSchema;
 import org.everit.json.schema.ValidationException;
 
@@ -15,4 +17,19 @@ protected ConditionalSchemaMismatchEvent(ConditionalSchema schema, Object instan
     @Override public ValidationException getFailure() {
         return failure;
     }
+
+    @Override public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (!(o instanceof ConditionalSchemaMismatchEvent))
+            return false;
+        if (!super.equals(o))
+            return false;
+        ConditionalSchemaMismatchEvent that = (ConditionalSchemaMismatchEvent) o;
+        return failure.equals(that.failure);
+    }
+
+    @Override public int hashCode() {
+        return Objects.hash(super.hashCode(), failure);
+    }
 }
diff --git a/core/src/main/java/org/everit/json/schema/listener/ConditionalSchemaValidationEvent.java b/core/src/main/java/org/everit/json/schema/listener/ConditionalSchemaValidationEvent.java
@@ -4,7 +4,7 @@
 
 public class ConditionalSchemaValidationEvent extends ValidationEvent<ConditionalSchema> {
 
-    protected ConditionalSchemaValidationEvent(ConditionalSchema schema, Object instance) {
+    public ConditionalSchemaValidationEvent(ConditionalSchema schema, Object instance) {
         super(schema, instance);
     }
 
diff --git a/core/src/main/java/org/everit/json/schema/listener/SubschemaMatchEvent.java b/core/src/main/java/org/everit/json/schema/listener/SubschemaMatchEvent.java
diff --git a/core/src/main/java/org/everit/json/schema/listener/SubschemaMismatchEvent.java b/core/src/main/java/org/everit/json/schema/listener/SubschemaMismatchEvent.java
diff --git a/core/src/main/java/org/everit/json/schema/listener/ValidationEvent.java b/core/src/main/java/org/everit/json/schema/listener/ValidationEvent.java
@@ -1,5 +1,7 @@
 package org.everit.json.schema.listener;
 
+import java.util.Objects;
+
 import org.everit.json.schema.Schema;
 
 public abstract class ValidationEvent<S extends Schema> {
@@ -17,4 +19,17 @@ public S getSchema() {
         return schema;
     }
 
+    @Override public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        ValidationEvent<?> that = (ValidationEvent<?>) o;
+        return schema.equals(that.schema) &&
+                instance.equals(that.instance);
+    }
+
+    @Override public int hashCode() {
+        return Objects.hash(schema, instance);
+    }
 }
diff --git a/core/src/test/java/org/everit/json/schema/EventToStringTest.java b/core/src/test/java/org/everit/json/schema/EventToStringTest.java
@@ -0,0 +1,11 @@
+package org.everit.json.schema;
+
+import org.junit.Test;
+
+public class EventToStringTest {
+
+    @Test
+    public void schemaReferenceEventToStringTest() {
+
+    }
+}
diff --git a/core/src/test/java/org/everit/json/schema/ValidatingVisitorTest.java b/core/src/test/java/org/everit/json/schema/ValidatingVisitorTest.java
@@ -2,7 +2,9 @@
 
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;
 
@@ -114,4 +116,25 @@ public void notPermittedTypeFailure(Object subject) {
         new ValidatingVisitor(subject, reporter, ReadWriteValidator.NONE, null);
     }
 
+    @Test
+    public void triggersCombinedSchemaEvents() {
+        ValidationListener listener = mock(ValidationListener.class);
+        StringSchema stringSchema = StringSchema.builder().requiresString(true).build();
+        TrueSchema trueSchema = TrueSchema.builder().build();
+        EmptySchema emptySchema = EmptySchema.builder().build();
+        CombinedSchema combinedSchema = CombinedSchema.builder().criterion(CombinedSchema.ONE_CRITERION)
+                .subschema(stringSchema)
+                .subschema(emptySchema)
+                //                .subschema(trueSchema)
+                .build();
+        ValidationFailureReporter reporter = spy(new CollectingFailureReporter(combinedSchema));
+        JSONObject instance = new JSONObject();
+
+        new ValidatingVisitor(instance, reporter, ReadWriteValidator.NONE, listener).visit(combinedSchema);
+
+        verify(listener).combinedSchemaMismatch(any());
+        verify(listener).combinedSchemaMatch(any()); //new CombinedSchemaValidationEvent(combinedSchema, trueSchema, instance)
+        //        verify(listener).combinedSchemaMatch(any()); //new CombinedSchemaValidationEvent(combinedSchema, emptySchema, instance)
+    }
+
 }

Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,9 @@`
`1`	`1`	`package org.everit.json.schema;`
`2`	`2`
	`3`	`+import static java.util.Objects.requireNonNull;`
`3`	`4`
`4`	`5`	`import java.util.Arrays;`
`5`	`6`
`6`		`-import static java.util.Objects.requireNonNull;`
`7`		`-`
`8`	`7`	`class ConditionalSchemaValidatingVisitor extends Visitor {`
`9`	`8`
`10`	`9`	`private final Object subject;`
`@@ -35,7 +34,7 @@ void visitIfSchema(Schema ifSchema) {`
`35`	`34`	`if (conditionalSchema.getIfSchema().isPresent()) {`
`36`	`35`	`ifSchemaException = owner.getFailureOfSchema(ifSchema, subject);`
`37`	`36`	`}`
`38`		`- owner.reportSchemaMatchEvent(ifSchema, ifSchemaException);`
	`37`	`+ // owner.reportSchemaMatchEvent(ifSchema, ifSchemaException);`
`39`	`38`	`}`
`40`	`39`
`41`	`40`	`@Override`
`@@ -50,10 +49,10 @@ void visitThenSchema(Schema thenSchema) {`
`50`	`49`	`"then",`
`51`	`50`	`conditionalSchema.getSchemaLocation());`
`52`	`51`
`53`		`- owner.reportSchemaMatchEvent(thenSchema, failure);`
	`52`	`+ // owner.reportSchemaMatchEvent(thenSchema, failure);`
`54`	`53`	`owner.failure(failure);`
`55`	`54`	`} else {`
`56`		`- owner.reportSchemaMatchEvent(thenSchema, null);`
	`55`	`+ // owner.reportSchemaMatchEvent(thenSchema, null);`
`57`	`56`	`}`
`58`	`57`	`}`
`59`	`58`	`}`
`@@ -70,10 +69,10 @@ void visitElseSchema(Schema elseSchema) {`
`70`	`69`	`"else",`
`71`	`70`	`conditionalSchema.getSchemaLocation());`
`72`	`71`
`73`		`- owner.reportSchemaMatchEvent(elseSchema, failure);`
	`72`	`+ // owner.reportSchemaMatchEvent(elseSchema, failure);`
`74`	`73`	`owner.failure(failure);`
`75`	`74`	`}`
`76`		`- owner.reportSchemaMatchEvent(elseSchema, null);`
	`75`	`+ // owner.reportSchemaMatchEvent(elseSchema, null);`
`77`	`76`	`}`
`78`	`77`	`}`
`79`	`78`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`public class ConditionalSchemaValidationEvent extends ValidationEvent<ConditionalSchema> {`
`6`	`6`
`7`		`- protected ConditionalSchemaValidationEvent(ConditionalSchema schema, Object instance) {`
	`7`	`+ public ConditionalSchemaValidationEvent(ConditionalSchema schema, Object instance) {`
`8`	`8`	`super(schema, instance);`
`9`	`9`	`}`
`10`	`10`