test(coverage): add reader and walker edge tests

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: baywet

test/Microsoft.OpenApi.Hidi.Tests/OpenApiSpecVersionHelperTests.cs

@@ -0,0 +1,31 @@
+#nullable enable
+using System;
+using Microsoft.OpenApi.Hidi;
+using Xunit;
+
+namespace Microsoft.OpenApi.Hidi.Tests;
+
+public class OpenApiSpecVersionHelperTests
+{
+    [Theory]
+    [InlineData("2.0", OpenApiSpecVersion.OpenApi2_0)]
+    [InlineData("3.0", OpenApiSpecVersion.OpenApi3_0)]
+    [InlineData("3.1", OpenApiSpecVersion.OpenApi3_1)]
+    [InlineData("3.2", OpenApiSpecVersion.OpenApi3_2)]
+    [InlineData("4.0", OpenApiSpecVersion.OpenApi3_2)]
+    public void TryParseOpenApiSpecVersionReturnsExpectedVersion(string version, OpenApiSpecVersion expectedVersion)
+    {
+        var result = OpenApiSpecVersionHelper.TryParseOpenApiSpecVersion(version);
+
+        Assert.Equal(expectedVersion, result);
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("abc")]
+    public void TryParseOpenApiSpecVersionThrowsForInvalidValues(string? version)
+    {
+        Assert.Throws<InvalidOperationException>(() => OpenApiSpecVersionHelper.TryParseOpenApiSpecVersion(version!));
+    }
+}

test/Microsoft.OpenApi.Hidi.Tests/Services/OpenApiFilterServiceTests.cs

@@ -221,6 +221,72 @@ public void ThrowsInvalidOperationExceptionInCreatePredicateWhenInvalidArguments
             Assert.Equal("Cannot specify both operationIds and tags at the same time.", message2);
         }
 
+        [Fact]
+        public void ThrowsInvalidOperationExceptionWhenRequestUrlsAreCombinedWithOtherFilters()
+        {
+            var requestUrls = new Dictionary<string, List<string>>
+            {
+                ["/users"] = ["GET"]
+            };
+
+            var message = Assert.Throws<InvalidOperationException>(() =>
+                OpenApiFilterService.CreatePredicate("users.user.ListUser", null, requestUrls, _openApiDocumentMock)).Message;
+
+            Assert.Equal("Cannot filter by Postman collection and either operationIds and tags at the same time.", message);
+        }
+
+        [Fact]
+        public void ThrowsWhenPredicateDoesNotMatchAnyPath()
+        {
+            var source = new OpenApiDocument
+            {
+                Info = new() { Title = "Test", Version = "1.0" },
+                Paths = new()
+                {
+                    ["/test"] = new OpenApiPathItem
+                    {
+                        Operations = new()
+                        {
+                            [HttpMethod.Get] = new OpenApiOperation { OperationId = "getTest" }
+                        }
+                    }
+                }
+            };
+
+            var subset = OpenApiFilterService.CreateFilteredDocument(source, static (_, _, _) => false);
+
+            Assert.Empty(subset.Paths);
+        }
+
+        [Fact]
+        public void CreatePredicateMatchesAbsoluteUrlsWhenSourceHasNoServers()
+        {
+            var source = new OpenApiDocument
+            {
+                Info = new() { Title = "Test", Version = "v1" },
+                Paths = new()
+                {
+                    ["/users"] = new OpenApiPathItem
+                    {
+                        Operations = new()
+                        {
+                            [HttpMethod.Get] = new OpenApiOperation { OperationId = "listUsers" }
+                        }
+                    }
+                }
+            };
+            var requestUrls = new Dictionary<string, List<string>>
+            {
+                ["https://graph.contoso.com/users"] = ["GET"]
+            };
+
+            var predicate = OpenApiFilterService.CreatePredicate(requestUrls: requestUrls, source: source);
+            var subset = OpenApiFilterService.CreateFilteredDocument(source, predicate);
+
+            Assert.Single(subset.Paths);
+            Assert.True(subset.Paths.ContainsKey("/users"));
+        }
+
         [Fact]
         public async Task CopiesOverAllReferencedComponentsToTheSubsetDocumentCorrectly()
         {

test/Microsoft.OpenApi.Hidi.Tests/StatsVisitorTests.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using Xunit;
+
+namespace Microsoft.OpenApi.Hidi.Tests;
+
+public class StatsVisitorTests
+{
+    [Fact]
+    public void GetStatisticsReportReflectsVisitedElements()
+    {
+        var document = new OpenApiDocument
+        {
+            Paths = new()
+            {
+                ["/pets"] = new OpenApiPathItem
+                {
+                    Operations = new()
+                    {
+                        [HttpMethod.Post] = new OpenApiOperation
+                        {
+                            Parameters =
+                            [
+                                new OpenApiParameter
+                                {
+                                    Name = "expand",
+                                    In = ParameterLocation.Query,
+                                    Schema = new OpenApiSchema { Type = JsonSchemaType.String }
+                                }
+                            ],
+                            RequestBody = new OpenApiRequestBody
+                            {
+                                Content = new Dictionary<string, IOpenApiMediaType>
+                                {
+                                    ["application/json"] = new OpenApiMediaType
+                                    {
+                                        Schema = new OpenApiSchema
+                                        {
+                                            Type = JsonSchemaType.Object,
+                                            Properties = new Dictionary<string, IOpenApiSchema>
+                                            {
+                                                ["name"] = new OpenApiSchema { Type = JsonSchemaType.String }
+                                            }
+                                        }
+                                    }
+                                }
+                            },
+                            Responses = new OpenApiResponses
+                            {
+                                ["200"] = new OpenApiResponse
+                                {
+                                    Headers = new Dictionary<string, IOpenApiHeader>
+                                    {
+                                        ["x-rate-limit"] = new OpenApiHeader
+                                        {
+                                            Schema = new OpenApiSchema { Type = JsonSchemaType.Integer }
+                                        }
+                                    },
+                                    Links = new Dictionary<string, IOpenApiLink>
+                                    {
+                                        ["next"] = new OpenApiLink()
+                                    }
+                                }
+                            },
+                            Callbacks = new Dictionary<string, IOpenApiCallback>
+                            {
+                                ["onData"] = new OpenApiCallback
+                                {
+                                    PathItems = new Dictionary<RuntimeExpression, IOpenApiPathItem>
+                                    {
+                                        [RuntimeExpression.Build("$request.body#/callbackUrl")] = new OpenApiPathItem
+                                        {
+                                            Operations = new()
+                                            {
+                                                [HttpMethod.Post] = new OpenApiOperation
+                                                {
+                                                    Responses = new OpenApiResponses
+                                                    {
+                                                        ["202"] = new OpenApiResponse { Description = "Accepted" }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        var visitor = new StatsVisitor();
+        new OpenApiWalker(visitor).Walk(document);
+        var report = visitor.GetStatisticsReport();
+
+        Assert.Equal(2, visitor.PathItemCount);
+        Assert.Equal(2, visitor.OperationCount);
+        Assert.Equal(1, visitor.ParameterCount);
+        Assert.Equal(1, visitor.RequestBodyCount);
+        Assert.Equal(2, visitor.ResponseCount);
+        Assert.Equal(1, visitor.LinkCount);
+        Assert.Equal(1, visitor.CallbackCount);
+        Assert.Equal(4, visitor.SchemaCount);
+        Assert.Contains("Path Items: 2", report, StringComparison.Ordinal);
+        Assert.Contains("Callbacks: 1", report, StringComparison.Ordinal);
+        Assert.Contains("Schemas: 4", report, StringComparison.Ordinal);
+    }
+}

test/Microsoft.OpenApi.Hidi.Tests/Utilities/SettingsUtilitiesTests.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Configuration;
+using Microsoft.OpenApi.Hidi.Utilities;
+using Microsoft.OpenApi.OData;
+using Xunit;
+
+namespace Microsoft.OpenApi.Hidi.Tests;
+
+public class SettingsUtilitiesTests
+{
+    [Fact]
+    public void GetOpenApiConvertSettingsThrowsWhenConfigurationIsNull()
+    {
+        Assert.Throws<ArgumentNullException>(() => SettingsUtilities.GetOpenApiConvertSettings(null!, null));
+    }
+
+    [Fact]
+    public void GetOpenApiConvertSettingsUsesMetadataVersionWhenSectionIsMissing()
+    {
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string, string?>()).Build();
+
+        var settings = SettingsUtilities.GetOpenApiConvertSettings(configuration, "2.1");
+
+        Assert.Equal("2.1", settings.SemVerVersion);
+    }
+
+    [Fact]
+    public void GetOpenApiConvertSettingsBindsConfiguredValuesOverMetadataVersion()
+    {
+        var configuration = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                [$"{nameof(OpenApiConvertSettings)}:{nameof(OpenApiConvertSettings.SemVerVersion)}"] = "3.0",
+                [$"{nameof(OpenApiConvertSettings)}:{nameof(OpenApiConvertSettings.EnablePagination)}"] = bool.TrueString
+            })
+            .Build();
+
+        var settings = SettingsUtilities.GetOpenApiConvertSettings(configuration, "2.1");
+
+        Assert.Equal("3.0", settings.SemVerVersion);
+        Assert.True(settings.EnablePagination);
+    }
+}

test/Microsoft.OpenApi.Readers.Tests/V2Tests/OpenApiDocumentFixupTests.cs

@@ -0,0 +1,106 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Text;
+using Microsoft.OpenApi.Reader;
+using Microsoft.OpenApi.YamlReader;
+using Xunit;
+
+namespace Microsoft.OpenApi.Readers.Tests.V2Tests;
+
+public class OpenApiDocumentFixupTests
+{
+    private static readonly Uri DocumentLocation = new("https://contoso.test/swagger.yaml");
+
+    [Fact]
+    public void ReadCreatesServersFromHostBasePathAndSchemes()
+    {
+        var result = ReadDocument(
+            """
+            swagger: "2.0"
+            info:
+              title: Sample API
+              version: "1.0"
+            host: api.contoso.com:443
+            basePath: /v1/
+            schemes:
+              - https
+            paths: {}
+            """);
+
+        Assert.NotNull(result.Document);
+        Assert.Empty(result.Diagnostic.Errors);
+        var server = Assert.Single(result.Document.Servers);
+        Assert.Equal("https://api.contoso.com/v1", server.Url);
+    }
+
+    [Theory]
+    [InlineData("https://api.contoso.com")]
+    [InlineData("api contoso com")]
+    public void ReadAddsDiagnosticErrorWhenHostIsInvalid(string host)
+    {
+        var result = ReadDocument(
+            $$"""
+            swagger: "2.0"
+            info:
+              title: Sample API
+              version: "1.0"
+            host: {{host}}
+            paths: {}
+            """);
+
+        Assert.NotNull(result.Document);
+        var error = Assert.Single(result.Diagnostic.Errors);
+        Assert.Contains("Invalid host", error.Message, StringComparison.Ordinal);
+        Assert.Empty(result.Document.Servers);
+    }
+
+    [Fact]
+    public void ReadMovesReferencedBodyParametersToRequestBodies()
+    {
+        var result = ReadDocument(
+            """
+            swagger: "2.0"
+            info:
+              title: Sample API
+              version: "1.0"
+            paths:
+              /pets:
+                post:
+                  parameters:
+                    - $ref: '#/parameters/PetBody'
+                  responses:
+                    '200':
+                      description: ok
+            parameters:
+              PetBody:
+                name: pet
+                in: body
+                required: true
+                schema:
+                  type: object
+                  properties:
+                    name:
+                      type: string
+            """);
+
+        Assert.NotNull(result.Document);
+        Assert.Empty(result.Diagnostic.Errors);
+        var requestBody = Assert.IsType<OpenApiRequestBodyReference>(result.Document.Paths["/pets"].Operations[HttpMethod.Post].RequestBody);
+        Assert.Equal("PetBody", requestBody.Reference.Id);
+        Assert.NotNull(result.Document.Components);
+        var componentRequestBody = Assert.IsType<OpenApiRequestBody>(result.Document.Components.RequestBodies["PetBody"]);
+        Assert.True(componentRequestBody.Required);
+        Assert.Contains("application/json", componentRequestBody.Content.Keys);
+        Assert.Empty(result.Document.Paths["/pets"].Operations[HttpMethod.Post].Parameters);
+    }
+
+    private static ReadResult ReadDocument(string yaml)
+    {
+        var settings = new OpenApiReaderSettings();
+        settings.AddYamlReader();
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(yaml));
+
+        return new OpenApiYamlReader().Read(stream, DocumentLocation, settings);
+    }
+}