Fix merge issues

Author: Shwetap05

src/Microsoft.OpenApi/Services/OpenApiComponentsComparer.cs

@@ -77,8 +77,20 @@ public override void Compare(
                     .GetComparer<IDictionary<string, OpenApiHeader>>()
                     .Compare(sourceComponents.Headers, targetComponents.Headers, comparisonContext));
 
-            // To Do compare Examples
-            // To Do compare SecuritySchemes
+            WalkAndCompare(
+                comparisonContext,
+                OpenApiConstants.SecuritySchemes,
+                () => comparisonContext
+                    .GetComparer<IDictionary<string, OpenApiSecurityScheme>>()
+                    .Compare(sourceComponents.SecuritySchemes, targetComponents.SecuritySchemes, comparisonContext));
+
+            WalkAndCompare(
+                comparisonContext,
+                OpenApiConstants.Examples,
+                () => comparisonContext
+                    .GetComparer<IDictionary<string, OpenApiExample>>()
+                    .Compare(sourceComponents.Examples, targetComponents.Examples, comparisonContext));
+
             // To Do compare Links
             // To Do compare Callbacks
         }

src/Microsoft.OpenApi/Services/OpenApiSchemaComparer.cs

@@ -145,92 +145,27 @@ public override void Compare(
                         .Compare(sourceSchema.Items, targetSchema.Items, comparisonContext));
             }
 
-            if (sourceSchema.Reference != null
-                && targetSchema.Reference != null
-                && sourceSchema.Reference.Id != targetSchema.Reference.Id)
-            {
-                WalkAndAddOpenApiDifference(
-                    comparisonContext,
-                    OpenApiConstants.DollarRef,
-                    new OpenApiDifference
-                    {
-                        OpenApiDifferenceOperation = OpenApiDifferenceOperation.Update,
-                        SourceValue = sourceSchema.Reference?.Id,
-                        TargetValue = targetSchema.Reference?.Id,
-                        OpenApiComparedElementType = typeof(string)
-                    });
-
-                return;
-            }
-
-            if (sourceSchema.Reference != null)
-            {
-                sourceSchema = (OpenApiSchema) comparisonContext.SourceDocument.ResolveReference(
-                    sourceSchema.Reference);
-            }
-
-            if (targetSchema.Reference != null)
-            {
-                targetSchema = (OpenApiSchema) comparisonContext.TargetDocument.ResolveReference(
-                    targetSchema.Reference);
-            }
+            WalkAndCompare(
+                comparisonContext,
+                OpenApiConstants.Properties,
+                () => comparisonContext
+                    .GetComparer<IDictionary<string, OpenApiSchema>>()
+                    .Compare(sourceSchema.Properties,
+                        targetSchema.Properties, comparisonContext));
 
-            if (targetSchema.Properties != null)
-            {
-                IEnumerable<string> newPropertiesInTarget = sourceSchema.Properties == null
-                    ? targetSchema.Properties.Keys
-                    : targetSchema.Properties.Keys.Except(sourceSchema.Properties.Keys)
-                        .ToList();
-
-                WalkAndCompare(comparisonContext, OpenApiConstants.Properties, () =>
-                {
-                    foreach (var newPropertyInTarget in newPropertiesInTarget)
-                    {
-                        WalkAndAddOpenApiDifference(
-                            comparisonContext,
-                            newPropertyInTarget,
-                            new OpenApiDifference
-                            {
-                                OpenApiDifferenceOperation = OpenApiDifferenceOperation.Add,
-                                TargetValue = new KeyValuePair<string, OpenApiSchema>(newPropertyInTarget,
-                                    targetSchema.Properties[newPropertyInTarget]),
-                                OpenApiComparedElementType = typeof(KeyValuePair<string, OpenApiSchema>)
-                            });
-                    }
-                });
-            }
+            WalkAndCompare(
+                comparisonContext,
+                OpenApiConstants.ExternalDocs,
+                () => comparisonContext
+                    .GetComparer<OpenApiExternalDocs>()
+                    .Compare(sourceSchema.ExternalDocs, targetSchema.ExternalDocs, comparisonContext));
 
-            if (sourceSchema.Properties != null)
-            {
-                WalkAndCompare(comparisonContext, OpenApiConstants.Properties, () =>
-                {
-                    foreach (var sourceSchemaProperty in sourceSchema.Properties)
-                    {
-                        if (targetSchema.Properties.ContainsKey(sourceSchemaProperty.Key))
-                        {
-                            WalkAndCompare(
-                                comparisonContext,
-                                sourceSchemaProperty.Key,
-                                () => comparisonContext
-                                    .GetComparer<OpenApiSchema>()
-                                    .Compare(sourceSchemaProperty.Value,
-                                        targetSchema.Properties[sourceSchemaProperty.Key], comparisonContext));
-                        }
-                        else
-                        {
-                            WalkAndAddOpenApiDifference(
-                                comparisonContext,
-                                sourceSchemaProperty.Key,
-                                new OpenApiDifference
-                                {
-                                    OpenApiDifferenceOperation = OpenApiDifferenceOperation.Remove,
-                                    SourceValue = sourceSchemaProperty,
-                                    OpenApiComparedElementType = typeof(KeyValuePair<string, OpenApiSchema>)
-                                });
-                        }
-                    }
-                });
-            }
+            WalkAndCompare(
+                comparisonContext,
+                OpenApiConstants.Example,
+                () => comparisonContext
+                    .GetComparer<IOpenApiAny>()
+                    .Compare(sourceSchema.Example, targetSchema.Example, comparisonContext));
 
             // To Do Compare schema.AllOf
             // To Do Compare schema.AnyOf