Schema what-changed almost complete.

Perhaps the biggest and most complex of all the models to determine what has changed.

what-changed/schema_test.go

@@ -5,6 +5,7 @@ package what_changed
 
 import (
 	"github.com/pb33f/libopenapi/datamodel"
+	"github.com/pb33f/libopenapi/datamodel/low"
 	"github.com/pb33f/libopenapi/datamodel/low/base"
 	v3 "github.com/pb33f/libopenapi/datamodel/low/v3"
 	"github.com/stretchr/testify/assert"
@@ -286,3 +287,693 @@ func TestCompareSchemas_Identical(t *testing.T) {
 	changes := CompareSchemas(rSchemaProxy, lSchemaProxy)
 	assert.Nil(t, changes)
 }
+
+func TestCompareSchemas_RequiredAdded(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      title: an OK message
+      description: a thing
+      required:
+        - one`
+
+	right := `components:
+  schemas:
+    OK:
+      title: an OK message
+      description: a thing
+      required:
+        - one
+        - two`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Len(t, changes.Changes, 1)
+	assert.Equal(t, PropertyAdded, changes.Changes[0].ChangeType)
+	assert.Equal(t, "two", changes.Changes[0].New)
+	assert.Equal(t, v3.RequiredLabel, changes.Changes[0].Property)
+}
+
+func TestCompareSchemas_RequiredRemoved(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      required:
+        - one`
+
+	right := `components:
+  schemas:
+    OK:
+      required:
+        - one
+        - two`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(rSchemaProxy, lSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Len(t, changes.Changes, 1)
+	assert.Equal(t, PropertyRemoved, changes.Changes[0].ChangeType)
+	assert.Equal(t, "two", changes.Changes[0].Original)
+	assert.Equal(t, v3.RequiredLabel, changes.Changes[0].Property)
+}
+
+func TestCompareSchemas_EnumAdded(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      enum: [a,b,c]`
+
+	right := `components:
+  schemas:
+    OK:
+      enum: [a,b,c,d]`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Len(t, changes.Changes, 1)
+	assert.Equal(t, PropertyAdded, changes.Changes[0].ChangeType)
+	assert.Equal(t, "d", changes.Changes[0].New)
+	assert.Equal(t, v3.EnumLabel, changes.Changes[0].Property)
+}
+
+func TestCompareSchemas_EnumRemoved(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      enum: [a,b,c]`
+
+	right := `components:
+  schemas:
+    OK:
+      enum: [a,b,c,d]`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(rSchemaProxy, lSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Len(t, changes.Changes, 1)
+	assert.Equal(t, PropertyRemoved, changes.Changes[0].ChangeType)
+	assert.Equal(t, "d", changes.Changes[0].Original)
+	assert.Equal(t, v3.EnumLabel, changes.Changes[0].Property)
+}
+
+func TestCompareSchemas_PropertyAdded(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      properties:
+        propA:
+          type: int`
+
+	right := `components:
+  schemas:
+    OK:
+      properties:
+        propB:
+          type: string
+        propA:
+          type: int`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Len(t, changes.Changes, 1)
+	assert.Equal(t, ObjectAdded, changes.Changes[0].ChangeType)
+	assert.Equal(t, "propB", changes.Changes[0].New)
+	assert.Equal(t, v3.PropertiesLabel, changes.Changes[0].Property)
+}
+
+func TestCompareSchemas_PropertyRemoved(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      properties:
+        propA:
+          type: int`
+
+	right := `components:
+  schemas:
+    OK:
+      properties:
+        propB:
+          type: string
+        propA:
+          type: int`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(rSchemaProxy, lSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Len(t, changes.Changes, 1)
+	assert.Equal(t, ObjectRemoved, changes.Changes[0].ChangeType)
+	assert.Equal(t, "propB", changes.Changes[0].Original)
+	assert.Equal(t, v3.PropertiesLabel, changes.Changes[0].Property)
+}
+
+func TestCompareSchemas_PropertyChanged(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      properties:
+        propA:
+          type: int`
+
+	right := `components:
+  schemas:
+    OK:
+      properties:
+        propA:
+          type: string`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, Modified, changes.SchemaPropertyChanges["propA"].Changes[0].ChangeType)
+	assert.Equal(t, "string", changes.SchemaPropertyChanges["propA"].Changes[0].New)
+	assert.Equal(t, "int", changes.SchemaPropertyChanges["propA"].Changes[0].Original)
+}
+
+func TestCompareSchemas_PropertySwap(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      properties:
+        propA:
+          type: int`
+
+	right := `components:
+  schemas:
+    OK:
+      properties:
+        propN:
+          type: string`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 2, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, ObjectAdded, changes.Changes[0].ChangeType)
+	assert.Equal(t, "propN", changes.Changes[0].New)
+	assert.Equal(t, v3.PropertiesLabel, changes.Changes[0].Property)
+	assert.Equal(t, ObjectRemoved, changes.Changes[1].ChangeType)
+	assert.Equal(t, "propA", changes.Changes[1].Original)
+	assert.Equal(t, v3.PropertiesLabel, changes.Changes[1].Property)
+}
+
+func TestCompareSchemas_AnyOfModifyAndAddItem(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      anyOf:
+        - type: bool`
+
+	right := `components:
+  schemas:
+    OK:
+      anyOf:
+        - type: string
+        - type: int"`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 2, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, ObjectAdded, changes.Changes[0].ChangeType)
+	assert.Equal(t, v3.AnyOfLabel, changes.Changes[0].Property)
+	assert.Equal(t, Modified, changes.AnyOfChanges[0].Changes[0].ChangeType)
+	assert.Equal(t, "string", changes.AnyOfChanges[0].Changes[0].New)
+	assert.Equal(t, "bool", changes.AnyOfChanges[0].Changes[0].Original)
+}
+
+func TestCompareSchemas_AnyOfModifyAndRemoveItem(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      anyOf:
+        - type: bool`
+
+	right := `components:
+  schemas:
+    OK:
+      anyOf:
+        - type: string
+        - type: int"`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(rSchemaProxy, lSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 2, changes.TotalChanges())
+	assert.Equal(t, 2, changes.TotalBreakingChanges())
+	assert.Equal(t, ObjectRemoved, changes.Changes[0].ChangeType)
+	assert.Equal(t, v3.AnyOfLabel, changes.Changes[0].Property)
+	assert.Equal(t, Modified, changes.AnyOfChanges[0].Changes[0].ChangeType)
+	assert.Equal(t, "bool", changes.AnyOfChanges[0].Changes[0].New)
+	assert.Equal(t, "string", changes.AnyOfChanges[0].Changes[0].Original)
+}
+
+func TestCompareSchemas_AnyOfModified(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      anyOf:
+        - type: bool`
+
+	right := `components:
+  schemas:
+    OK:
+      anyOf:
+        - type: string`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, Modified, changes.AnyOfChanges[0].Changes[0].ChangeType)
+	assert.Equal(t, "string", changes.AnyOfChanges[0].Changes[0].New)
+	assert.Equal(t, "bool", changes.AnyOfChanges[0].Changes[0].Original)
+
+}
+
+func TestCompareSchemas_OneOfModifyAndAddItem(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      oneOf:
+        - type: bool`
+
+	right := `components:
+  schemas:
+    OK:
+      oneOf:
+        - type: string
+        - type: int"`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 2, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, ObjectAdded, changes.Changes[0].ChangeType)
+	assert.Equal(t, v3.OneOfLabel, changes.Changes[0].Property)
+	assert.Equal(t, Modified, changes.OneOfChanges[0].Changes[0].ChangeType)
+	assert.Equal(t, "string", changes.OneOfChanges[0].Changes[0].New)
+	assert.Equal(t, "bool", changes.OneOfChanges[0].Changes[0].Original)
+}
+
+func TestCompareSchemas_AllOfModifyAndAddItem(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      allOf:
+        - type: bool`
+
+	right := `components:
+  schemas:
+    OK:
+      allOf:
+        - type: string
+        - type: int"`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 2, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, ObjectAdded, changes.Changes[0].ChangeType)
+	assert.Equal(t, v3.AllOfLabel, changes.Changes[0].Property)
+	assert.Equal(t, Modified, changes.AllOfChanges[0].Changes[0].ChangeType)
+	assert.Equal(t, "string", changes.AllOfChanges[0].Changes[0].New)
+	assert.Equal(t, "bool", changes.AllOfChanges[0].Changes[0].Original)
+}
+
+func TestCompareSchemas_ItemsModifyAndAddItem(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      type: string
+      items:
+        type: bool`
+
+	right := `components:
+  schemas:
+    OK:
+      type: string
+      items:
+        type: string`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, v3.TypeLabel, changes.ItemsChanges[0].Changes[0].Property)
+	assert.Equal(t, Modified, changes.ItemsChanges[0].Changes[0].ChangeType)
+	assert.Equal(t, "string", changes.ItemsChanges[0].Changes[0].New)
+	assert.Equal(t, "bool", changes.ItemsChanges[0].Changes[0].Original)
+}
+
+func TestCompareSchemas_ItemsModifyAndAddItemArray(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      type: string
+      items:
+        - type: bool`
+
+	right := `components:
+  schemas:
+    OK:
+      type: string
+      items:
+        - type: string`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, v3.TypeLabel, changes.ItemsChanges[0].Changes[0].Property)
+	assert.Equal(t, Modified, changes.ItemsChanges[0].Changes[0].ChangeType)
+	assert.Equal(t, "string", changes.ItemsChanges[0].Changes[0].New)
+	assert.Equal(t, "bool", changes.ItemsChanges[0].Changes[0].Original)
+}
+
+func TestCompareSchemas_NotModifyAndAddItem(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      type: string
+      not:
+        type: bool`
+
+	right := `components:
+  schemas:
+    OK:
+      type: string
+      not:
+        type: string`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, v3.TypeLabel, changes.NotChanges[0].Changes[0].Property)
+	assert.Equal(t, Modified, changes.NotChanges[0].Changes[0].ChangeType)
+	assert.Equal(t, "string", changes.NotChanges[0].Changes[0].New)
+	assert.Equal(t, "bool", changes.NotChanges[0].Changes[0].Original)
+}
+
+func TestCompareSchemas_DiscriminatorChange(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      type: string
+      discriminator:
+        propertyName: melody`
+
+	right := `components:
+  schemas:
+    OK:
+      type: string
+      discriminator:
+        propertyName: maddox`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, v3.PropertyNameLabel, changes.DiscriminatorChanges.Changes[0].Property)
+	assert.Equal(t, Modified, changes.DiscriminatorChanges.Changes[0].ChangeType)
+	assert.Equal(t, "maddox", changes.DiscriminatorChanges.Changes[0].New)
+	assert.Equal(t, "melody", changes.DiscriminatorChanges.Changes[0].Original)
+}
+
+func TestCompareSchemas_DiscriminatorAdd(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      type: string`
+
+	right := `components:
+  schemas:
+    OK:
+      type: string
+      discriminator:
+        propertyName: maddox`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, v3.DiscriminatorLabel, changes.Changes[0].Property)
+	assert.Equal(t, ObjectAdded, changes.Changes[0].ChangeType)
+	assert.Equal(t, "0e563831440581c713657dd857a0ec3af1bd7308a43bd3cae9184f61d61b288f",
+		low.HashToString(changes.Changes[0].NewObject.(*base.Discriminator).Hash()))
+
+}
+
+func TestCompareSchemas_DiscriminatorRemove(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      type: string`
+
+	right := `components:
+  schemas:
+    OK:
+      type: string
+      discriminator:
+        propertyName: maddox`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(rSchemaProxy, lSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 1, changes.TotalBreakingChanges())
+	assert.Equal(t, v3.DiscriminatorLabel, changes.Changes[0].Property)
+	assert.Equal(t, ObjectRemoved, changes.Changes[0].ChangeType)
+	assert.Equal(t, "0e563831440581c713657dd857a0ec3af1bd7308a43bd3cae9184f61d61b288f",
+		low.HashToString(changes.Changes[0].OriginalObject.(*base.Discriminator).Hash()))
+
+}
+
+func TestCompareSchemas_ExternalDocsChange(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      type: string
+      externalDocs:
+        url: https://pb33f.io`
+
+	right := `components:
+  schemas:
+    OK:
+      type: string
+      externalDocs:
+        url: https://pb33f.io/new`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 0, changes.TotalBreakingChanges())
+	assert.Equal(t, v3.URLLabel, changes.ExternalDocChanges.Changes[0].Property)
+	assert.Equal(t, Modified, changes.ExternalDocChanges.Changes[0].ChangeType)
+	assert.Equal(t, "https://pb33f.io/new", changes.ExternalDocChanges.Changes[0].New)
+	assert.Equal(t, "https://pb33f.io", changes.ExternalDocChanges.Changes[0].Original)
+}
+
+func TestCompareSchemas_ExternalDocsAdd(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      type: string`
+
+	right := `components:
+  schemas:
+    OK:
+      type: string
+      externalDocs:
+        url: https://pb33f.io`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 0, changes.TotalBreakingChanges())
+	assert.Equal(t, v3.ExternalDocsLabel, changes.Changes[0].Property)
+	assert.Equal(t, ObjectAdded, changes.Changes[0].ChangeType)
+	assert.Equal(t, "2b7adf30f2ea3a7617ccf429a099617a9c03e8b5f3a23a89dba4b90f760010d7",
+		low.HashToString(changes.Changes[0].NewObject.(*base.ExternalDoc).Hash()))
+
+}
+
+func TestCompareSchemas_ExternalDocsRemove(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      type: string`
+
+	right := `components:
+  schemas:
+    OK:
+      type: string
+      externalDocs:
+        url: https://pb33f.io`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(rSchemaProxy, lSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 0, changes.TotalBreakingChanges())
+	assert.Equal(t, v3.ExternalDocsLabel, changes.Changes[0].Property)
+	assert.Equal(t, ObjectRemoved, changes.Changes[0].ChangeType)
+	assert.Equal(t, "2b7adf30f2ea3a7617ccf429a099617a9c03e8b5f3a23a89dba4b90f760010d7",
+		low.HashToString(changes.Changes[0].OriginalObject.(*base.ExternalDoc).Hash()))
+
+}
+
+func TestCompareSchemas_AddExtension(t *testing.T) {
+	left := `components:
+  schemas:
+    OK:
+      type: string`
+
+	right := `components:
+  schemas:
+    OK:
+      type: string
+      x-melody: song`
+
+	leftDoc, rightDoc := test_BuildDoc(left, right)
+
+	// extract left reference schema and non reference schema.
+	lSchemaProxy := leftDoc.Components.Value.FindSchema("OK").Value
+	rSchemaProxy := rightDoc.Components.Value.FindSchema("OK").Value
+
+	changes := CompareSchemas(lSchemaProxy, rSchemaProxy)
+	assert.NotNil(t, changes)
+	assert.Equal(t, 1, changes.TotalChanges())
+	assert.Equal(t, 0, changes.TotalBreakingChanges())
+	assert.Equal(t, "x-melody", changes.ExtensionChanges.Changes[0].Property)
+	assert.Equal(t, ObjectAdded, changes.ExtensionChanges.Changes[0].ChangeType)
+	assert.Equal(t, "song", changes.ExtensionChanges.Changes[0].New)
+}