fix(diff): swagger diff is not working for certain cases

Signed-off-by: Suraj Chafle <suraj.chafle@crowdstrike.com>

Author: schafle

diff/compatibility.go

@@ -59,6 +59,13 @@ func init() {
 			DeletedTag:                NonBreaking,
 			DeletedConstraint:         NonBreaking,
 			AddedConstraint:           Breaking,
+			ChangedDefault:            Warning,
+			AddedDefault:              Warning,
+			DeletedDefault:            Warning,
+			ChangedExample:            NonBreaking,
+			AddedExample:              NonBreaking,
+			DeletedExample:            NonBreaking,
+			ChangedCollectionFormat:   Breaking,
 		},
 		ForChange: map[SpecChangeCode]Compatibility{
 			NoChangeDetected:          NonBreaking,

diff/difftypes.go

@@ -99,6 +99,20 @@ const (
 	DeletedDefinition
 	// AddedDefinition removed one of the definitions
 	AddedDefinition
+	// ChangedDefault - Changed default value
+	ChangedDefault
+	// AddedDefault - Added a default value
+	AddedDefault
+	// DeletedDefault - Deleted a default value
+	DeletedDefault
+	// ChangedExample - Changed an example value
+	ChangedExample
+	// AddedExample - Added an example value
+	AddedExample
+	// DeletedExample - Deleted an example value
+	DeletedExample
+	// ChangedCollectionFormat - A collectionFormat has been changed to a collectionFormat whose relative compatibility cannot be determined
+	ChangedCollectionFormat
 )
 
 var toLongStringSpecChangeCode = map[SpecChangeCode]string{
@@ -146,6 +160,13 @@ var toLongStringSpecChangeCode = map[SpecChangeCode]string{
 	AddedConstraint:           "Added a schema constraint",
 	DeletedDefinition:         "Deleted a schema definition",
 	AddedDefinition:           "Added a schema definition",
+	ChangedDefault:            "Default value is changed",
+	AddedDefault:              "Default value is added",
+	DeletedDefault:            "Default value is removed",
+	ChangedExample:            "Example value is changed",
+	AddedExample:              "Example value is added",
+	DeletedExample:            "Example value is removed",
+	ChangedCollectionFormat:   "Changed collection format",
 }
 
 var toStringSpecChangeCode = map[SpecChangeCode]string{
@@ -193,6 +214,13 @@ var toStringSpecChangeCode = map[SpecChangeCode]string{
 	AddedConstraint:           "AddedConstraint",
 	DeletedDefinition:         "DeletedDefinition",
 	AddedDefinition:           "AddedDefinition",
+	ChangedDefault:            "ChangedDefault",
+	AddedDefault:              "AddedDefault",
+	DeletedDefault:            "DeletedDefault",
+	ChangedExample:            "ChangedExample",
+	AddedExample:              "AddedExample",
+	DeletedExample:            "DeletedExample",
+	ChangedCollectionFormat:   "ChangedCollectionFormat",
 }
 
 var toIDSpecChangeCode = map[string]SpecChangeCode{}

diff/spec_analyser.go

@@ -169,7 +169,7 @@ func (sd *SpecAnalyser) analyseEndpointData() {
 }
 
 func (sd *SpecAnalyser) analyseRequestParams() {
-	locations := []string{"query", "path", "body", "header"}
+	locations := []string{"query", "path", "body", "header", "formData"}
 
 	for _, paramLocation := range locations {
 		rootNode := getNameOnlyDiffNode(strings.Title(paramLocation))
@@ -355,9 +355,9 @@ func (sd *SpecAnalyser) compareParams(urlMethod URLMethod, location string, name
 		if len(name) > 0 {
 			childLocation = childLocation.AddNode(getSchemaDiffNode(name, param2.Schema))
 		}
-
 		sd.compareSchema(childLocation, param1.Schema, param2.Schema)
 	}
+
 	diffs := sd.CompareProps(forParam(param1), forParam(param2))
 
 	childLocation = childLocation.AddNode(getSchemaDiffNode(name, &param2.SimpleSchema))
@@ -369,6 +369,10 @@ func (sd *SpecAnalyser) compareParams(urlMethod URLMethod, location string, name
 	if len(diffs) > 0 {
 		sd.addDiffs(childLocation, diffs)
 	}
+
+	if &param1.SimpleSchema != nil && &param2.SimpleSchema != nil {
+		sd.compareSimpleSchema(childLocation, &param1.SimpleSchema, &param2.SimpleSchema)
+	}
 }
 
 func (sd *SpecAnalyser) addTypeDiff(location DifferenceLocation, diff *TypeDiff) {
@@ -462,6 +466,51 @@ func (sd *SpecAnalyser) compareSchema(location DifferenceLocation, schema1, sche
 	}
 }
 
+func (sd *SpecAnalyser) compareSimpleSchema(location DifferenceLocation, schema1, schema2 *spec.SimpleSchema) {
+	// check optional/required
+	if schema1.Nullable != schema2.Nullable {
+		// If optional is made required
+		if schema1.Nullable && !schema2.Nullable {
+			sd.addDiffs(location, addTypeDiff([]TypeDiff{}, TypeDiff{Change: ChangedOptionalToRequired, FromType: getSchemaTypeStr(schema1), ToType: getSchemaTypeStr(schema2)}))
+		} else if !schema1.Nullable && schema2.Nullable {
+			// If required is made optional
+			sd.addDiffs(location, addTypeDiff([]TypeDiff{}, TypeDiff{Change: ChangedRequiredToOptional, FromType: getSchemaTypeStr(schema1), ToType: getSchemaTypeStr(schema2)}))
+		}
+	}
+
+	if schema1.CollectionFormat != schema2.CollectionFormat {
+		sd.addDiffs(location, addTypeDiff([]TypeDiff{}, TypeDiff{Change: ChangedCollectionFormat, FromType: getSchemaTypeStr(schema1), ToType: getSchemaTypeStr(schema2)}))
+	}
+
+	if schema1.Default != schema2.Default {
+		if schema1.Default == nil && schema2.Default != nil {
+			sd.addDiffs(location, addTypeDiff([]TypeDiff{}, TypeDiff{Change: AddedDefault, FromType: getSchemaTypeStr(schema1), ToType: getSchemaTypeStr(schema2)}))
+		} else if schema1.Default != nil && schema2.Default == nil {
+			sd.addDiffs(location, addTypeDiff([]TypeDiff{}, TypeDiff{Change: DeletedDefault, FromType: getSchemaTypeStr(schema1), ToType: getSchemaTypeStr(schema2)}))
+		} else {
+			sd.addDiffs(location, addTypeDiff([]TypeDiff{}, TypeDiff{Change: ChangedDefault, FromType: getSchemaTypeStr(schema1), ToType: getSchemaTypeStr(schema2)}))
+		}
+	}
+
+	if schema1.Example != schema2.Example {
+		if schema1.Example == nil && schema2.Example != nil {
+			sd.addDiffs(location, addTypeDiff([]TypeDiff{}, TypeDiff{Change: AddedExample, FromType: getSchemaTypeStr(schema1), ToType: getSchemaTypeStr(schema2)}))
+		} else if schema1.Example != nil && schema2.Example == nil {
+			sd.addDiffs(location, addTypeDiff([]TypeDiff{}, TypeDiff{Change: DeletedExample, FromType: getSchemaTypeStr(schema1), ToType: getSchemaTypeStr(schema2)}))
+		} else {
+			sd.addDiffs(location, addTypeDiff([]TypeDiff{}, TypeDiff{Change: ChangedExample, FromType: getSchemaTypeStr(schema1), ToType: getSchemaTypeStr(schema2)}))
+		}
+	}
+
+	if isArray(schema1) {
+		if isArray(schema2) {
+			sd.compareSimpleSchema(location, &schema1.Items.SimpleSchema, &schema2.Items.SimpleSchema)
+		} else {
+			sd.addDiffs(location, addTypeDiff([]TypeDiff{}, TypeDiff{Change: ChangedType, FromType: getSchemaTypeStr(schema1), ToType: getSchemaTypeStr(schema2)}))
+		}
+	}
+}
+
 func (sd *SpecAnalyser) addDiffs(location DifferenceLocation, diffs []TypeDiff) {
 	for _, e := range diffs {
 		eachTypeDiff := e

diff/spec_difference.go

@@ -60,6 +60,17 @@ func (sd SpecDifferences) BreakingChangeCount() int {
 	return count
 }
 
+// WarningChangeCount Calculates the warning change count
+func (sd SpecDifferences) WarningChangeCount() int {
+	count := 0
+	for _, eachDiff := range sd {
+		if eachDiff.Compatibility == Warning {
+			count++
+		}
+	}
+	return count
+}
+
 // FilterIgnores returns a copy of the list without the items in the specified ignore list
 func (sd SpecDifferences) FilterIgnores(ignores SpecDifferences) SpecDifferences {
 	newDiffs := SpecDifferences{}
@@ -190,6 +201,10 @@ func (sd SpecDifferences) ReportAllDiffs(fmtJSON bool) (io.Reader, error, error)
 	if numDiffs != sd.BreakingChangeCount() {
 		fmt.Fprintln(&out, "NON-BREAKING CHANGES:\n=====================")
 		_, _ = out.ReadFrom(sd.reportChanges(NonBreaking))
+		if sd.WarningChangeCount() > 0 {
+			fmt.Fprintln(&out, "\nNON-BREAKING CHANGES WITH WARNING:\n==================================")
+			_, _ = out.ReadFrom(sd.reportChanges(Warning))
+		}
 	}
 
 	more, err, warn := sd.ReportCompatibility()