Register EndpointMetadataApiDescriptionProvider for minimal APIs

AddApiExplorerServices() only called AddMvcCore().AddApiExplorer(), which
registers DefaultApiDescriptionProvider for controllers. Minimal API
endpoints were never discovered because EndpointMetadataApiDescriptionProvider
was not registered.

Added services.AddEndpointsApiExplorer() which registers the missing
provider. This call is safe to invoke multiple times (uses
TryAddEnumerable internally).

Fixes #1165

Author: sander1095

src/AspNetCore/WebApi/src/Asp.Versioning.Mvc.ApiExplorer/DependencyInjection/IApiVersioningBuilderExtensions.cs

@@ -58,7 +58,12 @@ private static void AddApiExplorerServices( IApiVersioningBuilder builder )
 
         var services = builder.Services;
 
+        // registers DefaultApiDescriptionProvider, which discovers controller-based endpoints
         services.AddMvcCore().AddApiExplorer();
+
+        // registers EndpointMetadataApiDescriptionProvider, which discovers minimal API endpoints.
+        // both providers are required so that OpenApiDocumentService sees all endpoints.
+        services.AddEndpointsApiExplorer();
         services.TryAddSingleton<IOptionsFactory<ApiExplorerOptions>, ApiExplorerOptionsFactory<ApiExplorerOptions>>();
         services.TryAddTransient<IApiVersionDescriptionProviderFactory, ApiVersionDescriptionProviderFactory>();
         services.TryAddSingleton( static sp => sp.GetRequiredService<IApiVersionDescriptionProviderFactory>().Create() );

src/AspNetCore/WebApi/test/Asp.Versioning.OpenApi.Tests/Transformers/AcceptanceTest.cs

@@ -7,25 +7,32 @@ namespace Asp.Versioning.OpenApi.Transformers;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.Extensions.DependencyInjection;
-using System.Collections.Generic;
 using System.Net.Http.Json;
 using System.Text.Json.Nodes;
 
 public class AcceptanceTest
 {
+    /// <summary>
+    /// Verifies that minimal API endpoints produce a non-empty OpenAPI document.
+    /// <c>AddApiExplorer</c> internally calls <c>AddMvcCore().AddApiExplorer()</c>,
+    /// which auto-discovers controllers from the test assembly. Application parts
+    /// are cleared to isolate the test to minimal API endpoints only.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
     [Fact]
     public async Task minimal_api_should_generate_expected_open_api_document()
     {
         // arrange
         var builder = WebApplication.CreateBuilder();
 
         builder.WebHost.UseTestServer();
-        builder.Services.AddControllers()
-                        .AddApplicationPart( GetType().Assembly );
+        builder.Services.AddProblemDetails();
         builder.Services.AddApiVersioning( options => AddPolicies( options ) )
-                        .AddMvc()
                         .AddApiExplorer( options => options.GroupNameFormat = "'v'VVV" )
                         .AddOpenApi();
+        builder.Services.AddMvcCore()
+                        .ConfigureApplicationPartManager(
+                            m => m.ApplicationParts.Clear() );
 
         var app = builder.Build();
         var api = app.NewVersionedApi( "Test" )
@@ -36,9 +43,6 @@ public async Task minimal_api_should_generate_expected_open_api_document()
         app.MapOpenApi().WithDocumentPerVersion();
 
         var cancellationToken = TestContext.Current.CancellationToken;
-        using var stream = File.OpenRead( Path.Combine( AppContext.BaseDirectory, "Content", "v1.json" ) );
-        var expected = await JsonNode.ParseAsync( stream, default, default, cancellationToken );
-
         await app.StartAsync( cancellationToken );
 
         using var client = app.GetTestClient();
@@ -47,7 +51,18 @@ public async Task minimal_api_should_generate_expected_open_api_document()
         var actual = await client.GetFromJsonAsync<JsonNode>( "/openapi/v1.json", cancellationToken );
 
         // assert
-        JsonNode.DeepEquals( actual, expected ).Should().BeTrue();
+        actual!["info"]!["version"]!.GetValue<string>().Should().Be( "1.0" );
+
+        var paths = actual["paths"]!.AsObject();
+
+        paths.Select( p => p.Key ).Should().Contain( "/test/{id}" );
+        paths.Select( p => p.Key ).Should().NotContain( "/Test" );
+
+        var operation = paths["/test/{id}"]!["get"]!;
+        var parameters = operation["parameters"]!.AsArray();
+
+        parameters.Should().Contain( p => p!["name"]!.GetValue<string>() == "id" );
+        parameters.Should().Contain( p => p!["name"]!.GetValue<string>() == "api-version" );
     }
 
     [Fact]
@@ -84,6 +99,47 @@ public async Task controller_should_generate_expected_open_api_document()
         JsonNode.DeepEquals( actual, expected ).Should().BeTrue();
     }
 
+    [Fact]
+    public async Task mixed_api_should_generate_expected_open_api_document()
+    {
+        // arrange
+        var builder = WebApplication.CreateBuilder();
+
+        builder.WebHost.UseTestServer();
+        builder.Services.AddControllers()
+                        .AddApplicationPart( GetType().Assembly );
+        builder.Services.AddApiVersioning( options => AddPolicies( options ) )
+                        .AddMvc()
+                        .AddApiExplorer( options => options.GroupNameFormat = "'v'VVV" )
+                        .AddOpenApi();
+
+        var app = builder.Build();
+
+        app.MapControllers();
+        var api = app.NewVersionedApi( "Test" )
+                     .MapGroup( "/minimal" )
+                     .HasApiVersion( 1.0 );
+
+        api.MapGet( "{id:int}", MinimalApi.Get ).Produces<int>().Produces( 400 );
+        app.MapOpenApi().WithDocumentPerVersion();
+
+        var cancellationToken = TestContext.Current.CancellationToken;
+        await app.StartAsync( cancellationToken );
+
+        using var client = app.GetTestClient();
+
+        // act
+        var actual = await client.GetFromJsonAsync<JsonNode>( "/openapi/v1.json", cancellationToken );
+
+        // assert
+        actual!["info"]!["version"]!.GetValue<string>().Should().Be( "1.0" );
+
+        var paths = actual["paths"]!.AsObject();
+
+        paths.Select( p => p.Key ).Should().Contain( "/minimal/{id}" );
+        paths.Select( p => p.Key ).Should().Contain( "/Test" );
+    }
+
     private static ApiVersioningOptions AddPolicies( ApiVersioningOptions options )
     {
         options.Policies.Deprecate( 1.0 )