subschema comparator

Signed-off-by: Atharva Joshi <[email protected]>

Author: Atharva Joshi

server/src/main/java/io/pravega/schemaregistry/rules/jsoncompatibility/BreakingChangesStore.java

@@ -70,10 +70,14 @@ protected enum BreakingChanges {
         // NOT TYPE
         NOT_TYPE_EXTENDED,
         // COMBINED
-        COMBINED_TYPE_SUBSCHEMAS_CHANGED,
-        COMPOSITION_METHOD_CHANGED,
-        PRODUCT_TYPE_EXTENDED,
-        SUM_TYPE_NARROWED
+        SUBSCHEMA_TYPE_ADDED,
+        SUBSCHEMA_TYPE_CHANGED,
+        SUBSCHEMA_TYPE_ALL_OF_SCHEMAS_INCREASED,
+        SUBSCHEMA_TYPE_ALL_OF_SCHEMAS_CHANGED,
+        SUBSCHEMA_TYPE_ONE_OF_SCHEMAS_DECREASED,
+        SUBSCHEMA_TYPE_ONE_OF_SCHEMAS_CHANGED,
+        SUBSCHEMA_TYPE_ANY_OF_SCHEMAS_DECREASED,
+        SUBSCHEMA_TYPE_ANYOF_SCHEMAS_CHANGED
     }
 
     private List<BreakingChanges> breakingChangesList = new ArrayList<>();

server/src/main/java/io/pravega/schemaregistry/rules/jsoncompatibility/JsonCompatibilityChecker.java

@@ -19,14 +19,16 @@ public class JsonCompatibilityChecker implements CompatibilityChecker {
     NumberComparator numberComparator;
     StringComparator stringComparator;
     ArrayTypeComparator arrayTypeComparator;
-
+    SubSchemaComparator subSchemaComparator;
+    
     public JsonCompatibilityChecker() {
         this.enumComparator = new EnumComparator();
         this.jsonCompatibilityCheckerUtils = new JsonCompatibilityCheckerUtils();
         this.objectTypeComparator = new ObjectTypeComparator();
         this.numberComparator = new NumberComparator();
         this.stringComparator = new StringComparator();
         this.arrayTypeComparator = new ArrayTypeComparator();
+        this.subSchemaComparator = new SubSchemaComparator();
     }
 
     @Override
@@ -67,6 +69,12 @@ private boolean canReadChecker(SchemaInfo toValidate, List<SchemaInfo> toValidat
     }
 
     protected BreakingChanges checkNodeType(JsonNode toCheck, JsonNode toCheckAgainst) {
+        if(jsonCompatibilityCheckerUtils.hasSubSchema(toCheck)) {
+            subSchemaComparator.setJsonCompatibilityChecker();
+            BreakingChanges subSchemaChanges = subSchemaComparator.checkSubSchemas(toCheck, toCheckAgainst);
+            if(subSchemaChanges != null)
+                return subSchemaChanges;
+        }
         if (toCheck.has("enum") || toCheckAgainst.has("enum")) {
             BreakingChanges enumChanges = enumComparator.enumComparator(toCheck, toCheckAgainst);
             if (enumChanges != null)

server/src/main/java/io/pravega/schemaregistry/rules/jsoncompatibility/JsonCompatibilityCheckerUtils.java

@@ -79,4 +79,11 @@ public boolean arrayComparisionOnlyAddition(ArrayNode toCheck, ArrayNode toCheck
         }
         return true;
     }
+    
+    public boolean hasSubSchema(JsonNode toCheck) {
+        if(toCheck.has("anyOf") || toCheck.has("allOf") || toCheck.has("oneOf")) {
+            return true;
+        }
+        return false;
+    }
 }

server/src/main/java/io/pravega/schemaregistry/rules/jsoncompatibility/SubSchemaComparator.java

@@ -0,0 +1,114 @@
+package io.pravega.schemaregistry.rules.jsoncompatibility;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+
+import static io.pravega.schemaregistry.rules.jsoncompatibility.BreakingChangesStore.*;
+
+public class SubSchemaComparator {
+    JsonCompatibilityChecker jsonCompatibilityChecker = new JsonCompatibilityChecker();
+    
+    public void setJsonCompatibilityChecker() {
+        this.jsonCompatibilityChecker = new JsonCompatibilityChecker();
+    }
+    
+    public BreakingChanges checkSubSchemas(JsonNode toCheck, JsonNode toCheckAgainst) {
+        if(toCheck.has("anyOf")) {
+            if(toCheckAgainst.has("oneOf") || toCheckAgainst.has("allOf"))
+                return BreakingChanges.SUBSCHEMA_TYPE_CHANGED;
+            else {
+                if(toCheckAgainst.has("anyOf"))
+                    return nonAllOfComparator(toCheck, toCheckAgainst);
+                else
+                    return BreakingChanges.SUBSCHEMA_TYPE_ADDED;
+            }
+        }
+        else if(toCheck.has("oneOf")) {
+            if(toCheckAgainst.has("anyOf") || toCheckAgainst.has("allOf"))
+                return BreakingChanges.SUBSCHEMA_TYPE_CHANGED;
+            else {
+                if(toCheckAgainst.has("oneOf"))
+                    return nonAllOfComparator(toCheck, toCheckAgainst);
+                else
+                    return BreakingChanges.SUBSCHEMA_TYPE_ADDED;
+            }
+        }
+        else if(toCheck.has("allOf")) {
+            if(toCheckAgainst.has("anyOf") || toCheckAgainst.has("oneOf"))
+                return BreakingChanges.SUBSCHEMA_TYPE_CHANGED;
+            else {
+                if(toCheckAgainst.has("allOf"))
+                    return allOfComparator(toCheck, toCheckAgainst);
+                else
+                    return BreakingChanges.SUBSCHEMA_TYPE_ADDED;
+            }
+        }
+        return null;
+    }
+    
+    private BreakingChanges nonAllOfComparator(JsonNode toCheck, JsonNode toCheckAgainst) {
+        if(toCheck.has("oneOf")) {
+            ArrayNode toCheckArray = (ArrayNode) toCheck.get("oneOf");
+            ArrayNode toCheckAgainstArray = (ArrayNode) toCheckAgainst.get("oneOf");
+            if(toCheckArray.size() < toCheckAgainstArray.size())
+                return BreakingChanges.SUBSCHEMA_TYPE_ONE_OF_SCHEMAS_DECREASED;
+            else {
+                if (!nonAllOfCompatibilityComputation(toCheckArray, toCheckAgainstArray))
+                    return BreakingChanges.SUBSCHEMA_TYPE_ONE_OF_SCHEMAS_CHANGED;
+            }
+        }
+        else {
+            ArrayNode toCheckArray = (ArrayNode) toCheck.get("anyOf");
+            ArrayNode toCheckAgainstArray = (ArrayNode) toCheckAgainst.get("anyOf");
+            if(toCheckArray.size() < toCheckAgainstArray.size())
+                return BreakingChanges.SUBSCHEMA_TYPE_ANY_OF_SCHEMAS_DECREASED;
+            else {
+                if (!nonAllOfCompatibilityComputation(toCheckArray, toCheckAgainstArray))
+                    return BreakingChanges.SUBSCHEMA_TYPE_ANYOF_SCHEMAS_CHANGED;
+            }
+        }
+        return null;
+    }
+    
+    private BreakingChanges allOfComparator(JsonNode toCheck, JsonNode toCheckAgainst) {
+        ArrayNode toCheckArray = (ArrayNode) toCheck.get("allOf");
+        ArrayNode toCheckAgainstArray = (ArrayNode) toCheckAgainst.get("allOf");
+        if(!(toCheckArray.size() <= toCheckAgainstArray.size()))
+            return BreakingChanges.SUBSCHEMA_TYPE_ALL_OF_SCHEMAS_INCREASED;
+        else {
+            if (!allOfCompatibilityComputation(toCheckArray, toCheckAgainstArray))
+                return BreakingChanges.SUBSCHEMA_TYPE_ALL_OF_SCHEMAS_CHANGED;
+        }
+        return null;
+    }
+    
+    private boolean allOfCompatibilityComputation(ArrayNode toCheckArray, ArrayNode toCheckAgainstArray) {
+        for(int i=0;i<toCheckArray.size();i++) {
+            int flag = 0;
+            for(int j=0;j<toCheckAgainstArray.size();j++) {
+                if(jsonCompatibilityChecker.checkNodeType(toCheckArray.get(i), toCheckAgainstArray.get(j))==null) {
+                    flag=1;
+                    break;
+                }
+            }
+            if(flag==0)
+                return false;
+        }
+        return true;
+    }
+    
+    private boolean nonAllOfCompatibilityComputation(ArrayNode toCheckArray, ArrayNode toCheckAgainstArray) {
+        for(int i=0;i<toCheckAgainstArray.size();i++) {
+            int flag = 0;
+            for(int j=0;j<toCheckArray.size();j++) {
+                if(jsonCompatibilityChecker.checkNodeType(toCheckAgainstArray.get(i), toCheckArray.get(j))==null) {
+                    flag=1;
+                    break;
+                }
+            }
+            if(flag==0)
+                return false;
+        }
+        return true;
+    }
+}