Merge pull request #2870 from microsoft/chore/additional-coverage

test(coverage): raise merged coverage with targeted unit tests

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/OpenApiYamlReaderTests.cs

@@ -0,0 +1,111 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.OpenApi.Reader;
+using Microsoft.OpenApi.YamlReader;
+using Xunit;
+
+namespace Microsoft.OpenApi.Readers.Tests;
+
+public class OpenApiYamlReaderTests
+{
+    private static readonly Uri DocumentLocation = new("https://contoso.test/openapi.yaml");
+
+    [Fact]
+    public async Task ReadAsyncParsesDocumentsFromNonMemoryStreams()
+    {
+        var reader = new OpenApiYamlReader();
+        await using var stream = new NonMemoryStream(CreateStream(
+            """
+            openapi: 3.0.1
+            info:
+              title: Sample API
+              version: 1.0.0
+            paths: {}
+            """));
+
+        var result = await reader.ReadAsync(stream, DocumentLocation, SettingsFixture.ReaderSettings, CancellationToken.None);
+
+        Assert.NotNull(result.Document);
+        Assert.Equal("Sample API", result.Document.Info.Title);
+        Assert.Equal(OpenApiConstants.Yaml, result.Diagnostic.Format);
+    }
+
+    [Fact]
+    public void ReadThrowsWhenYamlDoesNotContainADocument()
+    {
+        var reader = new OpenApiYamlReader();
+        using var stream = CreateStream(string.Empty);
+
+        var exception = Assert.Throws<InvalidOperationException>(() => reader.Read(stream, DocumentLocation, SettingsFixture.ReaderSettings));
+
+        Assert.Equal("No documents found in the YAML stream.", exception.Message);
+    }
+
+    [Fact]
+    public void ReadFragmentParsesSchemaFragments()
+    {
+        var reader = new OpenApiYamlReader();
+        using var stream = CreateStream(
+            """
+            type: string
+            description: A reusable schema
+            """);
+
+        var schema = reader.ReadFragment<OpenApiSchema>(
+            stream,
+            OpenApiSpecVersion.OpenApi3_0,
+            new OpenApiDocument(),
+            out var diagnostic);
+
+        Assert.NotNull(schema);
+        Assert.Empty(diagnostic.Errors);
+        Assert.Equal(JsonSchemaType.String, schema.Type);
+        Assert.Equal("A reusable schema", schema.Description);
+    }
+
+    [Fact]
+    public void ReadThrowsWhenSettingsIsNull()
+    {
+        var reader = new OpenApiYamlReader();
+        using var stream = CreateStream("openapi: 3.0.1");
+
+        Assert.Throws<ArgumentNullException>(() => reader.Read(stream, DocumentLocation, null!));
+    }
+
+    private static MemoryStream CreateStream(string yaml)
+    {
+        return new MemoryStream(Encoding.UTF8.GetBytes(yaml));
+    }
+
+    private sealed class NonMemoryStream(Stream innerStream) : Stream
+    {
+        public override bool CanRead => innerStream.CanRead;
+        public override bool CanSeek => innerStream.CanSeek;
+        public override bool CanWrite => innerStream.CanWrite;
+        public override long Length => innerStream.Length;
+        public override long Position
+        {
+            get => innerStream.Position;
+            set => innerStream.Position = value;
+        }
+
+        public override void Flush() => innerStream.Flush();
+        public override int Read(byte[] buffer, int offset, int count) => innerStream.Read(buffer, offset, count);
+        public override long Seek(long offset, SeekOrigin origin) => innerStream.Seek(offset, origin);
+        public override void SetLength(long value) => innerStream.SetLength(value);
+        public override void Write(byte[] buffer, int offset, int count) => innerStream.Write(buffer, offset, count);
+        public override ValueTask DisposeAsync() => innerStream.DisposeAsync();
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                innerStream.Dispose();
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}