Merge pull request #2405 from microsoft/chore/additional-schema-test-cases

baywet · web-flow · commit c7f735ba3eb1 · 2025-06-18T16:25:36.000-04:00
avoid stack overflow on cyclical references
diff --git a/src/Microsoft.OpenApi/Models/OpenApiDocument.cs b/src/Microsoft.OpenApi/Models/OpenApiDocument.cs
@@ -498,10 +498,10 @@ public void SetReferenceHostDocument()
         /// <summary>
         /// Load the referenced <see cref="IOpenApiReferenceable"/> object from a <see cref="BaseOpenApiReference"/> object
         /// </summary>
-        internal T? ResolveReferenceTo<T>(BaseOpenApiReference reference) where T : IOpenApiReferenceable
+        internal T? ResolveReferenceTo<T>(BaseOpenApiReference reference, IOpenApiSchema? parentSchema) where T : IOpenApiReferenceable
         {
 
-            if (ResolveReference(reference, reference.IsExternal) is T result)
+            if (ResolveReference(reference, reference.IsExternal, parentSchema) is T result)
             {
                 return result;
             }
@@ -566,7 +566,7 @@ private static string ConvertByteArrayToString(byte[] hash)
         /// <summary>
         /// Load the referenced <see cref="IOpenApiReferenceable"/> object from a <see cref="BaseOpenApiReference"/> object
         /// </summary>
-        internal IOpenApiReferenceable? ResolveReference(BaseOpenApiReference? reference, bool useExternal)
+        internal IOpenApiReferenceable? ResolveReference(BaseOpenApiReference? reference, bool useExternal, IOpenApiSchema? parentSchema)
         {
             if (reference == null)
             {
@@ -621,9 +621,9 @@ private static string ConvertByteArrayToString(byte[] hash)
                 false => new Uri(uriLocation).AbsoluteUri
             };
 
-            if (reference.Type is ReferenceType.Schema && absoluteUri.Contains('#'))
+            if (reference.Type is ReferenceType.Schema && absoluteUri.Contains('#') && parentSchema is not null)
             {
-                return Workspace?.ResolveJsonSchemaReference(absoluteUri);
+                return Workspace?.ResolveJsonSchemaReference(absoluteUri, parentSchema);
             }
 
             return Workspace?.ResolveReference<IOpenApiReferenceable>(absoluteUri);
diff --git a/src/Microsoft.OpenApi/Models/References/BaseOpenApiReferenceHolder.cs b/src/Microsoft.OpenApi/Models/References/BaseOpenApiReferenceHolder.cs
@@ -15,7 +15,7 @@ public virtual U? Target
         get
         {
             if (Reference.HostDocument is null) return default;
-            return Reference.HostDocument.ResolveReferenceTo<U>(Reference);
+            return Reference.HostDocument.ResolveReferenceTo<U>(Reference, this as IOpenApiSchema);
         }
     }
     /// <inheritdoc/>
diff --git a/src/Microsoft.OpenApi/Services/OpenApiWorkspace.cs b/src/Microsoft.OpenApi/Services/OpenApiWorkspace.cs
@@ -331,8 +331,9 @@ public bool Contains(string location)
         /// Recursively resolves a schema from a URI fragment.
         /// </summary>
         /// <param name="location"></param>
+        /// <param name="parentSchema">The parent schema to resolve against.</param>
         /// <returns></returns>
-        internal IOpenApiSchema? ResolveJsonSchemaReference(string location)
+        internal IOpenApiSchema? ResolveJsonSchemaReference(string location, IOpenApiSchema parentSchema)
         {
             /* Enables resolving references for nested subschemas
              * Examples:
@@ -362,14 +363,22 @@ public bool Contains(string location)
             {
                 // traverse remaining segments after fetching the base schema
                 var remainingSegments = pathSegments.Skip(4).ToArray();
-                return ResolveSubSchema(targetSchema, remainingSegments);
+                var stack = new Stack<IOpenApiSchema>();
+                stack.Push(parentSchema);
+                return ResolveSubSchema(targetSchema, remainingSegments, stack);
             }
 
             return default;          
         }
         
-        internal static IOpenApiSchema? ResolveSubSchema(IOpenApiSchema schema, string[] pathSegments)
+        internal static IOpenApiSchema? ResolveSubSchema(IOpenApiSchema schema, string[] pathSegments, Stack<IOpenApiSchema> visitedSchemas)
         {
+            // Prevent infinite recursion in case of circular references
+            if (visitedSchemas.Contains(schema))
+            {
+                return null;
+            }
+            visitedSchemas.Push(schema);
             // Traverse schema object to resolve subschemas
             if (pathSegments.Length == 0)
             {
@@ -383,13 +392,13 @@ public bool Contains(string location)
                 case OpenApiConstants.Properties:
                     var propName = pathSegments[0];
                     if (schema.Properties != null && schema.Properties.TryGetValue(propName, out var propSchema))
-                        return ResolveSubSchema(propSchema, [.. pathSegments.Skip(1)]);
+                        return ResolveSubSchema(propSchema, [.. pathSegments.Skip(1)], visitedSchemas);
                     break;
                 case OpenApiConstants.Items:
-                    return schema.Items is OpenApiSchema itemsSchema ? ResolveSubSchema(itemsSchema, pathSegments) : null;
+                    return schema.Items is OpenApiSchema itemsSchema ? ResolveSubSchema(itemsSchema, pathSegments, visitedSchemas) : null;
 
                 case OpenApiConstants.AdditionalProperties:
-                    return schema.AdditionalProperties is OpenApiSchema additionalSchema ? ResolveSubSchema(additionalSchema, pathSegments) : null;
+                    return schema.AdditionalProperties is OpenApiSchema additionalSchema ? ResolveSubSchema(additionalSchema, pathSegments, visitedSchemas) : null;
                 case OpenApiConstants.AllOf:
                 case OpenApiConstants.AnyOf:
                 case OpenApiConstants.OneOf:
@@ -405,7 +414,7 @@ public bool Contains(string location)
 
                     // recurse into the indexed subschema if valid
                     if (list != null && index < list.Count)
-                        return ResolveSubSchema(list[index], [.. pathSegments.Skip(1)]);
+                        return ResolveSubSchema(list[index], [.. pathSegments.Skip(1)], visitedSchemas);
                     break;
             }
 
diff --git a/test/Microsoft.OpenApi.Readers.Tests/V2Tests/OpenApiDocumentTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V2Tests/OpenApiDocumentTests.cs
@@ -261,7 +261,7 @@ public async Task ShouldAllowComponentsThatJustContainAReference()
             var schema1 = actual.Components.Schemas["AllPets"];
             var schema1Reference = Assert.IsType<OpenApiSchemaReference>(schema1);
             Assert.False(schema1Reference.UnresolvedReference);
-            var schema2 = actual.ResolveReferenceTo<OpenApiSchema>(schema1Reference.Reference);
+            var schema2 = actual.ResolveReferenceTo<OpenApiSchema>(schema1Reference.Reference, schema1Reference);
             Assert.IsType<OpenApiSchema>(schema2);
             if (string.IsNullOrEmpty(schema1Reference.Reference.Id) || schema1Reference.UnresolvedReference)
             {
diff --git a/test/Microsoft.OpenApi.Readers.Tests/V31Tests/RelativeReferenceTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V31Tests/RelativeReferenceTests.cs
@@ -223,7 +223,7 @@ public void ResolveSubSchema_ShouldTraverseKnownKeywords()
 
             var path = new[] { "properties", "a", "properties", "b" };
 
-            var result = OpenApiWorkspace.ResolveSubSchema(schema, path);
+            var result = OpenApiWorkspace.ResolveSubSchema(schema, path, []);
 
             Assert.NotNull(result);
             Assert.Equal(JsonSchemaType.String, result!.Type);
@@ -250,7 +250,7 @@ public void ResolveSubSchema_ShouldHandleUserDefinedKeywordNamedProperty(string[
                 }
             };
 
-            var result = OpenApiWorkspace.ResolveSubSchema(schema, pathSegments);
+            var result = OpenApiWorkspace.ResolveSubSchema(schema, pathSegments, []);
 
             Assert.NotNull(result);
             Assert.Equal(JsonSchemaType.String, result!.Type);
@@ -275,7 +275,7 @@ public void ResolveSubSchema_ShouldRecurseIntoAllOfComposition()
 
             var path = new[] { "allOf", "0", "properties", "x" };
 
-            var result = OpenApiWorkspace.ResolveSubSchema(schema, path);
+            var result = OpenApiWorkspace.ResolveSubSchema(schema, path, []);
 
             Assert.NotNull(result);
             Assert.Equal(JsonSchemaType.Integer, result!.Type);
@@ -434,6 +434,81 @@ public async Task ShouldResolveReferencesInSchemasFromSystemTextJson()
             var updatedTagsProperty = Assert.IsType<OpenApiSchemaReference>(schema.Properties["tags"]);
             Assert.Equal(absoluteReferenceId, updatedTagsProperty.Reference.ReferenceV3);
             Assert.Equal(JsonSchemaType.Array | JsonSchemaType.Null, updatedTagsProperty.Type);
+            Assert.Equal(JsonSchemaType.Object, updatedTagsProperty.Items.Type);
+
+
+            // doing the same for the parent property
+
+            var parentProperty = Assert.IsType<OpenApiSchema>(schema.Properties["parent"]);
+            var parentSubProperty = Assert.IsType<OpenApiSchemaReference>(parentProperty.Properties["parent"]);
+            Assert.Equal("#/properties/parent", parentSubProperty.Reference.ReferenceV3);
+            parentProperty.Properties["parent"] = new OpenApiSchemaReference($"#/components/schemas/Foo{parentSubProperty.Reference.ReferenceV3.Replace("#", string.Empty)}", document);
+            var updatedParentSubProperty = Assert.IsType<OpenApiSchemaReference>(parentProperty.Properties["parent"]);
+            Assert.Equal(JsonSchemaType.Object | JsonSchemaType.Null, updatedParentSubProperty.Type);
+
+            var pathItem = new OpenApiPathItem
+            {
+                Operations = new Dictionary<HttpMethod, OpenApiOperation>
+                {
+                    [HttpMethod.Post] = new OpenApiOperation
+                    {
+                        Responses = new OpenApiResponses
+                        {
+                            ["200"] = new OpenApiResponse
+                            {
+                            }
+                        },
+                        RequestBody = new OpenApiRequestBody
+                        {
+                            Content = new Dictionary<string, OpenApiMediaType>
+                            {
+                                ["application/json"] = new OpenApiMediaType
+                                {
+                                    Schema = new OpenApiSchemaReference("#/components/schemas/Foo", document)
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+            document.Paths.Add("/", pathItem);
+
+            var requestBodySchema = pathItem.Operations[HttpMethod.Post].RequestBody.Content["application/json"].Schema;
+            Assert.NotNull(requestBodySchema);
+            var requestBodyTagsProperty = Assert.IsType<OpenApiSchemaReference>(requestBodySchema.Properties["tags"]);
+            Assert.Equal(JsonSchemaType.Object, requestBodyTagsProperty.Items.Type);
+        }
+
+        [Fact]
+        public void ExitsEarlyOnCyclicalReferences()
+        {
+            var document = new OpenApiDocument
+            {
+                Info = new OpenApiInfo { Title = "Test API", Version = "1.0.0" },
+            };
+            var categorySchema = new OpenApiSchema
+            {
+                Type = JsonSchemaType.Object,
+                Properties = new Dictionary<string, IOpenApiSchema>
+                {
+                    ["name"] = new OpenApiSchema { Type = JsonSchemaType.String },
+                    ["parent"] = new OpenApiSchemaReference("#/components/schemas/Category", document),
+                    // this is intentionally wrong and cyclical reference
+                    // it tests whether we're going in an infinite resolution loop
+                    ["tags"] = new OpenApiSchemaReference("#/components/schemas/Category/properties/parent/properties/tags", document)
+                }
+            };
+            document.AddComponent("Category", categorySchema);
+            document.RegisterComponents();
+
+            var tagsSchemaRef = Assert.IsType<OpenApiSchemaReference>(categorySchema.Properties["tags"]);
+            Assert.Null(tagsSchemaRef.Items);
+            Assert.Equal("#/components/schemas/Category/properties/parent/properties/tags", tagsSchemaRef.Reference.ReferenceV3);
+            Assert.Null(tagsSchemaRef.Target);
+
+            var parentSchemaRef = Assert.IsType<OpenApiSchemaReference>(categorySchema.Properties["parent"]);
+            Assert.Equal("#/components/schemas/Category", parentSchemaRef.Reference.ReferenceV3);
+            Assert.NotNull(parentSchemaRef.Target);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -498,10 +498,10 @@ public void SetReferenceHostDocument()`
`498`	`498`	`/// <summary>`
`499`	`499`	`/// Load the referenced <see cref="IOpenApiReferenceable"/> object from a <see cref="BaseOpenApiReference"/> object`
`500`	`500`	`/// </summary>`
`501`		`- internal T? ResolveReferenceTo<T>(BaseOpenApiReference reference) where T : IOpenApiReferenceable`
	`501`	`+ internal T? ResolveReferenceTo<T>(BaseOpenApiReference reference, IOpenApiSchema? parentSchema) where T : IOpenApiReferenceable`
`502`	`502`	`{`
`503`	`503`
`504`		`- if (ResolveReference(reference, reference.IsExternal) is T result)`
	`504`	`+ if (ResolveReference(reference, reference.IsExternal, parentSchema) is T result)`
`505`	`505`	`{`
`506`	`506`	`return result;`
`507`	`507`	`}`
`@@ -566,7 +566,7 @@ private static string ConvertByteArrayToString(byte[] hash)`
`566`	`566`	`/// <summary>`
`567`	`567`	`/// Load the referenced <see cref="IOpenApiReferenceable"/> object from a <see cref="BaseOpenApiReference"/> object`
`568`	`568`	`/// </summary>`
`569`		`- internal IOpenApiReferenceable? ResolveReference(BaseOpenApiReference? reference, bool useExternal)`
	`569`	`+ internal IOpenApiReferenceable? ResolveReference(BaseOpenApiReference? reference, bool useExternal, IOpenApiSchema? parentSchema)`
`570`	`570`	`{`
`571`	`571`	`if (reference == null)`
`572`	`572`	`{`
`@@ -621,9 +621,9 @@ private static string ConvertByteArrayToString(byte[] hash)`
`621`	`621`	`false => new Uri(uriLocation).AbsoluteUri`
`622`	`622`	`};`
`623`	`623`
`624`		`- if (reference.Type is ReferenceType.Schema && absoluteUri.Contains('#'))`
	`624`	`+ if (reference.Type is ReferenceType.Schema && absoluteUri.Contains('#') && parentSchema is not null)`
`625`	`625`	`{`
`626`		`- return Workspace?.ResolveJsonSchemaReference(absoluteUri);`
	`626`	`+ return Workspace?.ResolveJsonSchemaReference(absoluteUri, parentSchema);`
`627`	`627`	`}`
`628`	`628`
`629`	`629`	`return Workspace?.ResolveReference<IOpenApiReferenceable>(absoluteUri);`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public virtual U? Target`
`15`	`15`	`get`
`16`	`16`	`{`
`17`	`17`	`if (Reference.HostDocument is null) return default;`
`18`		`- return Reference.HostDocument.ResolveReferenceTo<U>(Reference);`
	`18`	`+ return Reference.HostDocument.ResolveReferenceTo<U>(Reference, this as IOpenApiSchema);`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`	`/// <inheritdoc/>`
Original file line number	Diff line number	Diff line change
`@@ -261,7 +261,7 @@ public async Task ShouldAllowComponentsThatJustContainAReference()`
`261`	`261`	`var schema1 = actual.Components.Schemas["AllPets"];`
`262`	`262`	`var schema1Reference = Assert.IsType<OpenApiSchemaReference>(schema1);`
`263`	`263`	`Assert.False(schema1Reference.UnresolvedReference);`
`264`		`- var schema2 = actual.ResolveReferenceTo<OpenApiSchema>(schema1Reference.Reference);`
	`264`	`+ var schema2 = actual.ResolveReferenceTo<OpenApiSchema>(schema1Reference.Reference, schema1Reference);`
`265`	`265`	`Assert.IsType<OpenApiSchema>(schema2);`
`266`	`266`	`if (string.IsNullOrEmpty(schema1Reference.Reference.Id) \|\| schema1Reference.UnresolvedReference)`
`267`	`267`	`{`