Added Response Headers diff

src/main/java/com/qdesrame/openapi/diff/compare/HeaderDiff.java

@@ -0,0 +1,39 @@
+package com.qdesrame.openapi.diff.compare;
+
+import com.qdesrame.openapi.diff.model.ChangedHeader;
+import io.swagger.v3.oas.models.headers.Header;
+
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Created by adarsh.sharma on 28/12/17.
+ */
+public class HeaderDiff {
+    private OpenApiDiff openApiDiff;
+
+    public HeaderDiff(OpenApiDiff openApiDiff) {
+        this.openApiDiff = openApiDiff;
+    }
+
+    public ChangedHeader diff(Header left, Header right) {
+        ChangedHeader changedHeader = new ChangedHeader(left, right);
+
+        changedHeader.setChangeDescription(!Objects.equals(left.getDescription(), right.getDescription()));
+        changedHeader.setChangeRequired(getBooleanDiff(left.getRequired(), right.getRequired()));
+        changedHeader.setChangeDeprecated(!Boolean.TRUE.equals(left.getDeprecated()) && Boolean.TRUE.equals(right.getDeprecated()));
+        changedHeader.setChangeAllowEmptyValue(getBooleanDiff(left.getAllowEmptyValue(), right.getAllowEmptyValue()));
+        changedHeader.setChangeStyle(!Objects.equals(left.getStyle(), right.getStyle()));
+        changedHeader.setChangeExplode(getBooleanDiff(left.getExplode(), right.getExplode()));
+        changedHeader.setChangedSchema(openApiDiff.getSchemaDiff().diff(left.getSchema(), right.getSchema()));
+        changedHeader.setChangedContent(openApiDiff.getContentDiff().diff(left.getContent(), right.getContent()));
+
+        return changedHeader;
+    }
+
+    private boolean getBooleanDiff(Boolean left, Boolean right) {
+        boolean leftRequired = Optional.ofNullable(left).orElse(Boolean.FALSE);
+        boolean rightRequired = Optional.ofNullable(right).orElse(Boolean.FALSE);
+        return leftRequired != rightRequired;
+    }
+}

src/main/java/com/qdesrame/openapi/diff/compare/HeadersDiff.java

@@ -0,0 +1,41 @@
+package com.qdesrame.openapi.diff.compare;
+
+import com.qdesrame.openapi.diff.model.ChangedHeader;
+import com.qdesrame.openapi.diff.model.ChangedHeaders;
+import io.swagger.v3.oas.models.headers.Header;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by adarsh.sharma on 28/12/17.
+ */
+public class HeadersDiff {
+    private OpenApiDiff openApiDiff;
+
+    public HeadersDiff(OpenApiDiff openApiDiff) {
+        this.openApiDiff = openApiDiff;
+    }
+
+    public ChangedHeaders diff(Map<String, Header> left, Map<String, Header> right) {
+        ChangedHeaders changedHeaders = new ChangedHeaders(left, right);
+        MapKeyDiff<String, Header> headerMapDiff = MapKeyDiff.diff(left, right);
+        changedHeaders.setIncreased(headerMapDiff.getIncreased());
+        changedHeaders.setMissing(headerMapDiff.getMissing());
+        List<String> sharedHeaderKeys = headerMapDiff.getSharedKey();
+
+        Map<String, ChangedHeader> changed = new HashMap<>();
+        for (String headerKey : sharedHeaderKeys) {
+            Header oldHeader = left.get(headerKey);
+            Header newHeader = right.get(headerKey);
+            ChangedHeader changedHeader = openApiDiff.getHeaderDiff().diff(oldHeader, newHeader);
+            if (changedHeader.isDiff()) {
+                changed.put(headerKey, changedHeader);
+            }
+        }
+        changedHeaders.setChanged(changed);
+
+        return changedHeaders;
+    }
+}

src/main/java/com/qdesrame/openapi/diff/compare/OpenApiDiff.java

@@ -30,6 +30,9 @@ public class OpenApiDiff {
     private ParametersDiff parametersDiff;
     private ParameterDiff parameterDiff;
     private RequestBodyDiff requestBodyDiff;
+    private ResponseDiff responseDiff;
+    private HeadersDiff headersDiff;
+    private HeaderDiff headerDiff;
 
     private OpenAPI oldSpecOpenApi;
     private OpenAPI newSpecOpenApi;
@@ -87,6 +90,9 @@ private void initializeFields() {
         this.parametersDiff = new ParametersDiff(this);
         this.parameterDiff = new ParameterDiff(this);
         this.requestBodyDiff = new RequestBodyDiff(this);
+        this.responseDiff = new ResponseDiff(this);
+        this.headersDiff = new HeadersDiff(this);
+        this.headerDiff = new HeaderDiff(this);
     }
 
     /*
@@ -145,20 +151,19 @@ private ChangedOpenApi compare() {
                 ChangedParameters changedParameters = parametersDiff.diff(oldOperation.getParameters(), newOperation.getParameters());
                 changedOperation.setChangedParameters(changedParameters);
 
-                MapKeyDiff<String, ApiResponse> responseDiff = MapKeyDiff.diff(oldOperation.getResponses(),
+                MapKeyDiff<String, ApiResponse> responseMapKeyDiff = MapKeyDiff.diff(oldOperation.getResponses(),
                         newOperation.getResponses());
                 ChangedApiResponse changedApiResponse = new ChangedApiResponse(oldOperation.getResponses(), newOperation.getResponses());
                 changedOperation.setChangedApiResponse(changedApiResponse);
-                changedApiResponse.setAddResponses(responseDiff.getIncreased());
-                changedApiResponse.setMissingResponses(responseDiff.getMissing());
-                List<String> sharedResponseCodes = responseDiff.getSharedKey();
+                changedApiResponse.setAddResponses(responseMapKeyDiff.getIncreased());
+                changedApiResponse.setMissingResponses(responseMapKeyDiff.getMissing());
+                List<String> sharedResponseCodes = responseMapKeyDiff.getSharedKey();
                 Map<String, ChangedResponse> resps = new HashMap<>();
                 for (String responseCode : sharedResponseCodes) {
                     ApiResponse oldResponse = RefPointer.Replace.response(oldSpecOpenApi.getComponents(), oldOperation.getResponses().get(responseCode));
                     ApiResponse newResponse = RefPointer.Replace.response(newSpecOpenApi.getComponents(), newOperation.getResponses().get(responseCode));
                     ChangedContent changedContent = contentDiff.diff(oldResponse.getContent(), newResponse.getContent());
-                    ChangedResponse changedResponse = new ChangedResponse(newResponse.getDescription(), oldResponse.getContent(), newResponse.getContent());
-                    changedResponse.setDescription(newResponse.getDescription());
+                    ChangedResponse changedResponse = responseDiff.diff(oldResponse, newResponse);
                     changedResponse.setChangedContent(changedContent);
                     if (changedResponse.isDiff()) {
                         resps.put(responseCode, changedResponse);
@@ -201,6 +206,22 @@ public ParameterDiff getParameterDiff() {
         return parameterDiff;
     }
 
+    public RequestBodyDiff getRequestBodyDiff() {
+        return requestBodyDiff;
+    }
+
+    public ResponseDiff getResponseDiff() {
+        return responseDiff;
+    }
+
+    public HeadersDiff getHeadersDiff() {
+        return headersDiff;
+    }
+
+    public HeaderDiff getHeaderDiff() {
+        return headerDiff;
+    }
+
     public OpenAPI getOldSpecOpenApi() {
         return oldSpecOpenApi;
     }

src/main/java/com/qdesrame/openapi/diff/compare/ResponseDiff.java

@@ -0,0 +1,27 @@
+package com.qdesrame.openapi.diff.compare;
+
+import com.qdesrame.openapi.diff.model.ChangedResponse;
+import io.swagger.v3.oas.models.responses.ApiResponse;
+
+import java.util.Objects;
+
+/**
+ * Created by adarsh.sharma on 28/12/17.
+ */
+public class ResponseDiff {
+    private OpenApiDiff openApiDiff;
+
+    public ResponseDiff(OpenApiDiff openApiDiff) {
+        this.openApiDiff = openApiDiff;
+    }
+
+    public ChangedResponse diff(ApiResponse left, ApiResponse right) {
+        ChangedResponse changedResponse = new ChangedResponse(left, right);
+
+        changedResponse.setChangedContent(openApiDiff.getContentDiff().diff(left.getContent(), right.getContent()));
+        changedResponse.setChangedHeaders(openApiDiff.getHeadersDiff().diff(left.getHeaders(), right.getHeaders()));
+        changedResponse.setChangeDescription(!Objects.equals(left.getDescription(), right.getDescription()));
+
+        return changedResponse;
+    }
+}

src/main/java/com/qdesrame/openapi/diff/compare/SchemaDiff.java

@@ -36,7 +36,7 @@ public static SchemaDiffResult getSchemaDiffResult(OpenApiDiff openApiDiff) {
 
     public static SchemaDiffResult getSchemaDiffResult(Class<? extends Schema> classType, OpenApiDiff openApiDiff) {
         if (classType == null) {
-            throw new IllegalArgumentException("classType can not be null");
+            classType = Schema.class;
         }
 
         Class<? extends SchemaDiffResult> aClass = schemaDiffResultClassMap.get(classType);
@@ -92,7 +92,7 @@ public ChangedSchema diff(Schema left, Schema right) {
         //If schema type is same then get specific SchemaDiffResult and compare the properties
         SchemaDiffResult result = SchemaDiff.getSchemaDiffResult(right.getClass(), openApiDiff);
         ChangedSchema changedSchema = result.diff(leftComponents, rightComponents, left, right);
-        if(areBothRefSchemas) {
+        if (areBothRefSchemas) {
             schemaDiffCache.addToCache(leftRef, rightRef, changedSchema);
         }
         return changedSchema;

src/main/java/com/qdesrame/openapi/diff/model/ChangedHeader.java

@@ -0,0 +1,126 @@
+package com.qdesrame.openapi.diff.model;
+
+import io.swagger.v3.oas.models.headers.Header;
+
+/**
+ * Created by adarsh.sharma on 28/12/17.
+ */
+public class ChangedHeader implements Changed {
+    private Header oldHeader;
+    private Header newHeader;
+
+    private boolean changeDescription;
+    private boolean changeRequired;
+    private boolean changeDeprecated;
+    private boolean changeAllowEmptyValue;
+    private boolean changeStyle;
+    private boolean changeExplode;
+    private ChangedSchema changedSchema;
+    private ChangedContent changedContent;
+
+    public ChangedHeader(Header oldHeader, Header newHeader) {
+        this.oldHeader = oldHeader;
+        this.newHeader = newHeader;
+    }
+
+    @Override
+    public boolean isDiff() {
+        return changeDescription
+                || changeRequired
+                || changeDeprecated
+                || changeAllowEmptyValue
+                || changeStyle
+                || changeExplode
+                || (changedSchema != null && changedSchema.isDiff())
+                || (changedContent != null && changedContent.isDiff());
+    }
+
+    @Override
+    public boolean isDiffBackwardCompatible() {
+        return changeRequired
+                && changeAllowEmptyValue
+                && (changedSchema == null || changedSchema.isDiffBackwardCompatible(false))
+                && (changedContent == null || changedContent.isDiffBackwardCompatible(false));
+    }
+
+    public Header getOldHeader() {
+        return oldHeader;
+    }
+
+    public void setOldHeader(Header oldHeader) {
+        this.oldHeader = oldHeader;
+    }
+
+    public Header getNewHeader() {
+        return newHeader;
+    }
+
+    public void setNewHeader(Header newHeader) {
+        this.newHeader = newHeader;
+    }
+
+    public boolean isChangeDescription() {
+        return changeDescription;
+    }
+
+    public void setChangeDescription(boolean changeDescription) {
+        this.changeDescription = changeDescription;
+    }
+
+    public boolean isChangeRequired() {
+        return changeRequired;
+    }
+
+    public void setChangeRequired(boolean changeRequired) {
+        this.changeRequired = changeRequired;
+    }
+
+    public boolean isChangeDeprecated() {
+        return changeDeprecated;
+    }
+
+    public void setChangeDeprecated(boolean changeDeprecated) {
+        this.changeDeprecated = changeDeprecated;
+    }
+
+    public boolean isChangeAllowEmptyValue() {
+        return changeAllowEmptyValue;
+    }
+
+    public void setChangeAllowEmptyValue(boolean changeAllowEmptyValue) {
+        this.changeAllowEmptyValue = changeAllowEmptyValue;
+    }
+
+    public boolean isChangeStyle() {
+        return changeStyle;
+    }
+
+    public void setChangeStyle(boolean changeStyle) {
+        this.changeStyle = changeStyle;
+    }
+
+    public boolean isChangeExplode() {
+        return changeExplode;
+    }
+
+    public void setChangeExplode(boolean changeExplode) {
+        this.changeExplode = changeExplode;
+    }
+
+    public ChangedSchema getChangedSchema() {
+        return changedSchema;
+    }
+
+    public void setChangedSchema(ChangedSchema changedSchema) {
+        this.changedSchema = changedSchema;
+    }
+
+    public ChangedContent getChangedContent() {
+        return changedContent;
+    }
+
+    public void setChangedContent(ChangedContent changedContent) {
+        this.changedContent = changedContent;
+    }
+
+}

src/main/java/com/qdesrame/openapi/diff/model/ChangedHeaders.java

@@ -0,0 +1,75 @@
+package com.qdesrame.openapi.diff.model;
+
+import io.swagger.v3.oas.models.headers.Header;
+
+import java.util.Map;
+
+/**
+ * Created by adarsh.sharma on 28/12/17.
+ */
+public class ChangedHeaders implements Changed {
+    private Map<String, Header> oldHeaders;
+    private Map<String, Header> newHeaders;
+
+    private Map<String, Header> increased;
+    private Map<String, Header> missing;
+    private Map<String, ChangedHeader> changed;
+
+    public ChangedHeaders(Map<String, Header> oldHeaders, Map<String, Header> newHeaders) {
+        this.oldHeaders = oldHeaders;
+        this.newHeaders = newHeaders;
+    }
+
+    public Map<String, Header> getOldHeaders() {
+        return oldHeaders;
+    }
+
+    public void setOldHeaders(Map<String, Header> oldHeaders) {
+        this.oldHeaders = oldHeaders;
+    }
+
+    public Map<String, Header> getNewHeaders() {
+        return newHeaders;
+    }
+
+    public void setNewHeaders(Map<String, Header> newHeaders) {
+        this.newHeaders = newHeaders;
+    }
+
+    public Map<String, Header> getIncreased() {
+        return increased;
+    }
+
+    public void setIncreased(Map<String, Header> increased) {
+        this.increased = increased;
+    }
+
+    public Map<String, Header> getMissing() {
+        return missing;
+    }
+
+    public void setMissing(Map<String, Header> missing) {
+        this.missing = missing;
+    }
+
+    public Map<String, ChangedHeader> getChanged() {
+        return changed;
+    }
+
+    public void setChanged(Map<String, ChangedHeader> changed) {
+        this.changed = changed;
+    }
+
+    @Override
+    public boolean isDiff() {
+        return !increased.isEmpty()
+                || !missing.isEmpty()
+                || (changed != null && !changed.isEmpty());
+    }
+
+    @Override
+    public boolean isDiffBackwardCompatible() {
+        return missing.isEmpty()
+                && (changed == null || changed.values().stream().allMatch(c -> c.isDiffBackwardCompatible()));
+    }
+}